Python 列表推导式与生成器表达式

在 Python 中，列表推导式（List Comprehension）和生成器表达式（Generator Expression）是处理序列数据的高效工具。它们不仅能简化代码，还能提升数据处理的效率。本文将详细介绍这两种表达式的语法、特性、区别及适用场景，并通过丰富的实例帮助你掌握它们的使用技巧。

一、列表推导式：简洁高效的列表创建

列表推导式是 Python 中创建列表的一种简洁语法，它将循环、条件判断等逻辑浓缩成一行代码，既直观又高效。

1. 基本语法

# 基本格式
[表达式 for 变量 in 可迭代对象]# 带条件判断的格式
[表达式 for 变量 in 可迭代对象 if 条件]

示例 1：创建简单列表

# 传统方式：使用for循环创建列表
squares = []
for i in range(10):squares.append(i **2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]# 列表推导式：一行代码完成
squares = [i** 2 for i in range(10)]
print(squares)  # 结果同上

示例 2：带条件过滤的列表推导式

# 筛选偶数的平方
even_squares = [i **2 for i in range(10) if i % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]# 字符串处理：提取单词首字母大写
words = ["apple", "banana", "cherry", "date"]
capitalized = [word.capitalize() for word in words if len(word) > 5]
print(capitalized)  # ['Banana', 'Cherry']

2. 嵌套列表推导式

列表推导式支持嵌套，可用于处理二维数据结构（如矩阵）：

# 二维列表（矩阵）
matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 提取矩阵对角线元素
diagonal = [matrix[i][i] for i in range(len(matrix))]
print(diagonal)  # [1, 5, 9]# 矩阵转置（行变列）
transposed = [[row[i] for row in matrix] for i in range(3)]
print(transposed)  # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]# 扁平化矩阵（二维转一维）
flattened = [num for row in matrix for num in row]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

3. 列表推导式的优势

简洁性：将多行循环逻辑压缩为一行，代码更紧凑
可读性：符合 “声明式编程” 风格，直接表达 “要什么” 而非 “怎么做”
性能：通常比等效的for循环 +append()更快（内部优化）
功能性：结合条件判断可实现复杂过滤逻辑

4. 常见误区与最佳实践

避免过度复杂：嵌套层级不宜过多（建议不超过 2 层），否则可读性下降

# 不推荐：过于复杂的嵌套
complex = [x for x in [y for y in range(20) if y % 2 == 0] if x % 4 == 0]# 推荐：拆分逻辑
even_numbers = [y for y in range(20) if y % 2 == 0]
divisible_by_4 = [x for x in even_numbers if x % 4 == 0]

注意变量泄漏：Python 3 中列表推导式的变量不会泄漏到外部作用域

x = 10
[x for x in range(5)]
print(x)  # 输出10（变量x未被修改）

二、生成器表达式：惰性计算的内存优化方案

生成器表达式是一种创建生成器（Generator）的简洁语法，它与列表推导式类似，但采用惰性计算（Lazy Evaluation）策略，更适合处理大数据集。

1. 基本语法

# 基本格式（注意使用圆括号）
(表达式 for 变量 in 可迭代对象)# 带条件判断的格式
(表达式 for 变量 in 可迭代对象 if 条件)

示例 1：创建生成器

# 生成器表达式（圆括号可省略，视上下文而定）
squares_gen = (i **2 for i in range(10))
print(squares_gen)  # <generator object <genexpr> at 0x...># 遍历生成器（每次迭代才计算下一个值）
for num in squares_gen:print(num, end=" ")  # 0 1 4 9 16 25 36 49 64 81

示例 2：与列表推导式的直观对比

# 列表推导式：立即生成所有元素并占用内存
list_comp = [i** 2 for i in range(1000000)]
print(type(list_comp))  # <class 'list'>
print(len(list_comp))   # 1000000（已全部生成）# 生成器表达式：仅在迭代时生成元素，内存占用极低
gen_expr = (i **2 for i in range(1000000))
print(type(gen_expr))   # <class 'generator'>
# print(len(gen_expr))  # 报错：生成器没有长度（元素未生成）

2. 核心特性：惰性计算

生成器表达式的核心优势在于惰性计算：

元素仅在被请求时（如next()调用或for循环迭代）才会计算
计算后的值不会被存储，迭代结束后无法重新访问（一次性使用）
内存占用固定（与数据规模无关），适合处理超大数据集或无限序列

