Python类中基于主列表维护关联列表的实现难题

问题的核心是原生列表的原地修改操作（如append、remove）不会触发@property的setter——这些操作没有改变main指向的列表对象本身，只是修改了对象内部的数据。要兼容遗留代码且自动同步dependent，我们可以通过自定义继承自list的子类，重写所有会修改列表的方法，在操作后自动同步关联的dependent列表。

完整实现代码 #

import inflect

p = inflect.engine()

class SyncList(list):
    def __init__(self, iterable=None, sync_callback=None):
        super().__init__(iterable or [])
        self._sync_callback = sync_callback

    def _trigger_sync(self):
        if self._sync_callback:
            self._sync_callback(self)

    # 重写所有会修改列表的方法
    def append(self, item):
        super().append(item)
        self._trigger_sync()

    def extend(self, iterable):
        super().extend(iterable)
        self._trigger_sync()

    def insert(self, index, item):
        super().insert(index, item)
        self._trigger_sync()

    def remove(self, item):
        super().remove(item)
        self._trigger_sync()

    def pop(self, index=-1):
        result = super().pop(index)
        self._trigger_sync()
        return result

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

    def sort(self, *args, **kwargs):
        super().sort(*args, **kwargs)
        self._trigger_sync()

    def reverse(self):
        super().reverse()
        self._trigger_sync()

    # 处理下标赋值和删除
    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self._trigger_sync()

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

class T:
    def __init__(self):
        # 初始化SyncList，传入同步dependent的回调
        self._main = SyncList(sync_callback=self._update_dependent)
        self.dependent = []
    
    @property
    def main(self):
        return self._main

    @main.setter
    def main(self, value):
        # 把传入的可迭代对象转为SyncList，保持同步逻辑
        self._main = SyncList(value, sync_callback=self._update_dependent)
        self._update_dependent(self._main)

    def _update_dependent(self, current_main):
        # 执行转换逻辑，更新dependent实例变量（确保在__dict__中）
        self.dependent = [p.number_to_words(num) for num in current_main]

测试验证 #

t = T()

# 测试append操作
t.main.append(1)
print(t.dependent)  # 输出: ['one']

# 测试直接赋值
t.main = [2, 3]
print(t.dependent)  # 输出: ['two', 'three']

# 测试remove操作
t.main.remove(2)
print(t.dependent)  # 输出: ['three']

# 测试下标赋值
t.main[0] = 4
print(t.dependent)  # 输出: ['four']

# 验证dependent在__dict__中
print('dependent' in t.__dict__)  # 输出: True

关键说明 #

1. SyncList类：继承自原生list，重写所有会修改列表内容的方法，每次操作后调用_trigger_sync触发回调，保证任何修改都能同步更新dependent。
2. 回调函数_update_dependent：封装转换逻辑，直接修改实例变量self.dependent，确保它存在于类的__dict__中，满足数据传输需求。
3. 兼容性：遗留代码中所有对self.main的操作（包括append、remove、下标操作等）无需修改，完全兼容原有逻辑。
4. setter处理：当直接给main赋值时，自动将传入的可迭代对象转为SyncList实例，确保后续的原地修改仍能触发同步。

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