Python类嵌套字典的自定义Getter/Setter实现需求：修改深层值后返回上层字典并触发文件写入

要实现你需要的嵌套字典功能，核心思路是自定义一个继承自dict的类，让每个层级的字典都具备追踪父节点、触发修改回调的能力。这样既能保留普通字典的使用习惯，又能在修改深层值时执行额外逻辑（比如返回上层字典、调用写入方法）。

步骤1：实现基础的嵌套字典类 #

这个类会处理嵌套结构的初始化、修改时的回调，以及层级追踪：

class NestedDict(dict):
    def __init__(self, data=None, parent=None, parent_key=None, on_modify=None):
        super().__init__()
        self.parent = parent  # 记录父级字典
        self.parent_key = parent_key  # 记录当前字典在父级中的键
        self.on_modify = on_modify  # 修改时触发的回调函数
        if data is not None:
            self._initialize_nested(data)

    def _initialize_nested(self, data):
        """递归将普通字典转化为NestedDict实例"""
        for key, value in data.items():
            if isinstance(value, dict):
                self[key] = NestedDict(
                    value, 
                    parent=self, 
                    parent_key=key, 
                    on_modify=self.on_modify
                )
            else:
                super().__setitem__(key, value)

    def __setitem__(self, key, value):
        """重写赋值逻辑，自动转化嵌套字典并触发回调"""
        # 如果赋值的是普通字典，自动转为NestedDict
        if isinstance(value, dict) and not isinstance(value, NestedDict):
            value = NestedDict(
                value, 
                parent=self, 
                parent_key=key, 
                on_modify=self.on_modify
            )
        # 执行实际赋值
        super().__setitem__(key, value)
        # 触发修改回调（如果存在）
        if self.on_modify is not None:
            self.on_modify(self)

    def __getitem__(self, key):
        """确保获取到的嵌套字典都是NestedDict实例"""
        value = super().__getitem__(key)
        if isinstance(value, dict) and not isinstance(value, NestedDict):
            # 自动转化为NestedDict（防止通过update等方法添加普通字典）
            value = NestedDict(
                value, 
                parent=self, 
                parent_key=key, 
                on_modify=self.on_modify
            )
            super().__setitem__(key, value)
        return value

    def get_upper_level(self, levels_up=1):
        """获取指定层级的上层字典"""
        current = self
        for _ in range(levels_up):
            if current.parent is None:
                break
            current = current.parent
        return current

    def set_item(self, key, value, return_level=1):
        """自定义赋值方法，支持返回指定层级的上层字典"""
        self[key] = value
        return self.get_upper_level(return_level)

步骤2：针对文件场景扩展子类 #

你的实际需求是修改文件内容后自动写入，所以我们基于NestedDict实现一个带写入逻辑的子类：

import json

class FileDict(NestedDict):
    def __init__(self, file_path, data=None):
        # 传入修改时的回调函数（自动写入文件）
        super().__init__(data, on_modify=self._auto_write)
        self.file_path = file_path

    def _auto_write(self, modified_node):
        """当任何子节点被修改时，自动触发写入"""
        self.write_to_file()

    def write_to_file(self):
        """将当前字典内容写入文件（示例用JSON格式）"""
        # 递归将NestedDict转为普通字典，方便序列化
        def dictify(nested_obj):
            if isinstance(nested_obj, NestedDict):
                return {k: dictify(v) for k, v in nested_obj.items()}
            return nested_obj

        with open(self.file_path, 'w', encoding='utf-8') as f:
            json.dump(dictify(self), f, indent=2, ensure_ascii=False)
        print(f"✅ 文件 {self.file_path} 已更新")

步骤3：整合到你的业务类中 #

现在把这些组件整合到你的Try类里，替换原来的普通字典：

class Try:
    def __init__(self):
        # 初始化文件字典结构（示例数据）
        initial_data = {
            'file-1': {'content-1': '初始内容', 'content-3': 0},
            'file-2': {'content-2': 'Hello World'}
        }
        self._tryDict = NestedDict()
        # 将每个文件对应的字典转为FileDict
        for file_key, file_data in initial_data.items():
            self._tryDict[file_key] = FileDict(f"{file_key}.json", file_data)

    @property
    def tryDict(self):
        """Getter：直接返回嵌套字典实例"""
        return self._tryDict

    @tryDict.setter
    def tryDict(self, new_data):
        """Setter：支持直接替换整个字典结构"""
        if not isinstance(new_data, dict):
            raise ValueError("必须传入字典类型的数据")
        
        new_nested_dict = NestedDict()
        for file_key, file_data in new_data.items():
            new_nested_dict[file_key] = FileDict(f"{file_key}.json", file_data)
        self._tryDict = new_nested_dict

测试示例 #

现在来验证你的需求：

1. 读取深层值 #

t = Try()
print(t.tryDict['file-1']['content-1'])  # 输出：初始内容

2. 修改深层值并获取上层字典 #

由于Python的赋值语句（a[b] = c）本身不支持返回值，我们用自定义的set_item方法实现：

# 修改深层值，同时返回上层的file-1字典
updated_file_dict = t.tryDict['file-1']['content-3'].set_item('bla', 'z', return_level=2)
print(updated_file_dict)  # 输出：{'content-1': '初始内容', 'content-3': {'bla': 'z'}}

注：return_level=2表示返回当前节点的祖父级（即file-1对应的字典），如果设为1则返回父级（content-3对应的字典）。

3. 修改内容自动写入文件 #

当你修改任何深层值时，会自动触发write_to_file方法：

t.tryDict['file-1']['content-3'] = 1
# 控制台会打印：✅ 文件 file-1.json 已更新
# 同时file-1.json文件内容会被更新为最新的字典结构

注意事项 #

• 如果你需要支持其他文件格式（如YAML、XML），只需要修改FileDict.write_to_file方法的序列化逻辑即可。
• 如果需要处理大量嵌套层级或高性能场景，可以考虑优化递归逻辑（比如用迭代代替递归）。
• 若要支持更多字典操作（如update、pop），需要在NestedDict中重写对应的方法，确保修改时触发回调。

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