Python属性间调用的执行机制、风险及优化方案咨询

先看你提供的示例代码：

from pydantic import BaseModel

class Amount(BaseModel):
    reserve: float = 0.0
    paid: float = 0.0

    @property
    def gross_paid_loss(self) -> float:
        gross_paid = self.paid - self.reserve
        return gross_paid

    @property
    def gross_incurred_loss(self) -> float:
        incurred_loss = self.gross_paid_loss + self.reserve
        return incurred_loss

注：BaseModel来自pydantic，用于简化类编写。

一、gross_paid_loss的调用处理过程 #

当你访问gross_incurred_loss时，执行顺序是这样的：

1. 触发gross_incurred_loss对应的@property方法执行
2. 方法里的self.gross_paid_loss会触发gross_paid_loss的@property方法执行
3. gross_paid_loss方法计算self.paid - self.reserve，返回结果
4. 回到gross_incurred_loss方法，用返回的结果加上self.reserve，得到最终值返回

举个实例化的例子：

amt = Amount(paid=100.0, reserve=20.0)
print(amt.gross_incurred_loss)  # 输出100.0

执行流程就是：调用amt.gross_incurred_loss → 调用amt.gross_paid_loss得到80.0 → 80.0+20.0=100.0返回。

二、这种调用方式的风险 #

1. 重复计算开销：每次访问gross_incurred_loss都会重新计算gross_paid_loss，如果计算逻辑复杂（比如涉及大量数据运算），频繁访问会拖慢性能。
2. 维护隐患：如果后续修改gross_paid_loss的计算逻辑，gross_incurred_loss的结果会被间接影响，容易引发意料之外的bug，增加维护成本。
3. 循环调用风险：如果不小心让两个@property方法互相引用（比如gross_paid_loss里也调用gross_incurred_loss），会直接触发无限递归，抛出RecursionError。

三、更优的处理方式 #

1. 缓存计算结果（适合属性值不频繁修改的场景） #

用functools.lru_cache缓存计算结果，避免重复计算，同时在依赖字段变化时清空缓存：

from functools import lru_cache
from pydantic import BaseModel

class Amount(BaseModel):
    reserve: float = 0.0
    paid: float = 0.0

    @property
    @lru_cache(maxsize=None)
    def gross_paid_loss(self) -> float:
        return self.paid - self.reserve

    @property
    @lru_cache(maxsize=None)
    def gross_incurred_loss(self) -> float:
        return self.gross_paid_loss + self.reserve

    def __setattr__(self, name, value):
        super().__setattr__(name, value)
        # 当依赖的字段变化时，清空缓存
        if name in ("reserve", "paid"):
            self.gross_paid_loss.fget.cache_clear()
            self.gross_incurred_loss.fget.cache_clear()

2. 构造函数预计算（你提到的方案） #

在实例初始化时就计算好派生属性，适合属性值初始化后基本不变的场景：

from pydantic import BaseModel

class Amount(BaseModel):
    reserve: float = 0.0
    paid: float = 0.0
    gross_paid_loss: float
    gross_incurred_loss: float

    def __init__(self, **data):
        super().__init__(**data)
        self.gross_paid_loss = self.paid - self.reserve
        self.gross_incurred_loss = self.gross_paid_loss + self.reserve

注意：如果后续修改reserve或paid，派生属性不会自动更新，需要手动添加更新逻辑（比如写一个update_fields方法）。

3. 使用Pydantic v2的computed_field（推荐） #

Pydantic v2新增了computed_field装饰器，专门处理派生属性，默认支持缓存，且依赖字段变化时会自动重新计算：

from pydantic import BaseModel, computed_field

class Amount(BaseModel):
    reserve: float = 0.0
    paid: float = 0.0

    @computed_field
    @property
    def gross_paid_loss(self) -> float:
        return self.paid - self.reserve

    @computed_field
    @property
    def gross_incurred_loss(self) -> float:
        return self.gross_paid_loss + self.reserve

这种方式完全贴合Pydantic生态，无需手动处理缓存失效，是最省心的方案。

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