如何递归转换嵌套DictProxy为字典以保存至JSON文件？

针对嵌套多层DictProxy对象的大型字典，以下是几种高效的序列化方案：

1. 递归遍历转换（直观易实现） #

编写递归函数，遍历整个嵌套结构，将所有DictProxy转换为普通字典，同时处理嵌套的字典、列表/元组：

from multiprocessing.managers import DictProxy
import json

def convert_dictproxy(obj):
    # 处理DictProxy对象
    if isinstance(obj, DictProxy):
        return {k: convert_dictproxy(v) for k, v in obj.items()}
    # 处理普通字典，防止内部嵌套DictProxy
    elif isinstance(obj, dict):
        return {k: convert_dictproxy(v) for k, v in obj.items()}
    # 处理列表/元组中的元素
    elif isinstance(obj, (list, tuple)):
        return type(obj)(convert_dictproxy(item) for item in obj)
    # 其他可JSON序列化的类型直接返回
    else:
        return obj

# 转换后序列化到文件
serializable_dict = convert_dictproxy(nested_dict)
with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(serializable_dict, f, indent=2)

注意：如果字典层级极深（超过Python默认递归深度1000），会触发RecursionError，此时可改用迭代式方案。

2. 利用json.dump的default参数（内存高效） #

无需预先转换整个字典，直接在序列化过程中动态处理DictProxy，节省内存开销，适合超大型字典：

import json
from multiprocessing.managers import DictProxy

def dictproxy_serializer(obj):
    if isinstance(obj, DictProxy):
        return dict(obj)
    # 若存在其他不可序列化类型，可在此扩展处理逻辑
    raise TypeError(f"Object of type {type(obj).__name__} cannot be JSON serialized")

# 直接序列化，无需提前转换字典
with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(nested_dict, f, default=dictproxy_serializer, indent=2)

原理：json.dump会递归遍历所有元素，遇到不可序列化的DictProxy时，调用default函数将其转为普通字典，自动处理嵌套结构。

3. 迭代式转换（避免递归深度限制） #

用栈模拟递归遍历，彻底解决深层嵌套导致的递归报错问题：

from multiprocessing.managers import DictProxy
import json

def convert_dictproxy_iterative(obj):
    stack = [(obj, None, None)]
    while stack:
        current, parent, key = stack.pop()
        # 转换DictProxy为普通字典
        if isinstance(current, DictProxy):
            converted = dict(current)
            if parent is not None:
                parent[key] = converted
            else:
                obj = converted
            # 将转换后的字典元素加入栈，继续处理嵌套
            for k, v in converted.items():
                stack.append((v, converted, k))
        # 处理普通字典的嵌套元素
        elif isinstance(current, dict):
            for k, v in current.items():
                stack.append((v, current, k))
        # 处理列表/元组的嵌套元素
        elif isinstance(current, (list, tuple)):
            for idx, item in enumerate(current):
                stack.append((item, current, idx))
    return obj

# 转换后序列化
serializable_dict = convert_dictproxy_iterative(nested_dict)
with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(serializable_dict, f, indent=2)

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