如何从Python中的另一个函数中为函数赋值

我有一个解二次方程的函数：

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):
    print answer

如果我们需要的话，可以打印二次方程的答案

---

如何将上面函数中的答案列表提供给此函数以打印？

使答案成为类的成员。并通过自我回答引用它

---

让答案成为班上的一员。并通过自我回答引用它

---

将其存储在对象本身中：

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()

---

将其存储在对象本身中：

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保留为成员变量

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保留为成员变量

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

---

你真的不能；除非你让答案成为这个班的一员

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()

---

你真的不能；除非你让答案成为这个班的一员

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()

---

如果函数以错误的顺序运行，则可能引发异常：

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

---

如果函数以错误的顺序运行，则可能引发异常：

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

---

简短的答案已经发布了。使用自我回答：

不严格地说，实例变量数据成员只是一个变量，其生命周期与示例中其所有者的生命周期相同，即eq引用的对象

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

这里有一个QuadEq类。通过它的名字，我知道这个类的一个实例模拟了一个等式。由于这样一个方程的根是该方程的一个性质，我认为可以接受将该方法作为该类方法来求解。稍作修改后，我将使用更通用的名称solve。为什么？因为这为将来的不同方程类提供了相同的语义。此外，返回结果和将结果存储在实例变量中可能会令人困惑。你应该在这里做出选择。不提函数有时返回根的事实，其他时间根的数量为0

现在，印刷。我更怀疑这一点。显示本身不是方程式的固有属性。如果你这样做，你很快就会在你的方程类中处理与方程完全无关的问题：如何在文件中写入？二进制还是文本？我应该使用哪种编码？如何处理I/O错误？等等

因此，如果我是你，我会推动，只提供一个访问器方法来返回根，并从外部显示它们。因为这似乎很重要，我在这里保留了访问器和求解方法之间的分离，对于某些类型的方程，它们可能需要大量的计算。仅将实例变量self.answer用作缓存

以下是一个完整的示例：

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())

---

简短的答案已经发布了。使用自我回答：

不严格地说，实例变量数据成员只是一个变量，其生命周期与示例中其所有者的生命周期相同，即eq引用的对象

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

这里有一个QuadEq类。通过它的名字，我知道这个类的一个实例模拟了一个等式。由于这样一个方程的根是该方程的一个性质，我认为可以接受将该方法作为该类方法来求解。稍作修改后，我将使用更通用的名称solve。为什么？因为这为将来的不同方程类提供了相同的语义。此外，返回结果和将结果存储在实例变量中可能会令人困惑。你应该在这里做出选择。不提函数有时返回根的事实，其他时间根的数量为0

现在，印刷。我更怀疑这一点。显示本身不是方程式的固有属性。如果你这样做，你很快就会在你的方程类中处理与方程完全无关的问题：如何在文件中写入？二进制o r文本？我应该使用哪种编码？如何处理I/O错误？等等

因此，如果我是你，我会推动，只提供一个访问器方法来返回根，并从外部显示它们。因为这似乎很重要，我在这里保留了访问器和求解方法之间的分离，对于某些类型的方程，它们可能需要大量的计算。仅将实例变量self.answer用作缓存

以下是一个完整的示例：

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())

---

return self.solve_quad_eqself可能应该是return self.solve_quad_eqreturn self.solve_quad_eqself可能应该是return self.solve_quad_eqself。