Python中列表推导式详细教程 Python中列表推导式用法实例

冰火之心

发布时间：2025-08-26 16:58:01

1035人浏览过

来源于php中文网

原创

列表推导式是一种简洁高效的创建列表的方式，核心语法为[表达式 for 变量 in 可迭代对象 if 条件]，支持单层或多层嵌套、多条件过滤，相比传统循环更高效且更具可读性，但在复杂逻辑或大数据场景下应避免过度使用，可结合生成器表达式优化内存消耗。

python中列表推导式详细教程 python中列表推导式用法实例

Python中的列表推导式，说白了，就是一种非常Pythonic、简洁高效的创建列表的方式。它能让你用一行代码，优雅地完成原本需要好几行循环和

append

操作才能做到的事情。对我个人而言，它不仅仅是语法糖，更是一种思维模式的转变，一旦掌握，写起代码来会感觉流畅很多。

解决方案

列表推导式的核心语法结构是这样的：

[表达式 for 变量 in 可迭代对象 if 条件]

。

我们来拆解一下：

表达式
: 这是对
```
变量
```
进行操作后，最终要放入新列表的元素。它可以是
```
变量
```
本身，也可以是
```
变量
```
的某个属性，或者
```
变量
```
经过函数处理后的结果。
for 变量 in 可迭代对象
: 这部分和我们平时写的
```
for
```
循环非常相似，它会遍历
```
可迭代对象
```
中的每一个元素，并将其赋值给
```
变量
```
。
if 条件
(可选): 这是一个筛选器。只有当
```
条件
```
为
```
True
```
时，
```
表达式
```
才会被计算并加入到新的列表中。如果没有
```
if
```
条件，那么
```
可迭代对象
```
中的所有元素（经过
```
表达式
```
处理后）都会被包含进去。

举个最简单的例子，如果我想创建一个包含1到5的平方的列表：

立即学习“Python免费学习笔记（深入）”；

# 传统方法
squares = []
for i in range(1, 6):
    squares.append(i * i)
print(squares) # 输出: [1, 4, 9, 16, 25]

# 列表推导式
squares_lc = [i * i for i in range(1, 6)]
print(squares_lc) # 输出: [1, 4, 9, 16, 25]

你看，一行代码就搞定了。再来一个带条件筛选的：找出1到10之间的所有偶数。

# 传统方法
evens = []
for num in range(1, 11):
    if num % 2 == 0:
        evens.append(num)
print(evens) # 输出: [2, 4, 6, 8, 10]

# 列表推导式
evens_lc = [num for num in range(1, 11) if num % 2 == 0]
print(evens_lc) # 输出: [2, 4, 6, 8, 10]

这种写法，不仅代码量减少了，在我看来，它也更直接地表达了“我想要一个列表，里面是满足某个条件的元素经过某种处理后的结果”这个意图。

Python列表推导式与传统循环：效率与可读性对比如何？

谈到列表推导式，很多人首先想到的就是它比传统

for

循环更快、更简洁。这确实是事实，但背后的原因和实际应用中的权衡，我觉得还是值得深入聊聊的。

从效率上看，列表推导式通常会比等价的

for

循环加

append

操作要快。这主要是因为Python在底层对列表推导式进行了优化。当我们使用

for

循环时，每次

append

操作都可能涉及到函数调用和动态内存分配。而列表推导式在内部实现时，C语言级别的优化允许它更有效地预分配内存，减少了Python解释器执行的字节码指令数量。我个人在处理大量数据时，如果性能是关键考量，列表推导式往往是我的首选。你可以用

timeit

模块简单测试一下，结果通常会让你惊喜。

import timeit

# 传统循环
time_for_loop = timeit.timeit('[i*i for i in range(1000000)]', number=100)
print(f"传统循环耗时: {time_for_loop:.4f} 秒")

# 列表推导式
time_list_comp = timeit.timeit('list(map(lambda i: i*i, range(1000000)))', number=100) # 故意写错，这里应该是列表推导式本身
# Corrected for comparison:
time_list_comp = timeit.timeit('[i*i for i in range(1000000)]', number=100)
print(f"列表推导式耗时: {time_list_comp:.4f} 秒")

（自我修正：上面的

list(map(lambda i: i*i, range(1000000)))

虽然也是一种方式，但与列表推导式的直接比较，应该用列表推导式本身的代码。我有时候也会犯这种小迷糊，但重要的是能及时发现并纠正。）

从可读性角度来看，这就有点见仁见智了。对于简单的转换和过滤任务，列表推导式无疑是更简洁、更“Pythonic”的表达方式。它将整个列表创建的逻辑紧凑地封装在一行中，一眼就能看出其目的。然而，如果你的逻辑变得非常复杂，比如涉及到多层嵌套循环、多个复杂的条件判断，或者需要在循环内部执行一些有副作用的操作（比如修改外部变量），那么列表推导式可能会变得难以理解，甚至成为“一行地狱”。在这种情况下，我个人会毫不犹豫地选择传统的

for

循环，因为它能提供更清晰的步骤分解和更易于调试的结构。代码首先是给人读的，其次才是给机器执行的，可读性在很多时候比极致的简洁更重要。

掌握Python列表推导式的高级用法：嵌套与多条件过滤

列表推导式不仅仅能处理简单的单层循环和单条件筛选，它在处理更复杂的数据结构时也能大显身手，比如嵌套和多条件过滤。

