如何在Python中保留结构提取嵌套字典的指定子字典？

问题场景 #

现有嵌套字典：

d = {
    "a": {
        "b": {"id": 1, "time": 1234},
        "c": {"id": 3, "time": 2345},
    },
    "d": {
        "e": {"id": 5, "time": 3456},
        "f": {"id": 7, "time": 4567},
        "g": {"id": 9, "time": 5678},
    },
}

需要提取指定嵌套值并保留原层级结构，比如：

d_sub1 = {"a": {"b": {"id": 1, "time": 1234}}}
d_sub3 = {"d": {"e": {"id": 5, "time": 3456}}}

手动写法{"a": {"b": d["a"]["b"]}}在层级深时过于冗长，需要更简洁的实现。背景是要将完整字典传给多进程，记录每个进程修改的子字典后合并回原字典。

解决方案 #

1. 递归实现通用提取函数 #

写一个可复用的函数，传入原字典和目标键的路径列表，自动生成带层级的子字典：

def get_nested_subdict(original, keys):
    if not keys:
        return original
    current_key = keys[0]
    return {current_key: get_nested_subdict(original[current_key], keys[1:])}

用法示例：

d_sub1 = get_nested_subdict(d, ["a", "b"])
d_sub3 = get_nested_subdict(d, ["d", "e"])

无论层级有多深，只需要按顺序传入键列表即可，比如层级为5时，传入["key1", "key2", "key3", "key4", "key5"]就能生成对应层级的子字典。

2. 迭代实现（避免递归深度问题） #

如果字典层级极深，递归可能触发栈溢出，可改用迭代方式：

def get_nested_subdict_iterative(original, keys):
    # 先拿到最内层的值
    result = original[keys[-1]]
    # 从倒数第二个键开始反向构建层级
    for key in reversed(keys[:-1]):
        result = {key: result}
    return result

用法和递归版本完全一致，性能更稳定，适合超深层级的字典。

3. 合并子字典回原字典的补充 #

针对多进程修改后合并的场景，可以用以下递归合并函数，将子字典的修改同步回原字典：

def merge_subdict(original, subdict):
    for key, value in subdict.items():
        if isinstance(value, dict):
            merge_subdict(original[key], value)
        else:
            original[key] = value

用法示例：

# 假设进程修改了d_sub1的time值
d_sub1["a"]["b"]["time"] = 9999
# 合并回原字典d
merge_subdict(d, d_sub1)

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