【Python-Day 40】告别内存溢出！Python 生成器 (Generator) 的原理与实战

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【万字长文】MCP深度解析：打通AI与世界的“USB-C”，模型上下文协议原理、实践与未来

Python系列文章目录

PyTorch系列文章目录

机器学习系列文章目录

深度学习系列文章目录

Java系列文章目录

JavaScript系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践
06- 【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析
07-【Python-Day 7】从零精通 Python 运算符（下）：逻辑、成员、身份运算与优先级规则全解析
08-【Python-Day 8】从入门到精通：Python 条件判断 if-elif-else 语句全解析
09-【Python-Day 9】掌握循环利器：for 循环遍历序列与可迭代对象详解
10-【Python-Day 10】Python 循环控制流：while 循环详解与 for 循环对比
11-【Python-Day 11】列表入门：Python 中最灵活的数据容器 (创建、索引、切片)
12-【Python-Day 12】Python列表进阶：玩转添加、删除、排序与列表推导式
13-【Python-Day 13】Python 元组 (Tuple) 详解：从创建、操作到高级应用场景一网打尽
14-【Python-Day 14】玩转Python字典(上篇)：从零开始学习创建、访问与操作
15-【Python-Day 15】深入探索 Python 字典 (下)：常用方法、遍历、推导式与嵌套实战
16-【Python-Day 16】代码复用基石：详解 Python 函数的定义与调用
17-【Python-Day 17】玩转函数参数(上)：轻松掌握位置、关键字和默认值
18-【Python-Day 18】玩转函数参数（下）：*args 与 **kwargs 终极指南
19-【Python-Day 19】函数的回响：深入理解 return 语句与返回值
20-【Python-Day 20】揭秘Python变量作用域：LEGB规则与global/nonlocal关键字详解
21-【Python-Day 21】一行搞定！Python lambda 匿名函数的妙用与实战
22-【Python-Day 22】代码的基石：模块(Module)的导入与使用详解
23-【Python-Day 23】Python 模块化编程实战：创建、导入及 sys.path 深度解析
24-【Python-Day 24】告别杂乱代码！一文掌握 Python 包（Package）的创建与使用
25-【Python-Day 25】玩转数字：精通 math 与 random 模块，从数学运算到随机抽样
26-【Python-Day 26】解锁时间魔法：深入解析 time 与 datetime 模块
27-【Python-Day 27】轻松驾驭操作系统：精通 os 与 sys 模块核心功能
28-【Python-Day 28】从指令到蓝图：Python面向对象编程（OOP）入门指南
29-【Python-Day 29】万物皆对象：详解 Python 类的定义、实例化与 __init__ 方法
30-【Python-Day 30】从 self、cls 到 @staticmethod：Python 面向对象三大方法深度解析
31-【Python-Day 31】一文搞懂 Python 实例属性与类属性：从定义、区别到应用场景
32-【Python-Day 32】面向对象基石之封装：从 __private 到 @property 的深度解析
33-【Python-Day 33】OOP核心之继承（Inheritance）：代码复用与扩展的艺术
34-【Python-Day 34】深入解析Python继承：super()函数、MRO与菱形继承问题
35-【Python-Day 35】深入理解多态：代码更灵活的“鸭子类型”魔法
36-【Python-Day 36】解密文件IO：一文搞懂 Python 读写模式、编码与指针操作
37-【Python-Day 37】程序的守护者：一文彻底搞懂 Python 异常处理 (try-except-else-finally)
38-【Python-Day 38】告别通用错误！一文学会创建和使用 Python 自定义异常
39-【Python-Day 39】精通Python推导式：告别冗长for循环，提升代码效率与格调
40-【Python-Day 40】告别内存溢出！Python 生成器 (Generator) 的原理与实战

---

---

摘要

在处理大规模数据集或数据流时，一次性将所有数据加载到内存中往往会导致性能瓶颈，甚至引发 MemoryError。Python 提供了一种优雅且高效的解决方案——生成器 (Generator)。生成器是一种特殊的迭代器，它不会一次性存储所有值，而是“按需生成”，在每次迭代时才计算并返回一个值。这种“惰性计算”的特性使其成为处理大数据、实现无限序列和构建高效数据管道的利器。本文将从一个常见的内存问题出发，深入剖ducting生成器的核心概念、创建方式、yield 关键字的工作原理，并通过丰富的代码示例和应用场景，带你彻底掌握这个节省内存的强大工具。

一、为什么需要生成器？从一个内存问题谈起

在开始探索生成器之前，让我们先看一个在编程中非常常见的问题：处理一个庞大的数据集合。

1.1 场景引入：处理海量数据

