Python 列表推导式：编写简洁高效的代码技巧-优快云博客

本文链接：https://blog.youkuaiyun.com/Techlifehacks/article/details/147478961

列表推导式（List Comprehension）是一种简洁且强大的工具，它可以帮助我们编写出更加简洁高效的代码。这篇文章将会深入探讨列表推导式的技巧，从基础到进阶，帮助你更好地理解和运用这一强大的特性。

开篇引入

在开始之前，先问大家一个问题：你在处理列表数据时，是否还在使用传统的循环结构来创建新的列表呢？比如像下面这样：

Python

numbers = [1, 2, 3, 4, 5]
squared = []
for num in numbers:
    squared.append(num ** 2)

这种方法当然可以工作，但其实还有更加简洁和高效的方式来完成同样的任务，那就是列表推导式。它不仅可以让你的代码更简洁，还可以提高代码的可读性。

初识列表推导式

列表推导式提供了一种优雅的方式来创建列表，它的基本结构是：

[expression for item in iterable]

简单来说，就是对一个可迭代对象（如列表、元组、字典、集合、字符串等）中的每个元素执行某个表达式，并将结果收集到一个新的列表中。上面的例子用列表推导式可以改写为：

Python

numbers = [1, 2, 3, 4, 5]
squared = [num ** 2 for num in numbers]

是不是简洁了很多？这就是列表推导式的魅力所在。

添加条件表达式

列表推导式还可以结合条件表达式来筛选数据。比如我们只想保留偶数的平方：

Python

numbers = [1, 2, 3, 4, 5]
squared_even = [num ** 2 for num in numbers if num % 2 == 0]

这行代码的意思是：遍历 numbers 列表中的每个元素，如果元素是偶数，就计算它的平方并添加到新列表中。输出结果为：

[4, 16]

处理嵌套循环

在处理多维数据时，列表推导式同样可以处理嵌套循环。例如，我们有两个列表，想要生成它们的笛卡尔积：

Python

list1 = [1, 2]
list2 = [3, 4]
cartesian_product = [(x, y) for x in list1 for y in list2]

这段代码会产生以下输出：

[(1, 3), (1, 4), (2, 3), (2, 4)]

相当于嵌套了两层循环，但代码更加简洁。

列表推导式 vs 传统循环

你可能会问，列表推导式真的比传统循环好吗？答案是：在大多数情况下是的，但具体情况也需要具体分析。

优点

可读性增强 ：对于简单的操作，列表推导式能够将创建列表的意图一目了然地表达出来，减少了代码的行数。
执行效率更高 ：列表推导式在底层实现中进行了优化，通常比等价的传统循环结构运行得更快。

缺点

可读性降低 ：当逻辑过于复杂时，列表推导式可能会变得难以阅读。比如嵌套过多层循环或条件时，代码可能会变得很拥挤。
不适用于复杂操作 ：对于一些需要复杂副作用的操作（如修改外部变量、执行多项操作等），传统循环可能更适合。

常见的应用场景

现在我们来看看在实际编程中，列表推导式可以怎样大显身手。

数据转换

将列表中的字符串统一转换为大写：

Python

words = ["hello", "world", "python"]
uppercase_words = [word.upper() for word in words]

数据筛选

从列表中筛选出长度大于 5 的单词：

Python

words = ["apple", "banana", "cherry", "date"]
long_words = [word for word in words if len(word) > 5]

生成测试数据

快速生成一个包含 10 个随机数的列表：

Python

import random
random_numbers = [random.randint(1, 100) for _ in range(10)]

这里的 _ 表示我们忽略循环变量，因为我们只关心生成随机数的次数。

进阶技巧

嵌套列表推导式

有时候我们可能会遇到嵌套的列表结构。比如，我们有一个二维矩阵，想要将其转置：

Python

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

这段代码首先遍历列索引 i，然后对于每一列，从每一行中取出对应的元素，组成新的行。转置后的矩阵为：

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

条件表达式的灵活运用

