如何给一个函数的值从另一个函数在Python

Question

我有解决一元二次方程的功能：

class QuadEq(object): 
    def __init__(self, a, b, c): 
     self.a = a 
     self.b = b 
     self.c = c 

    def solve_quad_eq(self): 
     D = self.b**2-4*self.a*self.c 
     if D >= 0: 
      x1 = (-self.b-math.sqrt(D))/2*self.a 
      x2 = (-self.b+math.sqrt(D))/2*self.a 
      answer = [x1, x2] 
      return answer 
     else: 
      return 0 

然后在相同的I类有功能：

def show_result(self): 
    print answer 

那如果需要的话打印二次方程的答案。

我怎样才能把这个功能答案列表从它上面的功能打印？

Answer 1

简答题已经发布。使用instance variable（self.answer）：

class QuadEq(object): 
    def __init__(self, a, b, c): 
     self.a = a 
     self.b = b 
     self.c = c 

    def solve_quad_eq(self): 
     self.answer = ("this", "that") 
     return self.answer 

    def show_result(self): 
     print self.answer 


eq = QuadEq(1,2,3) 

eq.solve_quad_eq() 
eq.show_result() 

宽泛地说，一个实例变量（数据成员）仅仅是一个可变为之寿命是相同的它的“所有者”的一个（在本例中，对象参考eq）。

---

而现在，为长 - 和稍微迂腐 - 答案：设计一个类时，你必须考虑其responsibilities及其state。简单地说，你们班的目的是什么？它只是一个容器各种或多或少相关的功能？在这种情况下，上述答案完全可以接受。但通常情况下，您必须更加严格 - 至少要提高代码的可理解性/可维护性。

这里您有QuadEq class。通过它的名字，我了解了这个类的一个实例一个方程。由于这样的方程的根是一个性质方程的，我认为是可以接受的方法solve_quad_eq是该类的方法。随着轻微的变化，我会使用更通用的名称solve。为什么？因为这为未来的类提供了相同的语义。另外，返回结果和将其存储在实例变量中可能会造成混淆。你应该在这里做出选择。不要提到你的函数有时会返回根的事实，其他时候根的数量（0）。

现在，印刷。我对此更怀疑。显示自己不是一个方程的“本地”属性。如果你这样做，你很快就不得不面对与“等式”完全无关的问题来处理你的（s）方程类：如何写入一个文件？二进制或文本？我应该使用哪种编码？如何处理I/O错误？等等...

所以，如果我是你，我会推向separation of concern，只提供一个“访问器”方法来返回根，并从外部显示它们。由于这看起来很重要，所以我在这里保持该访问器和方法之间的分离（对于某些类型的方程可能是计算密集型的）。使用实例变量self.answer仅仅是作为一个高速缓存（memoization）

这是一个完整的例子：

class Eq(object): 
    def __init__(self): 
     self.answer = None # this should be calles "roots", no? 

    def roots(self): 
     if self.answer is None: 
      self.solve() 

     return self.answer 

class QuadEq(Eq): 
    def __init__(self, a, b, c): 
     Eq.__init__(self) 

     self.a = a 
     self.b = b 
     self.c = c 

    def solve(self): 
     self.answer = ("this", "that") 
     return 2 

eq = QuadEq(1,2,3) 
print(eq.roots()) 

请注意，现在是多么容易添加其他种类的公式在程序来解决.. 。

class OtherEq(Eq): 
    def __init__(self, a, b, c): 
     Eq.__init__(self) 

     self.a = a 
     self.b = b 
     self.c = c 

    def solve(self): 
     self.answer = ("it",) 
     return 1 

...更重要的是，该代码使用的是新的公式几乎是一样的前一个：

eq = OtherEq(1,2,3) 
print(eq.roots()) 

Answer 2

给答案一个类的成员。并通过self.answer来引用它。

class QuadEq(object): 
    def __init__(self, a, b, c): 
     self.a = a 
     self.b = b 
     self.c = c 
     self.answer = [] 


    def solve_quad_eq(self): 
     D = self.b**2-4*self.a*self.c 
     if D >= 0: 
      x1 = (-self.b-math.sqrt(D))/2*self.a 
      x2 = (-self.b+math.sqrt(D))/2*self.a 
      self.answer = [x1, x2] 
      return self.answer 
     else: 
      return 0 

    def show_result(self): 
     print self.answer 

Answer 3

储存于对象本身：

class QuadEq(object): 
    def __init__(self, a, b, c): 
     self.a = a 
     self.b = b 
     self.c = c 
     self.solution = None 

    def solve_quad_eq(self): 
     if self.solution is None: 
      D = self.b**2-4*self.a*self.c 
      if D >= 0: 
       x1 = (-self.b-math.sqrt(D))/2*self.a 
       x2 = (-self.b+math.sqrt(D))/2*self.a 
       self.solution = [x1, x2] 
      else: 
       self.solution = 0 
     return self.solution 

    def show_result(self): # <--- just an alias to solve_quad_eq 
     return self.solve_quad_eq() 

Answer 4

保持answer作为成员变量。

def solve_quad_eq(self): 
    D = self.b**2-4*self.a*self.c 
    if D >= 0: 
     x1 = (-self.b-math.sqrt(D))/2*self.a 
     x2 = (-self.b+math.sqrt(D))/2*self.a 
     self.answer = [x1, x2] 
     return self.answer 
    else: 
     return 0 

def show_result(self): 
    print self.answer 

Answer 5

你不可能真的;除非你这样回答

class QuadEq(object): 
    def __init__(self, a, b, c): 
     self.a = a 
     self.b = b 
     self.c = c 

    def solve_quad_eq(self): 
     D = self.b**2-4*self.a*self.c 
     if D >= 0: 
      x1 = (-self.b-math.sqrt(D))/2*self.a 
      x2 = (-self.b+math.sqrt(D))/2*self.a 
      answer = [x1, x2] 
      return answer 
     else: 
      return 0 

    def show_result(self): 
     if self.answer is None: 
      self.answer = solve_quad_eq() 
     print self.answer 

类的成员，或做一些简单的像这样...

def show_result(self): 
    print self.solve_quad_eq() 

Answer 6

你可以抛出一个异常，如果该功能是在错误的顺序运行：

class QuadEq(object): 
def __init__(self, a, b, c): 
    self.answer = None 

    #Rest of program... 

def show_result(self): 
    if self.answer is None: 
     raise RuntimeError('Error in QuadEq, tried to print result before solving equation') 
    print self.answer