Python字典匹配与扩展技巧教程

大家好，今天本人给大家带来文章《Python键值匹配与扩展字典列表教程》，文中内容主要涉及到，如果你对文章方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

本教程旨在详细阐述如何在Python中高效地合并和扩展包含字典的列表。通过匹配不同列表中特定键的值，我们可以将辅助列表中的信息（如原始名称、原始地址）集成到主数据列表中，从而生成一个包含更丰富信息的新列表。文章将介绍利用字典进行快速查找的优化策略，并提供清晰的示例代码和注意事项，确保数据处理的效率与准确性。

场景概述与数据结构

在数据处理的实际场景中，我们经常会遇到需要从多个数据源中整合信息的情况。假设我们有以下三组数据，它们都以字典列表的形式存储：

1. listA: 包含名称及其对应的原始名称信息。

   listA = [
     {"name": "name sample 1", "original_name": "original name sample 1"},
     {"name": "name sample 2", "original_name": "original name sample 2"},
     # ... 更多数据
   ]

2. listB: 包含地址及其对应的原始地址信息。

   listB = [
     {"address": "address sample 1", "original_address": "original address sample 1"},
     {"address": "address sample 2", "original_address": "original address sample 2"},
     # ... 更多数据
   ]

3. dataList: 我们的主数据列表，包含ID、创建时间、名称和地址。

   dataList = [
     {"id": "1", "created_at": "date 1", "name": "name sample 1", "address": "address sample 1"},
     {"id": "2", "created_at": "date 2", "name": "name sample 2", "address": "address sample 2"},
     # ... 更多数据
   ]

我们的目标是创建一个新的列表 finalList，它基于 dataList 的内容，并通过匹配 name 字段从 listA 中获取 original_name，以及通过匹配 address 字段从 listB 中获取 original_address，最终的 finalList 结构应如下所示：

finalList = [
  {
    "id": "1",
    "created_at": "date 1",
    "name": "name sample 1",
    "original_name": "original name sample 1",
    "address": "address sample 1",
    "original_address": "original address sample 1",
  },
  {
    "id": "2",
    "created_at": "date 2",
    "name": "name sample 2",
    "original_name": "original name sample 2",
    "address": "address sample 2",
    "original_address": "original address sample 2",
  },
  # ...
]

传统遍历方法的局限性

初学者可能会尝试使用多层嵌套循环来解决这个问题，例如：

# 示例：仅处理 original_name 的嵌套循环尝试
finalList_partial = []
for data in dataList:
    found_name = False
    for item_a in listA:
        if "name" in data and data["name"] == item_a["name"]:
            new_entry = {
                "id": data["id"],
                "created_at": data["created_at"],
                "name": data["name"],
                "original_name": item_a["original_name"],
                "address": data["address"], # 注意：这里还没有 original_address
            }
            finalList_partial.append(new_entry)
            found_name = True
            break # 找到匹配项后跳出内层循环
    if not found_name: # 如果没有找到匹配的name，也要添加原始数据
        finalList_partial.append(data.copy()) # 复制原始字典

这种方法虽然可以实现部分功能，但存在明显的问题：

1. 复杂性高： 如果需要合并更多辅助列表，嵌套循环的层数会增加，代码可读性和维护性变差。
2. 效率低下： 对于每个 dataList 中的元素，都需要完整遍历 listA 和 listB，时间复杂度为 O(len(dataList) * (len(listA) + len(listB)))。当列表数据量较大时，性能会急剧下降。
3. 逻辑分散： original_name 和 original_address 的处理逻辑是分开的，容易出错且不易扩展。

高效合并策略：利用查找字典

为了解决上述问题，我们可以采用一种更高效且更具可扩展性的方法：将辅助列表转换为查找字典（哈希表）。字典的平均查找时间复杂度为 O(1)，这能显著提高数据匹配的效率。

核心思想

1. 将 listA 转换为一个以 name 为键，original_name 为值的字典。
2. 将 listB 转换为一个以 address 为键，original_address 为值的字典。
3. 遍历 dataList 的副本，对于每个元素，使用其 name 和 address 作为键，在预先构建的查找字典中直接获取 original_name 和 original_address。

示例代码

from copy import deepcopy

# 原始数据
listA = [
  {"name": "name sample 1", "original_name": "original name sample 1"},
  {"name": "name sample 2", "original_name": "original name sample 2"},
  {"name": "name sample 3", "original_name": "original name sample 3"}, # 增加一个未在dataList中匹配的示例
]

listB = [
  {"address": "address sample 1", "original_address": "original address sample 1"},
  {"address": "address sample 2", "original_address": "original address sample 2"},
  {"address": "address sample 3", "original_address": "original address sample 3"}, # 增加一个未在dataList中匹配的示例
]

dataList = [
  {"id": "1", "created_at": "date 1", "name": "name sample 1", "address": "address sample 1"},
  {"id": "2", "created_at": "date 2", "name": "name sample 2", "address": "address sample 2"},
  {"id": "3", "created_at": "date 3", "name": "name sample 3", "address": "address sample 4"}, # name匹配，address不匹配
  {"id": "4", "created_at": "date 4", "name": "name sample 4", "address": "address sample 3"}, # address匹配，name不匹配
  {"id": "5", "created_at": "date 5", "name": "name sample 5", "address": "address sample 5"}, # 均不匹配
]