# 处理无限序列（列表推导式会直接崩溃）
def infinite_numbers():n = 0while True:yield nn += 1# 生成器表达式筛选偶数
even_infinite = (x for x in infinite_numbers() if x % 2 == 0)# 安全获取前5个偶数（不会耗尽内存）
for _ in range(5):print(next(even_infinite), end=" ")  # 0 2 4 6 8

3. 适用场景

大数据处理：当数据量超过内存限制时，生成器表达式可逐批处理

# 处理大文件（无需一次性加载全部内容）
def process_large_file(file_path):with open(file_path, "r") as f:# 生成器表达式逐行处理lines = (line.strip() for line in f)non_empty = (line for line in lines if line)  # 过滤空行for line in non_empty:# 处理逻辑（如数据分析、格式转换）pass

链式处理：与其他迭代器函数（如map、filter）配合，实现流式处理

# 生成器流水线
numbers = range(100)
squares = (x** 2 for x in numbers)
even_squares = (x for x in squares if x % 2 == 0)
sum_even = sum(even_squares)  # 按需计算，中间结果不存储

节省内存：替代列表推导式处理临时数据（如仅需迭代一次的场景）

# 计算1到100万的和（生成器表达式内存占用远低于列表）
total = sum(i for i in range(1000001))

4. 生成器表达式 vs 列表推导式：关键区别

特性	列表推导式	生成器表达式
语法标识	方括号 `[]`	圆括号 `()`（可省略）
返回类型	列表 `list`	生成器 `generator`
计算方式	立即计算所有元素（贪婪计算）	按需计算（惰性计算）
内存占用	与数据规模成正比	固定（极低）
可迭代次数	多次（元素已存储）	一次（元素计算后即丢弃）
支持的操作	所有列表方法（`len`、`index`等）	仅迭代操作（`next`、`for`循环）
适用场景	小数据、需多次访问、随机访问	大数据、单次迭代、内存受限场景

性能对比实验：

import memory_profiler
import time@memory_profiler.profile
def list_comprehension():return [i **2 for i in range(10** 7)]  # 1000万元素@memory_profiler.profile
def generator_expression():return sum(i **2 for i in range(10** 7))  # 同样1000万元素# 测试内存占用（列表推导式约占用380MB，生成器表达式约占用0.1MB）
list_comprehension()
generator_expression()# 测试时间（列表推导式耗时更长，因需先创建完整列表）
start = time.time()
list_comprehension()
print(f"列表推导式耗时：{time.time() - start:.2f}s")start = time.time()
generator_expression()
print(f"生成器表达式耗时：{time.time() - start:.2f}s")

三、实战应用：列表推导式与生成器表达式的协同使用

在实际开发中，两种表达式并非互斥关系，而是根据场景灵活选择：

1. 数据转换与过滤流水线

# 1. 原始数据（可能很大）
data = range(1, 1000001)  # 1到100万# 2. 生成器表达式：筛选偶数（惰性计算）
even_numbers = (x for x in data if x % 2 == 0)# 3. 生成器表达式：计算平方（继续惰性计算）
even_squares = (x **2 for x in even_numbers)# 4. 列表推导式：取前100个结果（转为列表便于后续复用）
first_100 = [next(even_squares) for _ in range(100)]print(first_100[:5])  # [4, 16, 36, 64, 100]

2. 文本处理场景

def process_text(file_path):# 生成器表达式：逐行读取并预处理with open(file_path, "r", encoding="utf-8") as f:lines = (line.strip() for line in f)non_empty = (line for line in lines if line)words = (word.lower() for line in non_empty for word in line.split())# 列表推导式：取前100个单词（小数据集）sample_words = [next(words) for _ in range(100)]print("样本单词：", sample_words[:10])# 生成器表达式：统计词频（大数据集）from collections import defaultdictfreq = defaultdict(int)for word in words:freq[word] += 1# 列表推导式：排序并返回前10高频词return sorted(freq.items(), key=lambda x: x[1], reverse=True)[:10]

3. 函数参数中的应用

许多内置函数（sum、max、min、any、all等）接受可迭代对象作为参数，此时生成器表达式是更优选择：

# 计算1到100的和（生成器表达式更省内存）
total = sum(i for i in range(1, 101))# 检查是否存在偶数（短路求值，找到第一个即停止）
has_even = any(i % 2 == 0 for i in [1, 3, 5, 7, 8, 9])# 找出最大平方数
max_square = max(x **2 for x in range(1, 10))