Python合并字典的N种姿势：从基础到性能优化全解析

会员源码网
0 阅读6分钟

一、最简单直接的方法

1. 使用双星号解包（Python 3.5+）

# 方法1：使用**解包操作符
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict3 = {'d': 5}

# 合并字典，后面的字典会覆盖前面的键
merged_dict = {**dict1, **dict2, **dict3}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5}

优点：

  • 语法简洁直观
  • 支持一次合并多个字典
  • 返回新字典，不影响原始字典
  • 源码网：svipm.com （描述：上千款各行各业的源码）

缺点：

  • 仅适用于Python 3.5及以上版本
  • 键冲突时，后面的字典会覆盖前面的值

2. 使用update()方法

# 方法2：使用update()方法
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 方法2.1：创建新字典
merged_dict = {}
merged_dict.update(dict1)
merged_dict.update(dict2)
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

# 方法2.2：就地修改（会改变dict1）
dict1_copy = dict1.copy()  # 先复制，避免修改原字典
dict1_copy.update(dict2)
print(dict1_copy)  # 输出: {'a': 1, 'b': 3, 'c': 4}

二、高级合并技巧

1. 使用collections.ChainMap（Python 3.3+）

from collections import ChainMap

# 方法3：使用ChainMap
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict3 = {'d': 5}

# 创建ChainMap对象
chained = ChainMap(dict1, dict2, dict3)
print(dict(chained))  # 输出: {'d': 5, 'b': 2, 'c': 4, 'a': 1}
print(chained['b'])   # 输出: 2（获取的是第一个字典的值）

# 转换为普通字典
merged_dict = dict(chained)
print(merged_dict)  # 输出: {'d': 5, 'b': 2, 'c': 4, 'a': 1}

ChainMap的特点：

  • 不创建新字典，只是创建视图
  • 查询时按顺序查找，返回最先找到的值
  • 节省内存，特别是合并大字典时
  • 修改会反映到原始字典

2. 使用字典推导式

# 方法4：字典推导式合并
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict3 = {'d': 5}

# 合并多个字典
merged_dict = {k: v for d in [dict1, dict2, dict3] for k, v in d.items()}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5}

自定义合并逻辑：

# 自定义合并策略：相同键的值相加
dict1 = {'a': 1, 'b': 2, 'score': 10}
dict2 = {'b': 3, 'c': 4, 'score': 20}
dict3 = {'d': 5, 'score': 30}

merged_dict = {}
for d in [dict1, dict2, dict3]:
    for k, v in d.items():
        if k in merged_dict:
            if isinstance(v, (int, float)) and isinstance(merged_dict[k], (int, float)):
                merged_dict[k] += v  # 数值相加
            else:
                merged_dict[k] = v   # 非数值则覆盖
        else:
            merged_dict[k] = v

print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'score': 60, 'd': 5}

三、Python 3.9+的新特性

合并运算符 | 和 |=

# 方法5：Python 3.9+ 的合并运算符
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 使用 | 运算符（创建新字典）
merged_dict = dict1 | dict2
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

# 使用 |= 运算符（就地修改）
dict1 |= dict2
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

四、性能对比分析

为了选择最合适的合并方法，我们需要了解它们的性能表现：

import timeit
from collections import ChainMap

# 测试数据
dict1 = {f'key{i}': i for i in range(1000)}
dict2 = {f'key{i+500}': i+500 for i in range(1000)}

# 测试各种方法的性能
def test_methods():
    methods = {
        '**解包': '{**dict1, **dict2}',
        'update': 'd=dict1.copy();d.update(dict2)',
        'ChainMap转dict': 'dict(ChainMap(dict1, dict2))',
        '字典推导式': '{k:v for d in [dict1,dict2] for k,v in d.items()}',
        '|运算符 (3.9+)': 'dict1 | dict2',
    }
    
    for name, code in methods.items():
        if '|运算符' in name and tuple(map(int, __import__('sys').version.split()[0].split('.'))) < (3, 9):
            continue
        time_taken = timeit.timeit(code, globals=globals(), number=1000)
        print(f'{name:20} 执行1000次耗时: {time_taken:.4f}秒')

if __name__ == '__main__':
    test_methods()

