要合并两个字典 `{"x": [1, 2], "y": [3]}` 和 `{"x": [4], "z": [5, 6]}`，并实现相同键的值（列表）进行合并，核心思路是遍历两个字典的所有键值对，当遇到相同键时，将两个列表使用 `+` 运算符或 `extend()` 方法进行连接，生成一个新列表作为合并后该键的值 [ref_1][ref_3][ref_4][ref_6]。 #### **核心实现方案对比** | 方案 | 核心方法 | 代码简洁度 | 可读性 | 性能 | | :--- | :--- | :--- | :--- | :--- | | **方案一：`for` 循环 + `setdefault()`/`get()`** | 显式遍历字典，处理键存在与否的逻辑 | 中 | 高 | 良好 | | **方案二：`collections.defaultdict`** | 使用自动初始化列表的字典，简化逻辑 | 高 | 高 | 良好 | | **方案三：字典推导式 + 集合运算** | 结合推导式与集合运算，较为精巧 | 中 | 中 | 良好 | #### **详细代码实现与解析** **方案一：使用 `for` 循环与 `setdefault()` 或 `get()` 方法（基础通用）** 此方法逻辑清晰，易于理解。首先创建一个空结果字典，然后遍历第一个字典，将其键值对存入结果字典；接着遍历第二个字典，若键已存在，则将值列表合并，否则直接添加新键值对 [ref_4][ref_6]。 ```python # 定义两个字典 dict1 = {"x": [1, 2], "y": [3]} dict2 = {"x": [4], "z": [5, 6]} # 方法1.1: 使用 setdefault() result = {} # 处理第一个字典 for key, value in dict1.items(): result.setdefault(key, []).extend(value) # 若key不存在，设为空列表[]，然后扩展 # 处理第二个字典 for key, value in dict2.items(): result.setdefault(key, []).extend(value) print(result) # 输出: {'x': [1, 2, 4], 'y': [3], 'z': [5, 6]} ``` ```python # 方法1.2: 使用 get() 方法 result = {} # 处理第一个字典 for key, value in dict1.items(): result[key] = result.get(key, []) + value # get(key, []) 获取现有列表或空列表，然后连接 # 处理第二个字典 for key, value in dict2.items(): result[key] = result.get(key, []) + value print(result) # 输出: {'x': [1, 2, 4], 'y': [3], 'z': [5, 6]} ``` * **关键点**： * `dict.setdefault(key, default)`：若键 `key` 不存在于字典中，则将其设置为 `default` 并返回 `default`；若存在，则直接返回其对应的值。这非常适合用于初始化一个可变容器（如列表）[ref_4]。 * `dict.get(key, default)`：返回键 `key` 对应的值，若键不存在则返回 `default`。结合列表的 `+` 运算（连接），也能实现合并 [ref_4][ref_6]。 * `list.extend(iterable)`：将可迭代对象中的元素逐个添加到列表末尾，是原地修改操作。 * `list1 + list2`：返回一个新的列表，包含 `list1` 和 `list2` 的所有元素。 **方案二：使用 `collections.defaultdict(list)`（代码更简洁）** `defaultdict` 是 `dict` 的一个子类，它接受一个默认工厂函数。当访问一个不存在的键时，会自动调用该工厂函数（此处为 `list`）来生成一个默认值（空列表）并赋值给该键。这极大地简化了合并逻辑 [ref_3]。 ```python from collections import defaultdict dict1 = {"x": [1, 2], "y": [3]} dict2 = {"x": [4], "z": [5, 6]} result = defaultdict(list) # 创建一个默认值为空列表的字典 # 遍历两个字典，将所有值列表扩展到对应的键下 for d in (dict1, dict2): for key, value in d.items(): result[key].extend(value) # 直接扩展，无需检查键是否存在 # 将 defaultdict 转换回普通 dict 以便输出（非必需） result_dict = dict(result) print(result_dict) # 输出: {'x': [1, 2, 4], 'y': [3], 'z': [5, 6]} ``` * **关键点**：`defaultdict(list)` 确保了 `result[key]` 总是一个列表对象。因此，可以直接调用 `extend()` 方法，即使该键是第一次出现。这是处理此类“键对应列表，需要动态合并”问题的**最优雅和高效的方式之一** [ref_3]。 **方案三：使用字典推导式与集合运算（函数式风格）** 此方法思路是：首先获取两个字典所有键的并集，然后为每个键构建合并后的列表。它更侧重于一次性生成结果，而非迭代更新 [ref_1][ref_6]。 ```python dict1 = {"x": [1, 2], "y": [3]} dict2 = {"x": [4], "z": [5, 6]} # 获取所有键的集合 all_keys = set(dict1.keys()) | set(dict2.keys()) # 使用字典推导式，为每个键合并列表 result = { key: dict1.get(key, []) + dict2.get(key, []) for key in all_keys } print(result) # 输出: {'y': [3], 'x': [1, 2, 4], 'z': [5, 6]} ``` * **关键点**： * `set(dict1.keys()) | set(dict2.keys())` 计算两个字典键的并集，确保结果字典包含所有可能的键 [ref_1]。 * 在推导式中，对于每个键 `key`，使用 `dict1.get(key, [])` 和 `dict2.get(key, [])` 分别获取两个字典中该键对应的列表（如果不存在则返回空列表），然后用 `+` 连接它们 [ref_4][ref_6]。 * 此方法在字典数量固定（如两个）时很简洁，但如果要合并多个字典，代码扩展性不如循环方案。 #### **扩展：合并多个字典与处理非列表值** **1. 合并任意数量字典的通用函数** 基于方案二的 `defaultdict`，可以轻松编写一个合并任意数量字典的函数 [ref_3][ref_6]。 ```python from collections import defaultdict from typing import Dict, List, Any def merge_dicts_with_list_values(*dicts: Dict[Any, List]) -> Dict[Any, List]: """合并多个字典，相同键的值列表将连接起来。""" result = defaultdict(list) for d in dicts: for key, value in d.items(): result[key].extend(value) return dict(result) # 使用示例 dict1 = {"x": [1, 2], "y": [3]} dict2 = {"x": [4], "z": [5, 6]} dict3 = {"y": [7, 8], "z": [9]} merged = merge_dicts_with_list_values(dict1, dict2, dict3) print(merged) # 输出: {'x': [1, 2, 4], 'y': [3, 7, 8], 'z': [5, 6, 9]} ``` **2. 处理值可能不是列表的情况（增强鲁棒性）** 如果输入字典的值不保证都是列表，可以在合并前进行类型检查或转换 [ref_4]。 ```python from collections import defaultdict def safe_merge_dicts(dict1, dict2): result = defaultdict(list) # 定义一个内部处理函数 def process_dict(d): for key, value in d.items(): if isinstance(value, list): result[key].extend(value) else: # 如果不是列表，将其作为单个元素放入列表 result[key].append(value) process_dict(dict1) process_dict(dict2) return dict(result) # 测试 dict1 = {"x": [1, 2], "y": 3} # y的值是整数 dict2 = {"x": [4], "z": [5, 6]} print(safe_merge_dicts(dict1, dict2)) # 输出: {'x': [1, 2, 4], 'y': [3], 'z': [5, 6]} ``` #### **方案对比与选择建议** | 特性 | 方案一 (`for`循环) | 方案二 (`defaultdict`) | 方案三 (推导式) | | :--- | :--- | :--- | :--- | | **实现难度** | 低 | 低 | 中 | | **代码可读性** | 高（逻辑直白） | **高**（意图清晰） | 中（需理解集合操作） | | **可扩展性** | 高（易于改循环） | **高**（天然支持多字典） | 低（固定两个字典时简洁） | | **性能** | 良好 | 良好 | 良好 | | **适用场景** | 基础教学、简单合并 | **生产代码、通用合并函数** | 快速脚本、已知字典数量 | **结论**：对于合并两个字典并将相同键的列表值连接这一需求，**方案二（使用 `collections.defaultdict(list)`）** 在代码简洁性、可读性和可扩展性上综合表现最佳，是推荐的首选方法 [ref_3]。方案一作为基础方法，有助于理解底层逻辑。方案三在特定场景下（如明确只有两个字典且追求一行代码）也可用，但通用性稍弱。若需合并多个字典或处理更复杂的数据类型，基于 `defaultdict` 的通用函数是最稳健的选择 [ref_3][ref_6]。