Python案例如何合并多个字典？

本文目录导读：

1. 方法一：使用 update() 方法（原地修改）
2. 方法二：使用 解包操作符（Python 3.5+）
3. 方法三：使用 合并运算符（Python 3.9+）
4. 方法四：使用 chain 和 dict 构造函数
5. 📝 处理重复键的情况
6. 🎯 合并列表中的多个字典
7. 🏆 推荐使用场景

在Python中合并多个字典有多种方法,我为你整理了最常用的几种方案：

使用 update() 方法（原地修改）

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {'e': 5, 'f': 6}
# 新建一个空字典来合并
merged = {}
merged.update(dict1)
merged.update(dict2)
merged.update(dict3)
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

使用 解包操作符（Python 3.5+）

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {'e': 5, 'f': 6}
merged = {**dict1, **dict2, **dict3}
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

使用 合并运算符（Python 3.9+）

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {'e': 5, 'f': 6}
merged = dict1 | dict2 | dict3
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

使用 chain 和 dict 构造函数

from itertools import chain
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {'e': 5, 'f': 6}
merged = dict(chain(dict1.items(), dict2.items(), dict3.items()))
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

📝 处理重复键的情况

当字典中有相同的键时,后面的值会覆盖前面的：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}  # 'b' 键重复
# 方法一：后面的覆盖前面的
merged = {**dict1, **dict2}
print(merged)  # {'a': 1, 'b': 3, 'c': 4}
# 方法二：自定义合并规则（例如保留较大的值）
def merge_with_rule(*dicts):
    result = {}
    for d in dicts:
        for key, value in d.items():
            if key not in result or value > result[key]:
                result[key] = value
    return result
result = merge_with_rule(dict1, dict2)
print(result)  # {'a': 1, 'b': 3, 'c': 4}  # 保留较大的值

🎯 合并列表中的多个字典

dicts = [
    {'a': 1, 'b': 2},
    {'c': 3, 'd': 4},
    {'e': 5, 'f': 6}
]
# 方法一：使用循环
merged = {}
for d in dicts:
    merged.update(d)
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
# 方法二：使用 reduce
from functools import reduce
merged = reduce(lambda x, y: {**x, **y}, dicts, {})
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

🏆 推荐使用场景

推荐：如果你使用 Python 3.9+， 运算符是最简洁的方式；如果兼容性要求高， 解包是最常用的选择。