Python如何为dataclass添加依赖其他属性且各实例计算逻辑不同的属性

方案1：Sys初始化末尾统一赋值（改动最小） #

这是对现有代码侵入性最低的实现方式，所有逻辑封闭在Sys类内部，不需要调整外部调用逻辑：

1. 先给Thing类新增thing_att_2字段，设置默认值为None
2. 在Sys的__init__方法完成所有核心属性初始化后，直接调用自身的计算方法给两个Thing实例的thing_att_2赋值

代码示例：

from dataclasses import dataclass
from typing import Any

@dataclass
class Input:
    @classmethod
    def from_stdin(cls):
        return cls() # 你的原有逻辑

@dataclass
class Thing:
    thing_att_1: list
    thing_att_2: Any = None # 新增字段，默认值为None

list_1, list_2 = [], [] # 你的原有列表

class Sys:
    def __init__(self, input):
        self.input = input
        # 先完成基础实例初始化
        self.thing_1 = Thing(list_1)
        self.thing_2 = Thing(list_2)
        # 初始化完成后直接计算赋值，不会再出现依赖未就绪的问题
        self.thing_1.thing_att_2 = self.calculate_list_1_alt()
        self.thing_2.thing_att_2 = self.calculate_list_2_alt()

    @classmethod
    def from_stdin(cls):
        return cls(Input.from_stdin())

    def calculate_list_1_alt(self):
        # 你的原有计算逻辑
        return []
    def calculate_list_2_alt(self):
        # 你的原有计算逻辑
        return []

if __name__ == '__main__':
    sys_inst = Sys.from_stdin()
    # 直接可以访问sys_inst.thing_1.thing_att_2，不需要额外赋值

方案2：计算逻辑绑定到Thing实例（内聚性更强） #

如果后续会新增更多Thing实例，更推荐这种方式，把每个实例对应的计算逻辑和Thing本身绑定，避免Sys类堆积大量重复的calculate方法：

from dataclasses import dataclass
from typing import Any, Callable

@dataclass
class Thing:
    thing_att_1: list
    # 每个实例传入独有的计算逻辑，入参为用户输入和自身的thing_att_1
    _calc_func: Callable
    thing_att_2: Any = None

    def init_att2(self, input):
        self.thing_att_2 = self._calc_func(input, self.thing_att_1)

class Sys:
    def __init__(self, input):
        self.input = input
        # 初始化时直接传入对应实例的计算逻辑
        self.thing_1 = Thing(
            list_1,
            _calc_func=lambda inp, att: [x for x in att if x > inp.threshold] # 替换为你的实际逻辑
        )
        self.thing_2 = Thing(
            list_2,
            _calc_func=lambda inp, att: [x*inp.multiplier for x in att] # 替换为你的实际逻辑
        )
        # 统一触发属性计算
        self.thing_1.init_att2(self.input)
        self.thing_2.init_att2(self.input)

方案3：延迟计算（适合计算成本高的场景） #

如果thing_att_2不是每次都需要用到，想避免初始化时的不必要计算，可以用缓存属性实现延迟加载，第一次访问时才执行计算：

from dataclasses import dataclass
from typing import Any, Callable
from functools import cached_property

@dataclass
class Thing:
    thing_att_1: list
    input: Input # 提前传入用户输入
    _calc_func: Callable

    # 缓存属性，第一次访问时计算，后续访问直接返回缓存结果
    @cached_property
    def thing_att_2(self) -> Any:
        return self._calc_func(self.input, self.thing_att_1)

class Sys:
    def __init__(self, input):
        self.input = input
        self.thing_1 = Thing(list_1, input, _calc_func=你的计算逻辑1)
        self.thing_2 = Thing(list_2, input, _calc_func=你的计算逻辑2)

内容的提问来源于stack exchange，提问作者kettle corn with a Q U