类的惰性计算

Question

我希望能够对一个类的实例执行操作，但是延迟实际的计算单元，直到另一个类调用它们运行

我下面的（简化的）代码有效。Foo（此处：f3和f4）的实例仅在我调用FooStorage上的run()时计算，它存储了Foo的所有实例

问题：有没有一种方法可以通过内置机制（如__add__方法上的装饰器）实现这一点？

import operator as op

MathOps = {"+":op.add, "*": op.mul} 

class FooStorage():
    def __init__(self):
        self.foo_list = []

    def add_to_foolist(self,foo):
        self.foo_list.append(foo)

    def run(self):
        for f in self.foo_list:
            f._calc()

class Foo():
    def __init__(self,storage, values=None, op=None):
        self._foostorage = storage
        self.values = values
        storage.add_to_foolist(self)
        self.op = op


    def __add__(self,other):
        op = ("+",self,other)
        return Foo(self._foostorage, op=op)

    def __mul__(self, other):
        pass
        # to come

    def _calc(self):
        if self.op:
            op, left, right = self.op
            self.values = MathOps[op](left.values,right.values)


fs = FooStorage()
f1 = Foo(fs, values=1)
f2 = Foo(fs,values=2)
f3 = f1 + f2 # update f3 value only once fs.run() is called
f4 = f3 + f1 # update f4 value only once fs.run() is called

fs.run() # triggers calculation
f4.values