假设我们需要一个函数，用于生成一百万个数字的平方。一个直观的实现方式是使用列表来存储这些结果。

import sysdef generate_squares_list(n):"""生成从 0 到 n-1 的平方数列表"""squares = []for i in range(n):squares.append(i * i)return squares# 生成一百万个平方数
num = 1000000
my_squares_list = generate_squares_list(num)# 查看列表占用的内存大小（单位：字节）
print(f"列表对象本身大小: {sys.getsizeof(my_squares_list)} bytes")
# print(my_squares_list[:5]) # 打印前5个元素查看

当你运行这段代码时，会发现它会瞬间占用相当可观的内存。在我的机器上，这个列表对象本身就占用了超过 8MB 的内存！

1.2 列表的局限性

上述例子暴露了列表（以及其他一次性生成所有元素的数据结构）的显著缺点：

1. 内存消耗巨大：所有数据必须在函数返回前全部计算完毕并存储在内存中。如果数据量达到千万甚至上亿级别，程序可能会因为内存耗尽而崩溃。
2. 启动延迟：在所有元素都生成完毕之前，调用者无法开始处理任何一个数据。对于大数据集，这意味着漫长的等待。

1.3 生成器的核心思想：惰性计算

为了解决这些问题，生成器应运而生。其核心思想是 惰性计算 (Lazy Evaluation) 或 按需生成 (On-demand Generation)。

我们可以把列表比作一个装满了所有商品的仓库，你需要一次性把整个仓库买下来。而生成器则像一个订单生产的工厂，只有在你下订单（即请求下一个数据）时，它才会生产那一件商品并交付给你。这种方式极大地节省了存储空间和初始生产时间。

二、什么是生成器 (Generator)？

2.1 生成器的定义

在 Python 中，生成器 (Generator) 是一种特殊的 迭代器 (Iterator)。它允许你以一种更节省内存的方式来创建可迭代的数据序列。与一次性构建并返回整个列表的函数不同，生成器函数会返回一个生成器对象，这个对象在每次迭代时“生成”一个值，直到耗尽为止。

关键特性：

• 迭代协议：生成器遵循迭代器协议，意味着你可以像遍历列表一样在 for 循环中使用它。
• 状态保持：生成器在每次 yield（生成）一个值后会暂停执行，并保存当前的函数状态（包括局部变量和执行位置）。当下次请求值时，它会从暂停的地方继续执行。

2.2 生成器与迭代器的关系

迭代器是一个更广泛的概念，任何实现了 __iter__() 和 __next__() 方法的对象都是迭代器。而生成器是创建迭代器的一种非常简单和强大的方式。

可以这样理解它们的关系：

graph TDA[可迭代对象 (Iterable)] -- 调用 iter() --> B[迭代器 (Iterator)];C[生成器 (Generator)] -- 是一种 --> B;D[生成器函数/表达式] -- 创建 --> C;style A fill:#f9f,stroke:#333,stroke-width:2pxstyle B fill:#bbf,stroke:#333,stroke-width:2pxstyle C fill:#9f9,stroke:#333,stroke-width:2pxstyle D fill:#ff9,stroke:#333,stroke-width:2px

简而言之，所有生成器都是迭代器，但生成器提供了一种更便捷的语法来自动创建迭代器，而无需手动实现一个类并定义 __iter__() 和 __next__() 方法。

三、创建生成器的两种方式

Python 提供了两种主要的方式来创建生成器，它们分别适用于不同的场景。

3.1 方式一：生成器表达式 (Generator Expression)

生成器表达式看起来非常像列表推导式，但它使用的是圆括号 () 而不是方括号 []。

3.1.1 语法与示例

• 列表推导式 (List Comprehension): [i * i for i in range(10)]，立即在内存中创建一个包含10个元素的列表。
• 生成器表达式 (Generator Expression): (i * i for i in range(10))，创建一个生成器对象，它并不会立即计算所有值。

让我们用生成器表达式来重写最初的平方数示例：

import sys# 生成一百万个平方数 - 使用生成器表达式
num = 1000000
my_squares_generator = (i * i for i in range(num))# 查看生成器对象本身的大小
print(f"生成器对象本身大小: {sys.getsizeof(my_squares_generator)} bytes")
print(f"生成器对象类型: {type(my_squares_generator)}")# 我们可以像遍历列表一样遍历它
# for i in my_squares_generator:
#     # 为了不让屏幕刷屏，我们只打印前5个
#     if i >= 25:
#         break
#     print(i)

输出结果分析：
你会惊讶地发现，无论 num 的值有多大，生成器对象本身占用的内存都非常小（通常只有几百个字节）。这是因为它只存储了生成规则和当前状态，而不是所有的数据。

