Python案例怎么合并两个列表？

Python案例：如何高效合并两个列表？7种实战方法详解

📖 目录导读

1. 为什么需要合并列表？
2. 基础方法： 运算符
3. 扩展方法：extend() 原地合并
4. 去重合并：set() 与列表推导式
5. 交替合并：zip() 实现交叉融合
6. 条件合并：列表推导式 + if 过滤
7. 大数据场景：itertools.chain 高性能合并
8. 实战案例：用户数据合并系统
9. 常见问答（FAQ）
10. 总结与最佳实践

---

为什么需要合并列表？

在Python开发中,合并列表是数据处理、日志聚合、API响应整合中最基础也最高频的操作。

• 从两个不同接口获取用户列表,需要合并为一个完整的用户池。
• 爬虫抓取分页数据时,需要将多个小列表拼成大列表。
• 分析A/B测试数据时，需要合并对照组与实验组的结果。

问题本质：列表是有序的可变序列，合并意味着将两个或多个列表中的元素，按照一定规则组成新的序列。

---

基础方法： 运算符

代码示例

list_a = [1, 2, 3]
list_b = [4, 5, 6]
merged = list_a + list_b
print(merged)  # 输出：[1, 2, 3, 4, 5, 6]

特点解析

• 最直观：语法简单，代码可读性强。
• 创建新列表：原列表不变，返回全新对象。
• 性能：时间复杂度 O(n+m)，适合中小规模数据（<10万元素）。

注意事项

• 不能直接合并 list + tuple，需先类型转换。
• 大量重复合并时,会产生大量临时对象，消耗内存。

# 错误示例
merged = [1,2,3] + (4,5,6)  # TypeError: can only concatenate list (not "tuple") to list

---

扩展方法：extend() 原地合并

代码示例

list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a.extend(list_b)  # 注意：list_a被修改
print(list_a)  # 输出：[1, 2, 3, 4, 5, 6]

核心优势

• 内存友好：原地修改，不创建新列表，节省内存。
• 可接收任何可迭代对象：extend 支持 list、tuple、set、generator。

适用场景

• 循环中不断向大列表追加数据。
• 当你不再需要原列表独立存在时。

# 拓展：合并多个列表
from functools import reduce
lists = [[1,2], [3,4], [5,6]]
result = []
for lst in lists:
    result.extend(lst)

---

去重合并（且保留顺序）

set + 排序

list_a = [3, 1, 2, 1]
list_b = [2, 4, 3]
merged_unique = list(set(list_a + list_b))
print(merged_unique)  # 输出：[1, 2, 3, 4]（顺序可能变）

保留顺序的去重

def merge_unique_ordered(a, b):
    seen = set()
    result = []
    for item in a + b:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result
list_a = [3, 1, 2, 1]
list_b = [2, 4, 3]
print(merge_unique_ordered(list_a, list_b))  # 输出：[3, 1, 2, 4]

关键技巧

• 使用 set 记录已出现元素，时间复杂度 O(n+m)。
• 注意：set 本身无序，需结合列表推导式或循环保持顺序。

---

交替合并：zip() 实现交叉融合

代码示例

list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
merged = [item for pair in zip(list_a, list_b) for item in pair]
print(merged)  # 输出：['a', 1, 'b', 2, 'c', 3]

特殊需求处理

如果两个列表长度不等,需使用 itertools.zip_longest：

from itertools import zip_longest
list_a = ['a', 'b']
list_b = [1, 2, 3]
merged = [item for pair in zip_longest(list_a, list_b, fillvalue=None) for item in pair]
print(merged)  # 输出：['a', 1, 'b', 2, None, 3]

应用场景

• 交错合并两个序列形成新序列（如洗牌、数据配对）。
• 生成报告中表头与数据的交替排列。

---

条件合并：筛选有效元素

场景：只合并满足条件的元素

list_a = [1, 2, 3, 4, 5]
list_b = [6, 7, 8, 9, 10]
merged = [x for x in list_a + list_b if x % 2 == 0]  # 只保留偶数
print(merged)  # 输出：[2, 4, 6, 8, 10]

更复杂的条件

# 合并两个列表，但排除None或空字符串
data1 = ['apple', '', None, 'banana']
data2 = ['', 'orange', None]
cleaned = [item for item in data1 + data2 if item]  # item为真值
print(cleaned)  # 输出：['apple', 'banana', 'orange']

性能提示

