当前位置：首页 > 文章列表 > 文章 > python教程 > Python多列表键值合并技巧

Python多列表键值合并技巧

2025-08-01 10:45:32 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

本篇文章给大家分享《Python高效合并多列表键值匹配策略》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

Python中基于键值匹配合并多列表数据的高效策略

本文详细介绍了在Python中如何将多个包含字典的列表进行高效合并，特别是根据特定键（如“name”和“address”）的值进行匹配，并从源列表中提取额外信息（如“original_name”和“original_address”）填充到目标列表中。教程涵盖了从数据结构理解、初步尝试的局限性到优化合并策略的完整过程，并提供了示例代码和性能优化建议，旨在帮助开发者构建结构清晰、数据完整的复合列表。

在日常数据处理中，我们经常会遇到需要从多个数据源整合信息以构建一个更完整的数据结构的需求。例如，您可能拥有多个列表，每个列表都包含字典，并且这些字典之间通过某些共同的键值存在关联。本教程将深入探讨如何高效地实现这一目标，特别是当需要根据键值匹配来补充或更新目标列表中的数据时。

原始数据结构

假设我们有以下三个列表，每个列表都包含一系列字典：

listA: 包含名称及其对应的原始名称。
listB: 包含地址及其对应的原始地址。
dataList: 我们的主数据列表，包含ID、创建时间、名称和地址，但缺少原始名称和原始地址信息。

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

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

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，但会从 listA 中匹配 name 字段以获取 original_name，并从 listB 中匹配 address 字段以获取 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",
  }
  # ... 更多数据
]

初步尝试与局限

在面对此类问题时，一个常见的初步尝试是使用嵌套循环进行迭代和匹配。例如，以下代码尝试从 listA 中获取 original_name：

# 假设的初步尝试
# finalList = []
# for data in dataList:
#    dataJson = {
#        "id": data["id"],
#        "created_at": data["created_at"],
#        "name": data["name"],
#        "address": data["address"],
#    }
#    for lista_item in listA:
#       if "name" in data and (data["name"] == lista_item["name"]):
#          dataJson["original_name"] = lista_item["original_name"]
#          break # 找到匹配后即可跳出内层循环
#    # 如何在这里同时处理 listB 呢？
#    # 另一个循环 for listb_item in listB... 会使代码冗余且复杂
#    finalList.append(dataJson)

这种方法虽然可以处理单个源列表的合并，但当需要从多个源列表（如 listA 和 listB）中获取信息时，会变得非常复杂和低效。我们需要为每个源列表添加一个独立的嵌套循环，这不仅增加了代码的冗余性，也使得维护和扩展变得困难。

高效数据合并策略

为了更优雅和高效地解决多源列表合并问题，我们可以采用一种策略：首先复制主数据列表，然后遍历所有源数据，根据其包含的键来更新目标列表中的相应条目。

1. 复制主数据列表

为了不修改原始的 dataList，我们首先使用 copy 模块中的 deepcopy 函数创建一个完全独立的副本作为 finalList。这确保了对 finalList 的修改不会影响到 dataList。

from copy import deepcopy

# ... (listA, listB, dataList 定义同上) ...

finalList = deepcopy(dataList)

2. 合并源列表并迭代

将 listA 和 listB 合并成一个可迭代的序列 (listA + listB)。然后，我们遍历这个合并后的序列中的每一个字典条目。

for entry in listA + listB:
    # ...

3. 条件判断与数据更新

在遍历 entry 时，我们需要判断当前 entry 是来自 listA 还是 listB，这可以通过检查字典中是否存在特定的键来完成（例如，"name" 存在则来自 listA，"address" 存在则来自 listB）。根据判断结果，我们再遍历 finalList，找到匹配的条目并更新其附加字段。

    if "name" in entry: # 如果是来自 listA 的条目
        for data in finalList: # 遍历 finalList 中的每个字典
            if data['name'] == entry['name']: # 找到 name 匹配的条目
                data['original_name'] = entry['original_name'] # 添加 original_name
    elif "address" in entry: # 如果是来自 listB 的条目
        for data in finalList: # 遍历 finalList 中的每个字典
            if data['address'] == entry['address']: # 找到 address 匹配的条目
                data['original_address'] = entry['original_address'] # 添加 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",
  }
]