3.1.2 验证内存占用

下面的代码直观地对比了列表和生成器在处理相同数据量时的内存差异。

import sysnum = 1000000# 列表推导式
list_comp = [i for i in range(num)]
print(f"列表占用内存: {sys.getsizeof(list_comp)} bytes")# 生成器表达式
gen_expr = (i for i in range(num))
print(f"生成器占用内存: {sys.getsizeof(gen_expr)} bytes")

结果一目了然，生成器的内存优势显而易见。

3.2 方式二：使用 yield 关键字的函数

当生成逻辑比较复杂，无法用一个简单的表达式表示时，我们可以使用包含 yield 关键字的函数来创建生成器。

3.2.1 yield 关键字的魔力

一个函数只要包含了 yield 关键字，它就不再是一个普通的函数，而是一个 生成器函数 (Generator Function)。

• 调用一个生成器函数，它不会立即执行函数体内的代码。
• 相反，它会返回一个生成器对象。
• 函数体的代码只有在 for 循环遍历生成器，或使用 next() 函数时才会执行。

3.2.2 示例：重写数字平方函数

现在，我们用 yield 函数来实现平方数生成器：

def generate_squares_yield(n):"""使用 yield 关键字生成从 0 到 n-1 的平方数"""print("--- 生成器开始执行 ---")for i in range(n):print(f"准备生成 {i} 的平方...")yield i * i  # yield 会返回一个值，并在此处暂停print(f"...{i} 的平方已生成，函数继续执行")print("--- 生成器执行结束 ---")# 调用生成器函数，得到一个生成器对象
my_gen = generate_squares_yield(3)
print(f"返回的对象类型: {type(my_gen)}")# 只有在迭代时，函数体才会执行
print("\n开始第一次迭代:")
print(f"得到的值: {next(my_gen)}\n")print("开始第二次迭代:")
print(f"得到的值: {next(my_gen)}\n")print("开始第三次迭代:")
print(f"得到的值: {next(my_gen)}\n")# 如果再次迭代，会抛出 StopIteration 异常
# print(next(my_gen)) # 这行会报错 StopIteration

观察输出，你会清晰地看到函数的执行是如何在 yield 处被“暂停”和“恢复”的。

3.2.3 生成器表达式 vs. yield 函数

特性	生成器表达式	yield 函数
语法	(expr for item in iterable)	标准的 def 函数，但包含 yield
简洁性	非常简洁，适合单行逻辑	更灵活，代码结构更清晰
适用场景	适用于简单的、一次性的生成逻辑	适用于复杂的生成逻辑、需要维护状态或进行复杂计算的场景
可读性	对于复杂逻辑，可读性可能下降	逻辑清晰，易于理解和维护

四、深入 yield 的工作原理

yield 是理解生成器的关键，它赋予了函数“暂停”和“恢复”的能力。

4.1 函数的“暂停”与“恢复”

当生成器函数的代码执行到 yield 语句时：

1. 返回值：yield 右侧表达式的值被返回给调用者。
2. 暂停执行：函数在此处暂停执行。它会冻结当前的所有状态，包括局部变量的值、指令指针等。
3. 等待下次调用：函数进入挂起状态，等待下一次 next() 的调用。

当外部代码再次调用 next() 时：

1. 恢复执行：函数从上次暂停的地方（即 yield 语句之后）恢复执行。
2. 继续执行：直到遇到下一个 yield 语句，或者函数执行结束。
3. 结束迭代：如果函数正常执行完毕（没有更多的 yield），它会自动引发 StopIteration 异常，标志着迭代的结束。

这个过程可以用一个流程图来表示：

graph TDA[调用 next(gen)] --> B{函数是否已启动?};B -- 否 --> C[从函数开头执行];B -- 是 --> D[从上次 yield 处恢复];C --> E{遇到 yield value?};D --> E;E -- 是 --> F[返回 value 并暂停];F --> G[等待下一次 next() 调用];A -.-> G;E -- 否(函数结束) --> H[抛出 StopIteration];

4.2 return vs. yield

关键字	在普通函数中	在生成器函数中
return	结束函数执行，并返回一个值。	结束生成器的迭代过程，并立即引发 StopIteration 异常。return 后的值会作为 StopIteration 异常的参数。
yield	(不适用)	暂停函数执行，返回一个值，并保存当前状态。函数可以在之后被恢复。

4.3 send() 方法：与生成器交互

这是一个更高级的用法。yield 不仅可以返回值，还可以接收值。通过生成器的 send() 方法，我们可以向生成器内部发送数据。