• 使用列表推导式比 filter() + lambda 快约20%。
• 条件复杂时,可拆分为独立函数提高可读性。

---

大数据场景：itertools.chain 高性能合并

代码示例

from itertools import chain
big_list_a = list(range(1000000))
big_list_b = list(range(1000000, 2000000))
merged_iter = chain(big_list_a, big_list_b)  # 返回迭代器
result = list(merged_iter)  # 按需转列表

为什么更快？

• 惰性求值：chain 返回迭代器，不立即创建新列表。
• 零拷贝：无需生成中间列表，遍历时直接从源列表读取。
• 内存节省：处理百万级列表时，内存占用仅为 的50%。

真实性能对比

方法	10万元素耗时	100万元素耗时	内存占用
003秒	04秒	高
extend	002秒	03秒	中
chain	001秒	01秒	低

最佳实践

• 处理超大数据：使用 chain 结合 list()。
• 流式处理：直接遍历 chain 对象，避免加载整个列表。

# 流式合并处理
for item in chain(list_a, list_b):
    process(item)  # 逐个处理，内存占用极低

---

实战案例：用户数据合并系统

需求描述

从两个数据库表获取用户数据,需要合并去重，并按注册时间排序。

原始数据

users_db1 = [
    {'id': 1, 'name': 'Alice', 'age': 25},
    {'id': 2, 'name': 'Bob', 'age': 30, 'email': 'bob@test.com'},
]
users_db2 = [
    {'id': 2, 'name': 'Bob', 'age': 31},  # 年龄更新
    {'id': 3, 'name': 'Charlie', 'age': 22},
]

合并并去重（按id合并，取最新数据）

def merge_users(db1, db2):
    # 用字典按id合并，后出现的覆盖前一个
    merged = {}
    for user in db1 + db2:
        merged[user['id']] = user
    return list(merged.values())
result = merge_users(users_db1, users_db2)
for user in result:
    print(user)
# 输出（id顺序可能变）：
# {'id': 1, 'name': 'Alice', 'age': 25}
# {'id': 2, 'name': 'Bob', 'age': 31}  # 年龄从30更新为31
# {'id': 3, 'name': 'Charlie', 'age': 22}

排序输出（按注册时间，假设数字越大越新）

from operator import itemgetter
sorted_result = sorted(result, key=itemgetter('id'), reverse=True)
# 按id降序排列：Charlie (id=3), Bob (id=2), Alice (id=1)

---

常见问答（FAQ）

Q1: 合并两个列表后，原来的列表还会变化吗？

• 使用 ：原列表不变，生成新列表。
• 使用 extend()：原列表被修改。
• 使用 chain：原列表不变，返回迭代器。

Q2: 如何合并两个列表并去除重复项且保持顺序？

使用循环 + set记录，如上述 方法二 中的 merge_unique_ordered 函数。

Q3: 合并两个列表时，如果列表元素是字典，如何按某个key去重？

使用字典暂存：{item['id']: item for item in list_a + list_b}.values()。

Q4: 如何合并两个列表，使它们像拉链一样交错排列？

使用 zip() 或 itertools.zip_longest，详情见第5节。

Q5: 有1000万个元素的列表，哪种合并方法最快？

推荐 itertools.chain，然后按需转 list，直接使用 会导致内存暴涨。

Q6: 合并后如何快速转成字符串？

''.join(map(str, merged_list))，注意元素必须是字符串。

---

总结与最佳实践

选择指南

需求	推荐方法	原因
简单合并，<1万元素	运算符	代码简洁，可读性高
循环中不断追加	extend()	原地修改，性能高
去重且保留顺序	set + 有序循环	保证顺序且高效
交错合并	zip() / zip_longest	专为匹配设计
条件筛选	列表推导式 + if	语法直观，性能好
大数据（>100万）	itertools.chain	内存友好，惰性求值
复杂对象合并	字典暂存（按key）	灵活控制更新策略

核心要点

• 优先考虑内存：大数据用惰性迭代，小数据用直观方法。
• 明确副作用：是否要修改原列表，还是生成新对象。
• 提前规划去重逻辑：元素是否可哈希？去重规则是什么？

掌握这7种方法,你可以在任何列表合并场景中，根据数据规模、内存限制、顺序要求、去重规则选择最优解，如果遇到特殊需求（如合并嵌套列表、自定义对象），再结合 deepcopy、OrderedDict 等工具即可。

---

没有“万能”的合并方法，只有“最合适”的合并策略。