如何避免设计成员函数相互依赖的类？

Question

假设我有一个类叫做加法器：

class adder(object):
  def __init__(self, a, b):
     self.a=a
     self.b=b
     self.result = None

  def perform_addition(self):
     self.result = self.a + self.b
     return self.result

如果我实例化这个类：

myAdder = adder(1,2)

那么我的加法器结果取决于首先调用perform\u addition（），否则它将始终保持为无。换句话说，对于自我结果. 如果我们外推，一个更复杂的类可以有一个依赖链：也就是说，你必须在D之前调用函数a、B和C，因为它们反过来填充下一个函数需要的必要变量。你知道吗

这个班级设计不好吗？有什么补救办法？ 我认为上面的例子是：https://en.wikipedia.org/wiki/Sequential_coupling

Answer 1

我认为这完全取决于你想做什么，以及你想怎么做。如果您希望对'perform\u addition（）'的值有一个静态依赖，那么您拥有的代码不一定是坏的自我结果' . 但是如果您想要一个动态依赖，那么下面的代码将是一个好的简单方法。这样，当通过实例化值为“a”和“b”的类来创建对象时自我结果'将自动计算。你也可以使用更高级的工具，比如属性、装饰器、描述符等等，就像我说的，这完全取决于你想要什么。你知道吗

Class adder(object):
    def __init__(self, a, b):
        self.a=a
        self.b=b
        self.result = self.perform_addition()

    def perform_addition(self):
        self.result = self.a + self.b
        return self.result

Answer 2

将result改为属性是一个很好的例子，这样只有在访问result属性时才执行加法：

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

    @property
    def result(self):
        return self.a + self.b

myAdder = adder(1,2)
print(myAdder.result)

输出：3

如果result属性需要多次访问，并且所涉及的计算代价高昂，则可以将结果保存在实例变量中以避免重新计算：

class adder(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
        self._result = None

    @property
    def result(self):
        if self._result is None:
            self._result = self.a + self.b
        return self._result