如何创建属性修改时自动更新关联属性的Python对象？并解决属性计算的性能优化问题

当然有更优雅的实现方式！核心痛点在于fingers是可变列表——原地修改（比如pop()、append()这类操作）不会触发普通属性的setter逻辑，导致缓存的number_of_fingers无法自动更新。下面推荐几种既高效又优雅的解决方案：

方案一：自定义可监听的容器类（推荐，完美覆盖所有场景） #

我们可以创建一个继承自list的自定义类，重写所有会修改列表的方法，在每次修改后触发回调通知主类更新计算结果。这样既能保持列表的原生使用体验，又能确保缓存值只在必要时更新。

class ObservableList(list):
    def __init__(self, *args, callback=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.callback = callback  # 列表修改时触发的回调函数

    # 重写所有会修改列表的方法，修改后触发回调
    def pop(self, *args, **kwargs):
        result = super().pop(*args, **kwargs)
        self._trigger_callback()
        return result

    def append(self, *args, **kwargs):
        super().append(*args, **kwargs)
        self._trigger_callback()

    def extend(self, *args, **kwargs):
        super().extend(*args, **kwargs)
        self._trigger_callback()

    def remove(self, *args, **kwargs):
        super().remove(*args, **kwargs)
        self._trigger_callback()

    def insert(self, *args, **kwargs):
        super().insert(*args, **kwargs)
        self._trigger_callback()

    def clear(self):
        super().clear()
        self._trigger_callback()

    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self._trigger_callback()

    def __delitem__(self, key):
        super().__delitem__(key)
        self._trigger_callback()

    def _trigger_callback(self):
        if self.callback:
            self.callback()


class Hand:
    def __init__(self, fingers: list):
        # 将普通列表包装为可监听列表，绑定更新回调
        self.fingers = ObservableList(fingers, callback=self._update_finger_count)
        self.number_of_fingers = len(fingers)

    def _update_finger_count(self):
        # 只有列表被修改时才重新计算（高开销操作放这里）
        self.number_of_fingers = len(self.fingers)


# 测试效果
left_hand = Hand(["thumb", "index", "middle", "ring", "pinkie"])
left_hand.fingers.pop()
print(left_hand.number_of_fingers)  # 输出4，符合预期
left_hand.fingers.append("extra_finger")
print(left_hand.number_of_fingers)  # 输出5，自动更新

这个方案的优势非常明显：

• 完全兼容原生列表的所有操作，用户不需要改变使用习惯
• 高开销计算只会在列表修改时执行一次，访问属性时直接返回缓存值，性能拉满
• 逻辑清晰，回调机制解耦了列表修改和属性更新的逻辑

方案二：@property + Setter（仅处理属性赋值场景） #

如果你的场景中只需要处理fingers被重新赋值的情况（不需要监听原地修改），可以用@property的setter来触发缓存更新：

class Hand:
    def __init__(self, fingers: list):
        self._fingers = fingers
        self._number_of_fingers = len(fingers)

    @property
    def fingers(self):
        return self._fingers

    @fingers.setter
    def fingers(self, new_fingers):
        self._fingers = new_fingers
        # 赋值时一次性更新缓存
        self._number_of_fingers = len(new_fingers)

    @property
    def number_of_fingers(self):
        return self._number_of_fingers


# 测试效果
left_hand = Hand(["thumb", "index", "middle", "ring", "pinkie"])
left_hand.fingers = left_hand.fingers[:-1]  # 重新赋值触发setter
print(left_hand.number_of_fingers)  # 输出4

注意：这个方案无法处理列表原地修改（比如left_hand.fingers.pop()），因为原地修改不会触发fingers的setter，适合需求简单的场景。

不推荐的方案：__getattribute__拦截 #

虽然可以通过重写__getattribute__来拦截number_of_fingers的访问，每次检查列表是否变化，但这种方式会增加属性访问的复杂度，容易引入隐藏bug，远不如自定义容器类直观可控。

内容的提问来源于stack exchange，提问作者Tereso del Río Almajano