Python构建动态嵌套字典问题：DataFrame父子节点整合

现有如下DataFrame：

from    to
B       C
A       B
D       E
D       F
B       D

目标是将其转换为嵌套字典，最终期望输出：

{ 
  "A": {
          "B": {
                   "C": {},
                   "D": {
                           "E": {},
                           "F": {},
                        }
               }
         }
}

当前编写的代码如下：

d = dict()
curr = d
for p, c in [("B", "C"), ("A", "B"), ("D", "E"), ("D", "F"), ("B", "D")]:
    
    # First time
    if not d:
        d.setdefault(p, {}).setdefault(c, {})
    
    # Check if p is a parent
    if p in d:
        curr = curr.setdefault(p, {}).setdefault(c, {})
        
    else:
        if c in d:
            curr = d
            curr.setdefault(p, {}).setdefault(c, d.get(c))
            del d[c]
        else:
            curr = d
            for k, v in curr.items():
                if p in v:
                    curr = v
                    curr.setdefault(p, {}).setdefault(c, {})
            else:
                curr.setdefault(p, {}).setdefault(c, {})

运行后得到的结果不符合预期：

{'A': {'B': {'C': {}}},
 'B': {'D': {'E': {},
             'F': {}}}}

核心困惑：不知道如何判断某个键已是父节点或子节点，并在对应情况下完成替换整合。

要搞定这种嵌套树状字典，核心是得随时追踪到每个节点在字典里的具体位置，不能只盯着顶层字典瞎操作。下面给你一套靠谱的实现思路和代码：

核心思路 #

1. 先把所有父节点对应的子节点整理成映射表，方便后续遍历
2. 找到整个树的根节点——也就是没有被任何节点指向的节点（这里就是A，因为所有to列里都没出现它）
3. 用一个字典专门记录每个节点对应的字典对象，不管节点在嵌套结构的哪一层，都能直接找到它并添加子节点

完整代码实现 #

import pandas as pd
from collections import deque

# 你的DataFrame数据
df = pd.DataFrame({
    'from': ['B', 'A', 'D', 'D', 'B'],
    'to': ['C', 'B', 'E', 'F', 'D']
})

# 第一步：整理父-子关系映射，同时收集所有节点
parent_child = {}
all_nodes = set()
for p, c in zip(df['from'], df['to']):
    parent_child.setdefault(p, []).append(c)
    all_nodes.add(p)
    all_nodes.add(c)

# 第二步：找根节点——不在to列里的节点就是根
root_nodes = all_nodes - set(df['to'])
root = root_nodes.pop()  # 这里只有A一个根，多根的话可以循环处理

# 第三步：构建嵌套字典，用node_map追踪每个节点的位置
node_map = {}
result = {root: {}}
node_map[root] = result[root]

# 用队列做广度优先遍历，从根开始逐层构建
queue = deque([root])
while queue:
    current_node = queue.popleft()
    # 获取当前节点的所有子节点
    children = parent_child.get(current_node, [])
    for child in children:
        # 给当前节点添加子节点
        node_map[current_node][child] = {}
        # 记录子节点的位置，方便后续给它加子节点
        node_map[child] = node_map[current_node][child]
        # 把子节点放进队列，继续处理它的子节点
        queue.append(child)

print(result)

运行后就能得到你想要的结果：

{'A': {'B': {'C': {}, 'D': {'E': {}, 'F': {}}}}}

为啥你的代码出问题了？ #

你的代码只在顶层字典或者当前curr指向的层级操作，没追踪到已经藏在嵌套结构里的节点——比如B明明已经是A的子节点了，但后续处理B和D的关系时，你没找到A下面的B，反而在顶层重新建了个B的条目，结果就分裂成两个顶层键了。

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