# 1. 创建查找字典以提高效率
# name_lookup: {"name sample 1": "original name sample 1", ...}
name_lookup = {item["name"]: item["original_name"] for item in listA}
# address_lookup: {"address sample 1": "original address sample 1", ...}
address_lookup = {item["address"]: item["original_address"] for item in listB}

# 2. 深度复制dataList以避免修改原始数据
finalList = deepcopy(dataList)

# 3. 遍历finalList并添加匹配的数据
for item in finalList:
    # 尝试根据name查找original_name
    if "name" in item and item["name"] in name_lookup:
        item["original_name"] = name_lookup[item["name"]]

    # 尝试根据address查找original_address
    if "address" in item and item["address"] in address_lookup:
        item["original_address"] = address_lookup[item["address"]]

print("原始 dataList:")
import json
print(json.dumps(dataList, indent=4, ensure_ascii=False))

print("\n合并后的 finalList:")
print(json.dumps(finalList, indent=4, ensure_ascii=False))

代码解析

1. from copy import deepcopy: 导入 deepcopy 函数。这是至关重要的一步，它确保我们创建 dataList 的一个完全独立的副本。如果直接使用 finalList = dataList，那么 finalList 和 dataList 将指向同一个内存地址，对 finalList 的修改会直接影响 dataList。deepcopy 创建了一个全新的、独立的列表及其内部所有字典的副本。

2. 创建查找字典:

   name_lookup = {item["name"]: item["original_name"] for item in listA}
   address_lookup = {item["address"]: item["original_address"] for item in listB}

   这两行代码使用字典推导式（Dictionary Comprehension）高效地构建了两个查找字典。例如，name_lookup 会将 listA 中每个字典的 name 值作为键，对应的 original_name 值作为字典的值。这种预处理步骤使得后续的查找操作非常快速。

3. 遍历并合并数据:

   for item in finalList:
       if "name" in item and item["name"] in name_lookup:
           item["original_name"] = name_lookup[item["name"]]
       if "address" in item and item["address"] in address_lookup:
           item["original_address"] = address_lookup[item["address"]]

   我们遍历 finalList 中的每一个字典 item。在添加新字段之前，进行双重检查：

   • "name" in item：确保当前字典中存在 name 键（防止 KeyError）。
   • item["name"] in name_lookup：确保 name 的值在 name_lookup 字典中存在对应的 original_name（处理没有匹配项的情况）。 如果两个条件都满足，则将从 name_lookup 中查找到的 original_name 添加到当前 item 字典中。对 address 和 original_address 的处理方式也相同。

注意事项与最佳实践

1. 性能考量: 当 listA、listB 或 dataList 的数据量非常大时，使用查找字典的方法能够提供显著的性能提升。其整体时间复杂度为 O(len(listA) + len(listB) + len(dataList))，远优于多层嵌套循环的 O(N*M)。

2. 数据完整性与缺失值处理:

   • 在查找字典时，使用 if key in lookup_dict 或 lookup_dict.get(key) 方法是最佳实践，可以避免因键不存在而引发 KeyError。
   • 如果某些 dataList 中的 name 或 address 没有在 listA 或 listB 中找到匹配项，上述代码将不会为其添加 original_name 或 original_address 字段。如果需要为这些未匹配项设置默认值（如 None 或空字符串），可以修改逻辑：

     item["original_name"] = name_lookup.get(item.get("name"), None) # 如果name键不存在或匹配不到，则为None
     item["original_address"] = address_lookup.get(item.get("address"), None)

     这里 item.get("name") 用于安全地获取 name 键的值，即使 name 键本身不存在也不会报错。

3. 内存使用: deepcopy 会创建一份完整的副本，这会增加内存消耗。对于极大的数据集，如果允许修改原始 dataList，可以省略 deepcopy，直接在 dataList 上进行操作，但这通常不推荐，因为它会改变原始数据。

4. 可读性与维护性: 将数据合并逻辑封装成函数可以提高代码的可读性和复用性，例如：

   def merge_data_lists(data_list, lookup_list_a, lookup_key_a, value_key_a, lookup_list_b, lookup_key_b, value_key_b):
       name_lookup = {item[lookup_key_a]: item[value_key_a] for item in lookup_list_a}
       address_lookup = {item[lookup_key_b]: item[value_key_b] for item in lookup_list_b}
   
       merged_list = deepcopy(data_list)
       for item in merged_list:
           if lookup_key_a in item and item[lookup_key_a] in name_lookup:
               item[value_key_a] = name_lookup[item[lookup_key_a]]
           if lookup_key_b in item and item[lookup_key_b] in address_lookup:
               item[value_key_b] = address_lookup[item[lookup_key_b]]
       return merged_list
   
   # 使用示例
   # final_data = merge_data_lists(dataList, listA, "name", "original_name", listB, "address", "original_address")

   这种函数化处理能够更好地适应更复杂的合并需求。

总结

在Python中处理字典列表的合并与扩展任务时，将辅助数据转换为查找字典（哈希表）是一种高效且健壮的策略。它不仅能够显著提升处理大规模数据集的性能，还能使代码逻辑更加清晰、易于维护和扩展。通过合理运用 deepcopy 和条件查找，我们可以确保数据处理的准确性，并灵活应对各种数据匹配场景。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。