将元组构成的字典转换为Pandas DataFrame的实现方案

需求描述 #

给定一个嵌套字典，每个键代表一名人员，对应值是一个元组：

• 元组第一个元素是字典，存储该人员到其他关联人员的距离
• 元组第二个元素是字典，存储该人员到其他关联人员的路径

需要将其转换为包含person、connected_person、distance、path四列的DataFrame，每行对应一组人员-关联人员的距离与路径信息。

示例输入字典 #

data = {
    'A': ({'A': 0,
           'B': 0.07142857142857142,
           'J': 0.125,
           'C': 0.2,
           'G': 0.26785714285714285,
           'F': 0.6011904761904762,
           'D': 1.2,
           'E': 1.3111111111111111},
          {'A': ['A'],
           'B': ['A', 'B'],
           'C': ['A', 'C'],
           'J': ['A', 'J'],
           'F': ['A', 'J', 'G', 'F'],
           'G': ['A', 'J', 'G'],
           'D': ['A', 'C', 'D'],
           'E': ['A', 'C', 'D', 'E']}),
    'B': ({'B': 0,
           'A': 0.07142857142857142,
           'J': 0.19642857142857142,
           'C': 0.27142857142857146,
           'G': 0.3392857142857143,
           'F': 0.6726190476190477,
           'D': 1.2714285714285714,
           'E': 1.3825396825396825},
          {'B': ['B'],
           'A': ['B', 'A'],
           'C': ['B', 'A', 'C'],
           'J': ['B', 'A', 'J'],
           'F': ['B', 'A', 'J', 'G', 'F'],
           'G': ['B', 'A', 'J', 'G'],
           'D': ['B', 'A', 'C', 'D'],
           'E': ['B', 'A', 'C', 'D', 'E']}),
    'C': ({'C': 0,
           'A': 0.2,
           'B': 0.27142857142857146,
           'J': 0.325,
           'G': 0.46785714285714286,
           'F': 0.8011904761904762,
           'D': 1.0,
           'E': 1.1111111111111112},
          {'C': ['C'],
           'A': ['C', 'A'],
           'D': ['C', 'D'],
           'B': ['C', 'A', 'B'],
           'J': ['C', 'A', 'J'],
           'F': ['C', 'A', 'J', 'G', 'F'],
           'G': ['C', 'A', 'J', 'G'],
           'E': ['C', 'D', 'E']}),
    'D': ({'D': 0,
           'E': 0.1111111111111111,
           'F': 1.0,
           'C': 1.0,
           'A': 1.2,
           'B': 1.2714285714285714,
           'J': 1.325,
           'G': 1.3333333333333333},
          {'D': ['D'],
           'E': ['D', 'E'],
           'F': ['D', 'F'],
           'C': ['D', 'C'],
           'G': ['D', 'F', 'G'],
           'A': ['D', 'C', 'A'],
           'B': ['D', 'C', 'A', 'B'],
           'J': ['D', 'C', 'A', 'J']}),
    'E': ({'E': 0,
           'D': 0.1111111111111111,
           'F': 1.1111111111111112,
           'C': 1.1111111111111112,
           'A': 1.3111111111111111,
           'B': 1.3825396825396825,
           'J': 1.4361111111111111,
           'G': 1.4444444444444444},
          {'E': ['E'],
           'D': ['E', 'D'],
           'F': ['E', 'D', 'F'],
           'C': ['E', 'D', 'C'],
           'G': ['E', 'D', 'F', 'G'],
           'A': ['E', 'D', 'C', 'A'],
           'B': ['E', 'D', 'C', 'A', 'B'],
           'J': ['E', 'D', 'C', 'A', 'J']}),
    'F': ({'F': 0,
           'G': 0.3333333333333333,
           'J': 0.47619047619047616,
           'A': 0.6011904761904762,
           'B': 0.6726190476190476,
           'C': 0.8011904761904762,
           'D': 1.0,
           'E': 1.1111111111111112},
          {'F': ['F'],
           'D': ['F', 'D'],
           'G': ['F', 'G'],
           'A': ['F', 'G', 'J', 'A'],
           'J': ['F', 'G', 'J'],
           'B': ['F', 'G', 'J', 'A', 'B'],
           'C': ['F', 'G', 'J', 'A', 'C'],
           'E': ['F', 'D', 'E']}),
    'G': ({'G': 0,
           'J': 0.14285714285714285,
           'A': 0.26785714285714285,
           'F': 0.3333333333333333,
           'B': 0.3392857142857143,
           'C': 0.46785714285714286,
           'D': 1.3333333333333333,
           'E': 1.4444444444444444},
          {'G': ['G'],
           'J': ['G', 'J'],
           'F': ['G', 'F'],
           'A': ['G', 'J', 'A'],
           'B': ['G', 'J', 'A', 'B'],
           'C': ['G', 'J', 'A', 'C'],
           'D': ['G', 'F', 'D'],
           'E': ['G', 'F', 'D', 'E']}),
    'J': ({'J': 0,
           'A': 0.125,
           'G': 0.14285714285714285,
           'B': 0.19642857142857142,
           'C': 0.325,
           'F': 0.47619047619047616,
           'D': 1.325,
           'E': 1.4361111111111111},
          {'J': ['J'],
           'G': ['J', 'G'],
           'A': ['J', 'A'],
           'B': ['J', 'A', 'B'],
           'C': ['J', 'A', 'C'],
           'F': ['J', 'G', 'F'],
           'D': ['J', 'A', 'C', 'D'],
           'E': ['J', 'A', 'C', 'D', 'E']})
}

转换代码 #

import pandas as pd

# 初始化空列表存储每行数据
result_rows = []

# 遍历每个人员及其对应的距离、路径字典
for person, (distance_map, path_map) in data.items():
    # 遍历所有关联人员，提取对应数据
    for connected in distance_map:
        result_rows.append({
            'person': person,
            'connected_person': connected,
            'distance': distance_map[connected],
            'path': path_map[connected]
        })

# 转换为DataFrame并按人员排序
final_df = pd.DataFrame(result_rows).sort_values('person').reset_index(drop=True)

# 打印结果（可选）
print(final_df)

代码说明 #

1. 先创建空列表result_rows，用于逐行存储转换后的结构化数据
2. 外层循环遍历字典的每个人员键，同时取出对应的距离字典和路径字典
3. 内层循环遍历每个关联人员，将人员、关联人员、距离、路径打包为字典，添加到结果列表
4. 最后用pd.DataFrame()将列表转换为DataFrame，并按person列排序，让结果更规整

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