异常教程

Python 合并两个列表为一个（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在 Python 开发中，合并两个列表为一个列表是一个高频操作，无论是处理用户数据、整合日志信息，还是构建数据结构，开发者都需要灵活运用不同的方法实现这一目标。本文将从基础语法到高级技巧，结合实际案例，深入解析如何高效合并两个列表，并帮助读者理解不同方法的适用场景。通过本文的学习，读者不仅能掌握多种合并列表的实用技巧，还能培养解决实际问题的编程思维。

基础方法：直接合并的三种核心语法

1. 加号运算符（+）

Python 中最直观的列表合并方法是使用加号运算符 +，它可以直接拼接两个列表，生成一个新的列表对象。

示例代码：

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

原理比喻：
这如同将两列乐高积木并排放置，形成一列更长的积木。原列表保持不变，合并后的列表是全新的，因此不会影响原始数据。

2. extend() 方法

extend() 方法通过修改原列表，将另一个列表的元素逐个添加到末尾，实现“原地合并”。

示例代码：

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

对比分析：
与 + 运算符不同，extend() 会直接修改原列表，而 + 运算符则生成新列表。选择二者的关键在于是否需要保留原始列表的完整性。

3. 列表推导式（List Comprehension）

通过列表推导式，可以将两个列表的元素逐个遍历并合并到新列表中。这种方法在需要条件筛选或转换时尤为有用。

基础用法：

list_a = [1, 2, 3]  
list_b = [4, 5, 6]  
merged_list = [x for lst in [list_a, list_b] for x in lst]  
print(merged_list)  # 输出：[1, 2, 3, 4, 5, 6]

扩展思考：
若需合并时过滤某些元素，例如仅保留偶数，可以添加条件判断：

merged_list = [x for lst in [list_a, list_b] for x in lst if x % 2 == 0]

进阶技巧：灵活应对复杂场景

1. 生成器表达式（Generator Expression）

当处理超大列表时，使用生成器表达式可以显著减少内存占用。它通过惰性求值逐个生成元素，而非一次性加载所有数据。

示例对比：

merged_list = list(a + b for a, b in zip(list_a, list_b))  

merged_gen = (x for lst in [list_a, list_b] for x in lst)  
for item in merged_gen:  
    print(item)

适用场景：
当需要逐个处理元素而非一次性存储所有数据时（如实时处理日志流），生成器表达式是更优选择。

2. itertools.chain() 模块

Python 标准库中的 itertools 模块提供了 chain() 函数，能够高效合并多个可迭代对象。

使用方法：

import itertools  

list_a = [1, 2, 3]  
list_b = [4, 5, 6]  
merged_iter = itertools.chain(list_a, list_b)  
merged_list = list(merged_iter)  
print(merged_list)  # 输出：[1, 2, 3, 4, 5, 6]

优势分析：

  • 支持任意数量的可迭代对象（如 chain(list_a, list_b, list_c)）。
  • 内部实现高效，适合处理大规模数据。

3. 字典合并的特殊处理

若列表元素为字典对象，直接合并可能导致键值覆盖。此时可通过 update() 方法或字典推导式实现安全合并。

示例场景：

dict_list_a = [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]  
dict_list_b = [{"id": 3, "name": "Charlie"}, {"id": 2, "name": "Bob Updated"}]  

merged_dicts = []  
id_set = set()  

for d in dict_list_a + dict_list_b:  
    if d["id"] not in id_set:  
        merged_dicts.append(d)  
        id_set.add(d["id"])  

print(merged_dicts)

关键点：
通过 id_set 记录已存在的唯一键，避免重复数据，体现了“去重合并”的逻辑设计。

实际案例：合并用户行为数据

场景描述

假设我们有两个用户行为日志列表，分别记录用户在网页端和移动端的点击事件，需要合并为统一的分析数据：

web_logs = [  
    {"timestamp": "2023-01-01 10:00", "event": "page_view"},  
    {"timestamp": "2023-01-01 11:30", "event": "button_click"}  
]  

mobile_logs = [  
    {"timestamp": "2023-01-01 12:15", "event": "app_open"},  
    {"timestamp": "2023-01-01 13:45", "event": "purchase"}  
]

合并策略选择

若需保留所有事件记录，使用 itertools.chain() 最为简洁：

import itertools  

all_logs = list(itertools.chain(web_logs, mobile_logs))

若需按时间排序后再合并，可先排序再合并：

sorted_logs = sorted(  
    web_logs + mobile_logs,  
    key=lambda x: x["timestamp"]  
)

注意事项与常见误区

1. 类型一致性

合并操作要求两个列表元素类型兼容。例如，合并字符串列表和数字列表可能导致后续处理错误：

str_list = ["apple", "banana"]  
num_list = [10, 20]  
merged = str_list + num_list  # 会生成 ["apple", "banana", 10, 20]  
sum(merged)  # 报错！

解决方案：
在合并前确保元素类型符合后续操作需求，或通过类型转换统一数据格式。

2. 内存与性能优化

当处理千万级元素列表时，需注意：

  • 避免频繁使用 + 运算符合并列表（每次都会创建新列表）。
  • 优先使用 extend() 或 itertools.chain() 减少内存开销。

性能对比示例：

import timeit  

def method_plus():  
    a = list(range(1000))  
    b = list(range(1000, 2000))  
    return a + b  

def method_extend():  
    a = list(range(1000))  
    b = list(range(1000, 2000))  
    a.extend(b)  
    return a  

print("加号运算符耗时:", timeit.timeit(method_plus, number=1000))  
print("extend() 方法耗时:", timeit.timeit(method_extend, number=1000))

测试结果显示，extend() 的性能显著优于 + 运算符。

3. 深拷贝与浅拷贝

若列表元素是可变对象（如字典或列表），直接合并可能导致意外修改。此时需使用 copy.deepcopy() 进行深拷贝：

original_list = [[1, 2], [3, 4]]  
shallow_copy = original_list.copy()  # 浅拷贝  
deep_copy = copy.deepcopy(original_list)  

shallow_copy[0][0] = 99  
print(original_list)  # 输出：[[99, 2], [3, 4]] → 修改了原列表

结论

合并两个列表为一个列表是 Python 开发中的基础但关键的操作。通过掌握加号运算符、extend() 方法、itertools 模块等核心工具，并结合实际场景选择合适的方法，开发者可以高效完成数据整合任务。本文还揭示了合并操作中常见的类型冲突、内存优化和拷贝陷阱，帮助读者避免因细节问题导致的程序错误。建议读者通过动手实践案例，逐步内化这些技巧，最终在项目中灵活运用。

通过本文的学习，读者不仅能快速解决“如何合并列表”的问题，更能理解不同方法背后的逻辑差异，从而在复杂场景中做出更优选择。编程的本质是解决问题的艺术，而掌握合并列表的多种方法，正是构建这种艺术能力的重要一步。

最新发布

查看更多文章