Python自定义磁盘字典：可变值动态修改失效的应对方案

问题背景 #

我正在开发一个磁盘持久化的自定义字典FileDict，目标是接口贴近原生dict且精简，但遇到了一个关键问题：用户修改通过FileDict获取的可变元素（比如列表）时，修改仅停留在内存临时副本，不会同步到磁盘，且操作被静默忽略，完全不符合用户预期。

由于实时同步到磁盘的方案（如维护内存副本+线程监控）过于冗余，希望找到两种可行方向：

• 触发明确报错，告知用户此类操作无效；
• 在用户大概率不读文档的前提下，有效传递这一限制。

复现代码 #

import pickle
from pathlib import Path


class FileDict:
    def __init__(self):
        self.dirname = Path("filecache")
        self.dirname.mkdir(exist_ok=True)

    def __setitem__(self, key, value):
        with open(self.dirname / key, "wb") as f:
            f.write(pickle.dumps(value))

    def __getitem__(self, key: str):
        if not (self.dirname / key).exists():
            raise KeyError

        with open(self.dirname / key, "rb") as f:
            return pickle.loads(f.read())


if __name__ == "__main__":
    c = FileDict()
    c["foo"] = "bar"
    print(c["foo"])  # bar
    c["bar"] = [1, 2, 3]
    print(c["bar"])  # [1, 2, 3]
    c["bar"].append(1)
    print(c["bar"])  # 输出仍为[1, 2, 3]，修改被静默忽略

解决方案 #

方案一：返回不可变包装对象，直接阻止修改 #

将__getitem__返回的可变对象（列表、集合、字典等）包装为不可变类型，用户尝试修改时会立刻触发TypeError，明确知晓操作不允许。

import pickle
from pathlib import Path
from collections.abc import Mapping
import types


def make_immutable(obj):
    # 递归包装所有嵌套的可变对象
    if isinstance(obj, list):
        return tuple(make_immutable(item) for item in obj)
    elif isinstance(obj, set):
        return frozenset(make_immutable(item) for item in obj)
    elif isinstance(obj, Mapping):
        return types.MappingProxyType({k: make_immutable(v) for k, v in obj.items()})
    else:
        return obj


class FileDict:
    def __init__(self):
        self.dirname = Path("filecache")
        self.dirname.mkdir(exist_ok=True)

    def __setitem__(self, key, value):
        with open(self.dirname / key, "wb") as f:
            f.write(pickle.dumps(value))

    def __getitem__(self, key: str):
        if not (self.dirname / key).exists():
            raise KeyError

        with open(self.dirname / key, "rb") as f:
            obj = pickle.loads(f.read())
            return make_immutable(obj)


if __name__ == "__main__":
    c = FileDict()
    c["bar"] = [1, 2, 3]
    print(c["bar"])  # 输出(1, 2, 3)，列表被转为元组
    c["bar"].append(1)  # 触发 TypeError: 'tuple' object has no attribute 'append'

方案二：返回深拷贝+警告提示 #

如果不想完全禁止修改，可以返回对象的深拷贝，同时在获取元素时发出警告，提醒用户修改不会同步到磁盘，需重新赋值才能保存。

import pickle
import warnings
from pathlib import Path
import copy


class FileDict:
    def __init__(self):
        self.dirname = Path("filecache")
        self.dirname.mkdir(exist_ok=True)

    def __setitem__(self, key, value):
        with open(self.dirname / key, "wb") as f:
            f.write(pickle.dumps(value))

    def __getitem__(self, key: str):
        if not (self.dirname / key).exists():
            raise KeyError

        with open(self.dirname / key, "rb") as f:
            obj = pickle.loads(f.read())
            # 发出警告，stacklevel=2让警告指向用户调用的行
            warnings.warn(
                f"修改FileDict['{key}']返回的对象不会同步到磁盘，如需保存请执行 FileDict['{key}'] = 修改后的对象",
                UserWarning,
                stacklevel=2
            )
            return copy.deepcopy(obj)


if __name__ == "__main__":
    c = FileDict()
    c["bar"] = [1, 2, 3]
    print(c["bar"])  # 输出列表，同时打印警告
    c["bar"].append(1)
    print(c["bar"])  # 内存副本变为[1,2,3,1]
    print(c["bar"])  # 重新获取仍为[1,2,3]，再次触发警告

方案三：用代理类拦截修改方法（精准控制） #

创建一个代理类，拦截可变对象的所有修改方法（如append、__setitem__），当用户调用这些方法时直接抛出错误，并给出正确的操作指引。

import pickle
from pathlib import Path


class MutationPreventer:
    def __init__(self, obj):
        self._obj = obj
        # 定义需要拦截的可变操作方法
        self._mutating_methods = {
            'append', 'extend', 'insert', 'remove', 'pop', 'clear',
            '__setitem__', '__delitem__', 'update', 'add', 'discard'
        }

    def __getattr__(self, name):
        if name in self._mutating_methods:
            raise TypeError(f"不允许直接修改FileDict返回的对象，如需更新请执行 FileDict[key] = 新值")
        return getattr(self._obj, name)

    # 处理嵌套容器的索引访问，递归包装子元素
    def __getitem__(self, key):
        item = self._obj[key]
        if isinstance(item, (list, dict, set)):
            return MutationPreventer(item)
        return item

    def __repr__(self):
        return repr(self._obj)


class FileDict:
    def __init__(self):
        self.dirname = Path("filecache")
        self.dirname.mkdir(exist_ok=True)

    def __setitem__(self, key, value):
        with open(self.dirname / key, "wb") as f:
            f.write(pickle.dumps(value))

    def __getitem__(self, key: str):
        if not (self.dirname / key).exists():
            raise KeyError

        with open(self.dirname / key, "rb") as f:
            obj = pickle.loads(f.read())
            if isinstance(obj, (list, dict, set)):
                return MutationPreventer(obj)
            return obj


if __name__ == "__main__":
    c = FileDict()
    c["bar"] = [1, 2, 3]
    print(c["bar"])  # 输出[1, 2, 3]，外观和原列表一致
    c["bar"].append(1)  # 触发 TypeError: 不允许直接修改FileDict返回的对象，如需更新请执行 FileDict[key] = 新值

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