我们可以在列表推导式中使用条件表达式来决定每个元素的值，而不仅仅是决定是否包含该元素。例如，根据元素的奇偶性返回不同的值：

Python

numbers = [1, 2, 3, 4, 5]
result = ["even" if num % 2 == 0 else "odd" for num in numbers]

这段代码会产生以下输出：

['odd', 'even', 'odd', 'even', 'odd']

结合函数使用

将列表中的每个元素传递给一个函数进行处理：

Python

def double(x):
    return x * 2

numbers = [1, 2, 3, 4, 5]
doubled = [double(num) for num in numbers]

性能对比案例

为了更直观地体现列表推导式的性能优势，我们来做一个简单的测试。我们将分别使用列表推导式和传统循环来生成一个包含 100 万个元素的列表，并记录它们的执行时间。

Python

import time

# 测试列表推导式
start_time = time.time()
comprehension_result = [x ** 2 for x in range(1000000)]
comprehension_time = time.time() - start_time

# 测试传统循环
start_time = time.time()
loop_result = []
for x in range(1000000):
    loop_result.append(x ** 2)
loop_time = time.time() - start_time

print(f"列表推导式执行时间：{comprehension_time} 秒")
print(f"传统循环执行时间：{loop_time} 秒")

在我的机器上，运行结果大约是列表推导式比传统循环快 30% - 50% 左右。虽然这个结果会因机器配置和 Python 版本而有所差异，但可以明显看出列表推导式的性能优势。

踩坑指南

尽管列表推导式有很多优点，但在使用过程中也需要注意一些常见的坑。

过度使用导致可读性下降

当列表推导式变得过于复杂时，会使其他开发者难以理解你的代码。例如：

Python

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in nested_list if len(row) > 2 for num in row if num % 2 == 0]

这段代码的功能是将嵌套列表展平，并只保留元素大于 2 的行中的偶数。虽然它能工作，但可读性很差。遇到这种情况，我们不妨考虑将其拆分为多个步骤，或者使用传统循环：

Python

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = []
for row in nested_list:
    if len(row) > 2:
        for num in row:
            if num % 2 == 0:
                flattened.append(num)

这样虽然代码行数增加了，但可读性得到了很大提升。

误解列表推导式的执行顺序

有人可能会误解列表推导式的执行顺序。例如，在嵌套循环的列表推导式中，循环的顺序和传统嵌套循环是一致的。来看这个例子：

Python

list1 = [1, 2]
list2 = [3, 4]
result = [x + y for x in list1 for y in list2]

这段代码的执行顺序是：先遍历 list1 中的 x，再遍历 list2 中的 y。所以 result 的输出是：

[4, 5, 5, 6]

而不是：

[4, 5, 6, 7]

这可能与一些人的直觉不符。因此，在使用嵌套列表推导式时，一定要明确循环的顺序。

误用可变对象的引用

这个坑稍微隐蔽一些。假设我们想创建一个包含多个列表的列表，每个子列表包含相同的初始元素：

Python

rows = [[] * 3 for _ in range(3)]

你可能以为这样会创建一个 3x3 的空矩阵，但实际上，由于列表推导式的执行机制，这行代码会导致多个子列表引用同一个内存地址。当我们修改其中一个子列表时，其他子列表也会受到影响。正确的做法是：

Python

rows = [[] for _ in range(3)]

这样每个子列表都是独立的。

总结

列表推导式是 Python 中一个非常实用的特性，它可以帮助我们编写出简洁高效的代码。在实际开发中，我们应该根据具体情况灵活运用列表推导式：

对于简单的列表创建和转换操作，列表推导式通常是首选。
当逻辑变得复杂，或者可读性受到严重影响时，我们不妨退回到传统循环结构。
在处理嵌套数据结构时，要特别注意列表推导式的执行顺序和可变对象的引用问题。

希望大家通过这篇文章能够深入理解列表推导式的技巧，并在日常编程中得心应手地使用它。如果你还有其他关于列表推导式的问题或技巧，欢迎在评论区分享交流！