如何在Python中合并具有共同值的字典项？（含DataFrame场景）

结论：直接操作字典更简便 #

如果已经拿到目标字典，直接用**连通分量（Union-Find）**的方式处理逻辑更直接，代码轻量且无需依赖Pandas；如果还在DataFrame的处理流程中，用Pandas展开后再处理也能实现，但步骤稍多。

方法一：直接操作字典（推荐） #

核心思路是把每个值和对应的键绑定，通过Union-Find算法找到所有共享值的键的连通组，最后合并每组的键和值：

from collections import defaultdict

# 目标字典
d = {'A': ['tango', 'bravo', 'alpha'],
     'B': ['bravo', 'test'],
     'C': ['romero', 'test'],
     'D': ['delta']}

# 1. 建立「值→关联键列表」的映射
value_to_keys = defaultdict(list)
for key, values in d.items():
    for val in values:
        value_to_keys[val].append(key)

# 2. 实现Union-Find算法，找到连通的键
parent = {key: key for key in d.keys()}

def find(u):
    # 查找根节点，带路径压缩
    while parent[u] != u:
        parent[u] = parent[parent[u]]
        u = parent[u]
    return u

def union(u, v):
    # 合并两个连通分量
    u_root = find(u)
    v_root = find(v)
    if u_root != v_root:
        parent[v_root] = u_root

# 遍历每个值对应的键，合并连通的键
for keys in value_to_keys.values():
    if len(keys) >= 2:
        first_key = keys[0]
        for key in keys[1:]:
            union(first_key, key)

# 3. 按连通组分组合并键和值
key_groups = defaultdict(list)
value_groups = defaultdict(set)

for key in d.keys():
    root = find(key)
    key_groups[root].append(key)
    value_groups[root].update(d[key])

# 生成最终结果字典
result = {}
for root in key_groups:
    # 按字母排序键，保证输出一致
    combined_key = ' , '.join(sorted(key_groups[root]))
    result[combined_key] = value_groups[root]

print(result)

输出结果：

{'A , B , C': {'alpha', 'bravo', 'romero', 'test', 'tango'}, 'D': {'delta'}}

方法二：用Pandas处理 #

如果是从DataFlow出发，可以先展开列表列，再复用连通分量的逻辑：

import pandas as pd
from collections import defaultdict

# 原始DataFrame
df = pd.DataFrame(
    {'Column1': ['A', 'B', 'C', 'D'],
     'Column2': [['tango', 'bravo', 'alpha'], ['bravo', 'test'], ['romero', 'test'], ['delta']]
    })

# 1. 展开Column2中的列表，每行对应一个值
df_exploded = df.explode('Column2')

# 2. 建立「值→关联键列表」的映射
value_to_keys = df_exploded.groupby('Column2')['Column1'].apply(list).to_dict()

# 3. 同样用Union-Find找连通组
parent = {key: key for key in df['Column1']}

def find(u):
    while parent[u] != u:
        parent[u] = parent[parent[u]]
        u = parent[u]
    return u

def union(u, v):
    u_root = find(u)
    v_root = find(v)
    if u_root != v_root:
        parent[v_root] = u_root

for keys in value_to_keys.values():
    if len(keys) >= 2:
        first_key = keys[0]
        for key in keys[1:]:
            union(first_key, key)

# 4. 分组合并键和值
df['group_root'] = df['Column1'].apply(find)
grouped = df.groupby('group_root').agg(
    combined_key=('Column1', lambda x: ' , '.join(sorted(x))),
    combined_values=('Column2', lambda x: set().union(*x))
)

# 转换为目标字典
result_df = grouped.set_index('combined_key')['combined_values'].to_dict()
print(result_df)

输出结果和方法一完全一致。

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