Python中嵌套字典列表转层级结构的稳健实现求助

我来帮你搞定这个层级结构转换的问题！你的需求是把嵌套字典列表转成任意深度的层级结构，现有实现确实只能处理到两层，遇到更深的嵌套就会失效。下面我给你两种稳健的实现方案，一种是高效的节点映射方式，另一种是你考虑的递归方式。

先明确你的输入与期望输出 #

输入结构 #

nested_list = [
 { "id" : "fruit", "name" : "apple" },
 { "name": "fruit" },
 { "id" : "fruit", "name" : "grape" },
 { "id" : "fruit", "name" : "pineapple" },
 { "name": "vehicle" },
 { "id" : "vehicle", "name": "car" },
 { "id" : "car", "name": "sedan" },
]

期望输出结构 #

{
 "vehicle": { "car": { "sedan" : {} } },
 "fruit" : { "apple": {}, "grape": {}, "pineapple": {} }
}

现有实现的问题 #

你当前的代码只能处理最多两层的嵌套，当新增类似{ "id" : "sedan", "name": "mini sedan" }的三层条目时，就无法深入到第三层找到父节点，灵活性和稳健性都不足。

方案一：节点映射法（高效且稳健） #

这个方法通过维护一个节点引用字典，直接通过父ID找到对应的节点，无需遍历整个结构，支持任意深度的嵌套，效率更高。

def build_hierarchy(nested_list):
    root = {}
    node_map = {}  # 存储所有节点的引用：key为节点的id/name，value为对应的字典节点
    
    # 第一步：先处理所有顶层节点（没有id的条目）
    for item in nested_list:
        if 'id' not in item:
            name = item['name']
            root[name] = {}
            node_map[name] = root[name]
    
    # 第二步：处理有父id的条目，直接通过映射找到父节点并添加子节点
    for item in nested_list:
        if 'id' in item:
            parent_id = item['id']
            child_name = item['name']
            
            # 如果父节点已存在于映射中，直接添加子节点
            if parent_id in node_map:
                node_map[parent_id][child_name] = {}
                node_map[child_name] = node_map[parent_id][child_name]
    
    return root

测试验证 #

# 测试原输入
result = build_hierarchy(nested_list)
print(result)  # 输出与期望完全一致

# 测试三层嵌套的情况
nested_list.append({"id": "sedan", "name": "mini sedan"})
result = build_hierarchy(nested_list)
print(result)
# 输出：
# {
#  "vehicle": {"car": {"sedan": {"mini sedan": {}}}},
#  "fruit": {"apple": {}, "grape": {}, "pineapple": {}}
# }

这个方案的优势：

• 支持任意深度的嵌套扩展
• 查找父节点的时间复杂度是O(1)，效率远高于遍历查找
• 逻辑清晰，容错性强（如果父ID不存在则跳过，不会报错）

方案二：递归查找法（符合你最初的思路） #

如果你更倾向于用递归实现，可以写一个辅助函数递归查找父节点，再添加子节点：

def find_parent_node(root, parent_id):
    # 递归遍历查找目标父节点
    for key, value in root.items():
        if key == parent_id:
            return value
        # 递归进入子节点继续查找
        found_node = find_parent_node(value, parent_id)
        if found_node is not None:
            return found_node
    return None

def build_hierarchy_recursive(nested_list):
    root = {}
    
    # 先处理所有顶层节点
    for item in nested_list:
        if 'id' not in item:
            root[item['name']] = {}
    
    # 处理子节点，通过递归找到父节点
    for item in nested_list:
        if 'id' in item:
            parent_id = item['id']
            child_name = item['name']
            parent_node = find_parent_node(root, parent_id)
            if parent_node is not None:
                parent_node[child_name] = {}
    
    return root

这个递归方案也能实现需求，但当列表规模大、层级深时，递归查找的效率会比节点映射法低一些，适合小规模数据场景。

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