如何将嵌套字典拆分为由单键路径构成的列表

递归DFS是处理这类嵌套结构拆解需求的最优常规方案，逻辑清晰、代码冗余度低，不需要手动维护复杂的路径状态，递归调用栈会自动记录层级关系。
核心逻辑只有两步：

• 遍历当前层级字典的所有键值对，若值为非字典类型（即叶子节点），直接构造单键字典加入结果集
• 若值为字典类型，递归拆解该子字典，将返回的每个子拆解结果外层包裹当前键，再加入结果集

递归实现代码 #

def split_nested_dict(nested_data: dict) -> list:
    res = []
    for k, v in nested_data.items():
        if not isinstance(v, dict):
            res.append({k: v})
        else:
            # 递归处理子字典，嵌套当前键层
            for sub_res in split_nested_dict(v):
                res.append({k: sub_res})
    return res

样例验证 #

传入你提供的输入（已补全原字典缺失的语法逗号）：

test_dict = {
    "a": {"b": 1,
          "c": 2,
          "d": {"e": 3,
                "f": 4}
          },
    "g": {"h": 5,
          "i": 6}
}

print(split_nested_dict(test_dict))

输出和预期完全匹配：

[
    {'a': {'b': 1}},
    {'a': {'c': 2}},
    {'a': {'d': {'e': 3}}},
    {'a': {'d': {'f': 4}}},
    {'g': {'h': 5}},
    {'g': {'i': 6}}
]

特殊场景可选：迭代版实现 #

如果你的场景存在超深嵌套（超过Python默认递归深度限制1000层），可以用手动维护栈的迭代版本实现，逻辑和递归完全等价，不会触发栈溢出：

def split_nested_dict_iter(nested_data: dict) -> list:
    res = []
    # 栈元素格式：(当前处理的字典, 外层已构造的嵌套前缀)
    stack = [(nested_data, None)]
    
    while stack:
        current_dict, prefix = stack.pop()
        for k, v in current_dict.items():
            current_node = {k: v}
            # 拼接外层前缀
            if prefix:
                import copy
                tmp = copy.deepcopy(prefix)
                cursor = tmp
                # 定位到前缀最内层位置挂载当前节点
                while isinstance(list(cursor.values())[0], dict):
                    cursor = list(cursor.values())[0]
                cursor[list(cursor.keys())[0]] = current_node
                current_node = tmp
            
            if not isinstance(v, dict):
                res.append(current_node)
            else:
                stack.append((v, current_node))
    # 栈为后进先出，反转后保持和递归版一致的顺序
    return res[::-1]

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