如何避免Python类中多个依赖函数重复计算并存储结果？

需要计算多个互相依赖的变量，这些变量可被其他变量调用，最初采用类方法实现：

class Variables:
    def __init__(self, param1, param2):
        self._param1 = param1
        self._param2 = param2
    
    def var1(self):
        return self._param1 + 'foo'
    def var2(self):
        return var1() + 'bar'
    # ... 省略中间变量定义
    def var9(self):
        return var2() + var8()
    def var10(self):
        return var3() + var9()

问题在于外部调用时，中间函数var1至var9会被重复计算。尝试在__init__中预计算这些变量：

def var1(self):
    return self._param1 + 'foo'
def var2(self):
    return self._var1 + 'bar'
# ... 省略中间变量定义
def var9(self):
    return self._var2 + self._var8
def var10(self):
    return self._var3 + self._var9


class Variables:
    def __init__(self, param1, param2):
        self._param1 = param1
        self._param2 = param2
        
        self._var1 = var1(self)
        self._var2 = var2(self)
        # ... 省略中间变量预计算
        self._var9 = var9(self)
        self._var10 = var10(self)

但这种方案存在类内外self使用不一致的问题，且需要保留10个独立函数，无法合并为一个大函数，请问最优的计算与存储方式是什么？

方案1：Python 3.8+ 用functools.cached_property（推荐） #

直接使用标准库的cached_property装饰器，它专门为类属性实现了懒加载+自动缓存的功能，代码简洁且符合类内规范：

from functools import cached_property

class Variables:
    def __init__(self, param1, param2):
        self._param1 = param1
        self._param2 = param2

    @cached_property
    def var1(self):
        return self._param1 + 'foo'

    @cached_property
    def var2(self):
        return self.var1 + 'bar'

    # ... 中间变量依此类推
    @cached_property
    def var9(self):
        return self.var2 + self.var8

    @cached_property
    def var10(self):
        return self.var3 + self.var9

每个变量的计算逻辑完全独立，第一次访问时才会计算，之后直接返回缓存值，彻底避免重复计算，且类内self调用统一。

方案2：兼容旧版本的手动懒加载缓存 #

如果需要支持Python 3.8以下版本，可手动用@property实现懒加载逻辑：

class Variables:
    def __init__(self, param1, param2):
        self._param1 = param1
        self._param2 = param2
        # 初始化缓存标记为None，表示未计算
        self._var1 = None
        self._var2 = None
        # ... 依次初始化_var3到_var10为None

    @property
    def var1(self):
        if self._var1 is None:
            self._var1 = self._param1 + 'foo'
        return self._var1

    @property
    def var2(self):
        if self._var2 is None:
            self._var2 = self.var1 + 'bar'
        return self._var2

    # ... 中间变量依此类推
    @property
    def var9(self):
        if self._var9 is None:
            self._var9 = self.var2 + self.var8
        return self._var9

    @property
    def var10(self):
        if self._var10 is None:
            self._var10 = self.var3 + self.var9
        return self._var10

核心逻辑和方案1一致，只是手动维护缓存状态，兼容性更好。

方案优势总结 #

• 保留了每个变量的独立计算逻辑，符合“不能合并为一个大函数”的要求
• 懒加载特性：仅当变量被访问时才计算，避免预计算不需要的变量
• 完全避免重复计算，性能最优
• 类内self调用统一，没有外部函数的混乱问题

内容的提问来源于stack exchange，提问作者tima