def simple_coroutine():print("-> 协程启动")x = yield  # yield 在这里作为表达式，可以接收 send() 传来的值print(f"-> 协程接收到: {x}")y = yield x + 1print(f"-> 协程接收到: {y}")my_co = simple_coroutine()
next(my_co)  # 启动协程，执行到第一个 yield# 发送值给协程
# send(10) 会让 yield 表达式的返回值为 10，然后 x 被赋值为 10
# 接着代码执行到下一个 yield，返回 x + 1 即 11
value = my_co.send(10) 
print(f"外部接收到: {value}")# 再次发送值
try:my_co.send(20)
except StopIteration:print("协程已结束")

send() 的能力是 Python 协程和异步编程的基石，虽然在日常数据处理中不常用，但了解它有助于你更深入地理解生成器的机制。

五、如何使用生成器

消费（使用）一个生成器非常简单，主要有以下几种方式。

5.1 使用 for 循环遍历

这是最常用、最自然的方式。for 循环会自动处理 next() 的调用和 StopIteration 异常。

def fibonacci_generator(max_val):a, b = 0, 1while a < max_val:yield aa, b = b, a + bfib_gen = fibonacci_generator(30)print("斐波那契数列:")
for num in fib_gen:print(num, end=" ") # 输出: 0 1 1 2 3 5 8 13 21 

5.2 使用 next() 函数手动迭代

当你需要精确控制迭代过程时，可以使用 next()。

gen = (i for i in range(3))print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
# print(next(gen))  # 再次调用会引发 StopIteration

5.3 将生成器转换为其他数据类型

你可以将一个生成器的所有值“展开”到一个列表、元组或集合中。

gen = (i * i for i in range(5))# 转换为列表
my_list = list(gen)
print(f"列表: {my_list}") # 输出: [0, 1, 4, 9, 16]# 注意：一旦生成器被消耗（如转换为列表），它就变空了
# 再次转换会得到一个空列表
my_list_again = list(gen)
print(f"再次转换列表: {my_list_again}") # 输出: []

重要提醒：将一个可能产生海量数据的生成器转换为列表，会失去生成器节省内存的优势，请谨慎使用。

六、生成器的应用场景与优势

6.1 内存优化：处理大数据流

这是生成器最核心的应用。无论是读取 TB 级的日志文件，还是处理来自数据库或网络API的连续数据，生成器都能让你以固定的、极小的内存开销来完成任务。

def read_large_file(file_path):"""逐行读取大文件，无需将整个文件加载到内存"""with open(file_path, 'r', encoding='utf-8') as f:for line in f:yield line.strip()# 使用示例 (假设你有一个很大的log.txt文件)
# for log_entry in read_large_file('log.txt'):
#     if 'ERROR' in log_entry:
#         print(log_entry)

6.2 实现无限序列

列表无法表示无限序列，但生成器可以轻松做到。

def infinite_sequence():"""生成一个无限的整数序列"""num = 0while True:yield numnum += 1# for i in infinite_sequence():
#     print(i) # 这会无限打印，需要手动停止

6.3 协程（Coroutine）的基础

如前所述，生成器的 yield 和 send() 机制是构建协程的基础，这在现代 Python 的 asyncio 库中得到了进一步发展，是实现高并发异步编程的关键。

6.4 总结优势

1. 节省内存 (Memory Efficient)：核心优势。只在需要时才生成数据，内存占用极小。
2. 惰性计算 (Lazy Evaluation)：计算被推迟到需要时才执行，如果数据流在处理中途被中断，可以避免不必要的计算。
3. 代码简洁 (Concise Code)：生成器表达式语法紧凑，yield 函数比手动实现迭代器类要简单得多。
4. 可组合性 (Composability)：可以轻松地将多个生成器串联起来，形成高效的数据处理管道 (pipeline)。

七、总结

通过本文的学习，我们深入了解了 Python 中的内存管理利器——生成器。现在，让我们回顾一下核心要点：

1. 核心价值：生成器通过惰性计算机制，按需生成数据，极大地节省了内存，是处理大数据流、无限序列的首选方案。
2. 创建方式：我们掌握了两种创建生成器的方法：简洁的生成器表达式 (x for x in iterable) 和功能更强大的**yield 关键字函数**。
3. 工作原理：yield 关键字是生成器的灵魂，它能够暂停函数执行并保存其状态，在下次迭代时从暂停处恢复，实现了“即用即生”的特性。
4. 关键优势：生成器的优点突出，包括内存效率高、计算延迟、代码简洁以及易于构建数据处理管道。
5. 实践应用：在未来的编程实践中，当你遇到需要处理一个庞大或未知长度的数据集时，请第一时间想到使用生成器，它将使你的代码更加健壮和高效。

---