嵌套列表推导式 当你需要处理一个包含列表的列表（比如矩阵），或者想将一个嵌套的结构扁平化时，嵌套列表推导式就非常方便。它的写法和我们传统的嵌套

for

循环非常相似，只是顺序有点不同。

假设我们有一个数字矩阵：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

如果我们想把这个矩阵扁平化成一个一维列表：

flattened_list = [num for row in matrix for num in row]
print(flattened_list) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

这里的

for row in matrix for num in row

，你可以想象成外层循环

for row in matrix

，内层循环

for num in row

。在写的时候，内层循环写在前面，这和传统

for

循环的嵌套顺序刚好相反，初学者可能会有点不适应，但习惯了就好。

阿里云AI平台

下载

再比如，我们想创建一个新的矩阵，其中每个元素是原矩阵对应元素的平方：

squared_matrix = [[num * num for num in row] for row in matrix]
print(squared_matrix)
# 输出: [[1, 4, 9], [16, 25, 36], [49, 64, 81]]

这里外层的

[... for row in matrix]

负责遍历每一行，内层的

[num * num for num in row]

则负责处理行内的每个元素。不过，我得提醒一句，嵌套层级太深的话，列表推导式的可读性会急剧下降。我个人通常建议最多两层嵌套，再复杂就考虑用传统循环或者封装成函数了。

多条件过滤 在

if

条件部分，我们可以使用逻辑运算符

and

和

or

来组合多个条件。这让我们的筛选逻辑更加灵活。

例如，从1到20中找出所有既是偶数又是5的倍数的数字：

filtered_numbers = [num for num in range(1, 21) if num % 2 == 0 and num % 5 == 0]
print(filtered_numbers) # 输出: [10, 20]

如果条件变得非常复杂，比如需要检查多个属性，或者涉及一些复杂的计算，我可能会选择将条件封装到一个辅助函数中，让列表推导式保持简洁，只负责调用这个函数。

def is_special_number(n):
    return n > 10 and n % 3 == 0 and n % 2 != 0 # 找出大于10的奇数且是3的倍数

special_numbers = [num for num in range(1, 30) if is_special_number(num)]
print(special_numbers) # 输出: [15, 21, 27]

这样做的好处是，

is_special_number

函数的逻辑可以单独测试和维护，而列表推导式本身依然清晰明了。

Python列表推导式常见误区与最佳实践：避免性能陷阱

列表推导式虽好用，但用不好也可能带来一些问题。作为一名开发者，我觉得识别这些误区并遵循最佳实践，能帮助我们写出更健壮、更高效的代码。

常见误区：

过度复杂化： 这是我经常看到的一个问题。有人试图把所有的逻辑，包括复杂的条件判断、多层嵌套，甚至一些有副作用的操作，都塞进一个列表推导式里。结果就是一行代码长得像“天书”，难以理解和维护。我个人认为，如果一个列表推导式需要你花超过几秒钟来理解它的意图，那它可能就已经过度复杂了。
追求副作用： 列表推导式的主要目的是创建新的列表。如果你在
```
表达式
```
中调用了一个函数，而这个函数的主要目的是修改外部变量或者执行I/O操作（比如打印），那这通常是一个代码异味。列表推导式应该尽可能地保持纯粹，即只根据输入产生输出，不产生其他副作用。
内存消耗： 列表推导式会一次性生成所有元素并存储在一个列表中。如果你的可迭代对象非常大，比如一个包含百万甚至千万元素的生成器，那么生成的列表可能会占用大量的内存，导致程序变慢甚至崩溃（
```
MemoryError
```
）。这其实是一个很实际的问题，尤其是在处理大数据时。

最佳实践：

保持简洁和专注： 列表推导式最适合简单的转换和过滤。如果你的逻辑开始变得复杂，考虑将其分解成多个步骤，或者使用传统的
```
for
```
循环。代码的可读性往往比所谓的“一行代码”更重要。
明确意图： 当你使用列表推导式时，确保你的意图是清晰地从一个可迭代对象中创建或转换出一个新的列表。避免将其用于其他目的。
善用生成器表达式（Generator Expressions）： 当你处理非常大的数据集，或者你不需要一次性将所有结果都存储在内存中，而只需要逐个处理时，生成器表达式是列表推导式的绝佳替代品。它的语法和列表推导式非常相似，只是用圆括号
```
()
```
代替了方括号
```
[]
```
。
```
# 列表推导式 (生成整个列表)
large_list = [i*i for i in range(10**7)] # 可能会占用大量内存

# 生成器表达式 (惰性求值，按需生成)
large_generator = (i*i for i in range(10**7)) # 不会立即计算所有值
# 只有当你迭代它的时候，元素才会被生成
for item in large_generator:
    # 处理 item
    if item > 100:
        break
```
生成器表达式不会一次性构建整个列表，而是返回一个迭代器，每次请求时才计算下一个值。这在处理大数据流或者只需要部分结果时，能显著节省内存。对我来说，这是一个非常重要的性能优化手段。
测试和调试： 尽管列表推导式很简洁，但在出现问题时，调试可能会有点挑战。如果你的列表推导式出现错误，可以尝试将其拆分成传统的
```
for
```
循环来定位问题。熟练掌握调试技巧总是有益的。