典型结果（仅供参考，实际结果因环境和Python版本而异）：

  • update()方法：通常最快
  • **解包：简洁且性能不错
  • |运算符：Python 3.9+推荐，语法最直观
  • ChainMap：内存效率最高，适合只读场景

五、实际应用场景

场景1：配置文件合并

# 默认配置
default_config = {
    'host': 'localhost',
    'port': 8080,
    'debug': False,
    'timeout': 30
}

# 用户自定义配置
user_config = {
    'host': '192.168.1.100',
    'port': 9000,
    'max_connections': 100
}

# 合并配置（用户配置优先）
final_config = {**default_config, **user_config}
print(final_config)

场景2：多级字典深度合并

def deep_merge(dict1, dict2):
    """深度合并两个字典"""
    result = dict1.copy()
    
    for key, value in dict2.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = deep_merge(result[key], value)
        else:
            result[key] = value
    
    return result

# 示例
base_config = {
    'database': {
        'host': 'localhost',
        'port': 3306
    },
    'logging': {
        'level': 'INFO'
    }
}

override_config = {
    'database': {
        'host': 'production-db',
        'name': 'app_db'
    }
}

merged = deep_merge(base_config, override_config)
print(merged)

场景3：处理API响应数据

# 模拟多个API响应
user_info = {'id': 1, 'name': '张三', 'email': 'zhangsan@example.com'}
user_profile = {'age': 25, 'city': '北京', 'email': 'updated@example.com'}
user_stats = {'posts': 45, 'likes': 230, 'followers': 120}

# 合并用户数据
user_data = {**user_info, **user_profile, **user_stats}
print(f"完整用户数据: {user_data}")

# 或者使用ChainMap避免数据复制
user_view = ChainMap(user_info, user_profile, user_stats)
print(f"邮箱地址: {user_view['email']}")  # 输出: zhangsan@example.com

六、最佳实践建议

  1. Python 3.9+用户：优先使用 |运算符，语法最直观
  2. 性能敏感场景：使用 update()方法，特别是合并大字典时
  3. 只读场景：使用 ChainMap节省内存
  4. 需要自定义合并逻辑：使用字典推导式或循环合并
  5. 保持代码兼容性：如果支持Python 3.5以下版本，使用 update()方法
  6. 避免副作用：如果不希望修改原字典，记得先使用 copy()
# 安全合并示例
def safe_merge(*dicts, on_conflict='last'):
    """
    安全合并多个字典
    
    参数:
        *dicts: 要合并的字典
        on_conflict: 冲突处理策略
            'last' - 使用最后一个字典的值（默认）
            'first' - 使用第一个字典的值
            'raise' - 抛出异常
    
    返回:
        合并后的新字典
    """
    if on_conflict == 'last':
        return {k: v for d in dicts for k, v in d.items()}
    elif on_conflict == 'first':
        result = {}
        for d in reversed(dicts):  # 反向遍历
            result.update(d)
        return result
    elif on_conflict == 'raise':
        result = {}
        for d in dicts:
            for k, v in d.items():
                if k in result and result[k] != v:
                    raise ValueError(f"键 '{k}' 的值冲突: {result[k]} vs {v}")
                result[k] = v
        return result
    else:
        raise ValueError(f"不支持的冲突处理策略: {on_conflict}")

# 使用示例
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

print(safe_merge(dict1, dict2, on_conflict='last'))   # {'a': 1, 'b': 3, 'c': 4}
print(safe_merge(dict1, dict2, on_conflict='first'))  # {'a': 1, 'b': 2, 'c': 4}

总结

方法Python版本特点适用场景
{**d1, **d2}3.5+简洁直观，返回新字典快速合并，不修改原字典
update()所有版本性能好，可链式调用性能敏感，需要兼容老版本
ChainMap3.3+内存高效，惰性求值只读场景，大字典合并
字典推导式所有版本灵活，可自定义逻辑需要特殊合并逻辑
`d1d2`3.9+语法最直观

选择哪种方法主要取决于：Python版本、性能需求、内存限制以及是否需要自定义合并逻辑。在实际开发中，建议根据具体场景选择最合适的方法，并保持团队内的一致性。

avatar
文章
阅读
粉丝