listB = [
  {
    "address": "address sample 1",
    "original_address" : "original address sample 1",
  },
  {
    "address": "address sample 2",
    "original_address" : "original address sample 2",
  }
]

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",
  }
]

# 1. 深度复制 dataList 以创建 finalList
finalList = deepcopy(dataList)

# 2. 遍历合并后的源列表 (listA 和 listB)
for entry in listA + listB:
    # 3. 根据键判断来源并更新 finalList
    if "name" in entry: # 如果是来自 listA 的条目
        for data in finalList: # 遍历 finalList 中的每个字典
            if data['name'] == entry['name']: # 找到 name 匹配的条目
                data['original_name'] = entry['original_name'] # 添加 original_name
    elif "address" in entry: # 如果是来自 listB 的条目
        for data in finalList: # 遍历 finalList 中的每个字典
            if data['address'] == entry['address']: # 找到 address 匹配的条目
                data['original_address'] = entry['original_address'] # 添加 original_address

print("原始 dataList (未被修改):")
print(dataList)
print("\n最终合并后的 finalList:")
print(finalList)

运行结果

执行上述代码，您将得到如下输出：

原始 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:
[
    {
        'id': '1',
        'created_at': 'date 1',
        'name': 'name sample 1',
        'address': 'address sample 1',
        'original_name': 'original name sample 1',
        'original_address': 'original address sample 1'
    },
    {
        'id': '2',
        'created_at': 'date 2',
        'name': 'name sample 2',
        'address': 'address sample 2',
        'original_name': 'original name sample 2',
        'original_address': 'original address sample 2'
    }
]

注意事项与性能优化

deepcopy 的必要性: 如果不使用 deepcopy 而直接 finalList = dataList，那么 finalList 将只是 dataList 的一个引用。对 finalList 的任何修改都会直接反映在 dataList 上。使用 deepcopy 确保我们操作的是一个完全独立的数据副本。
数据量考量与性能优化: 上述方案对于数据量不大的情况是有效且易于理解的。然而，当 listA、listB 或 dataList 的规模非常大时，嵌套循环（for entry in listA+listB 内部的 for data in finalList）会导致 O(N*M) 的时间复杂度，其中 N 是 listA 和 listB 的总长度，M 是 dataList 的长度。这在大型数据集上可能会非常慢。
优化方案: 预先将 listA 和 listB 转换为字典（哈希映射），以实现 O(1) 的平均查找时间。然后，只需遍历 finalList 一次，即可完成数据填充。
```
from copy import deepcopy

# ... (listA, listB, dataList 定义同上) ...

# 构建哈希映射
name_map = {item["name"]: item["original_name"] for item in listA}
address_map = {item["address"]: item["original_address"] for item in listB}

finalList_optimized = deepcopy(dataList)

for data in finalList_optimized:
    # 从 name_map 中查找并添加 original_name
    if data['name'] in name_map:
        data['original_name'] = name_map[data['name']]

    # 从 address_map 中查找并添加 original_address
    if data['address'] in address_map:
        data['original_address'] = address_map[data['address']]

print("\n优化后的 finalList:")
print(finalList_optimized)
```
这种优化方案的时间复杂度将变为 O(N + M)，其中 N 是源列表的总长度（用于构建映射），M 是 dataList 的长度（用于遍历和查找），显著提高了大数据集处理的效率。
处理数据不匹配的情况: 在实际应用中，dataList 中的 name 或 address 可能在 listA 或 listB 中找不到匹配项。上述代码在找不到匹配时不会添加 original_name 或 original_address 字段。如果需要为这些情况设置默认值或特殊处理，可以在 if data['key'] in map: 块的 else 分支中进行处理。

总结

本教程详细介绍了如何在Python中根据键值匹配，将多个列表中的字典数据合并到一个新的复合列表中。我们从理解原始问题和初步尝试的局限性出发，逐步构建了一个清晰、可维护的解决方案。对于小规模数据，直接遍历嵌套循环的方法简单易行；而对于大规模数据集，通过构建哈希映射（字典）进行预处理，可以显著提升数据合并的效率。选择哪种方法取决于您的具体需求和数据规模。掌握这些技巧将有助于您更高效地处理和整合复杂的数据结构。

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