python生成器是一种按需生成值的特殊函数，能显著节省内存。其核心是yield关键字，函数执行到yield时暂停并返回值，下次从暂停处继续执行。使用生成器的步骤包括：1. 定义包含yield的函数；2. 调用函数返回生成器对象；3. 用next()或for循环驱动生成器。生成器适合处理海量数据、数据流式处理、节省内存的场景，但不适合多次遍历或随机访问。生成器通过保持状态和惰性求值实现高效数据处理，还可用于构建数据管道、实现迭代器和协程。
python生成器，说白了，就是一种能让你在需要时才计算并生成值的特殊函数。它最大的魅力在于，不是一次性把所有结果都装进内存，而是“用一个，吐一个”，大大节省了内存开销，尤其处理海量数据时，这简直是救命稻草。它不像列表那样需要一次性构建所有元素，而是按需生成，这就像是流水线作业，而不是堆积如山的库存。
Python生成器怎么用？节省内存的高效技巧
生成器的核心其实就是
yield
关键字。当一个函数里包含了
yield
，它就不再是一个普通函数，而是一个生成器函数了。调用它时，它不会立即执行函数体内的代码，而是返回一个生成器对象。这个对象本身就是个迭代器，你可以用
next()
函数或者
for
循环来驱动它。
立即学习“Python免费学习笔记（深入）”；
来看个最简单的例子，比如我们想生成一个斐波那契数列，如果用列表，很快就会内存爆炸：
def fibonacci_list(n): nums = [] a, b = 0, 1 for _ in range(n): nums.append(a) a, b = b, a + b return nums # print(fibonacci_list(1000000)) # 尝试生成百万级，内存占用会很高
而用生成器，你可以这样写：
def fibonacci_generator(n): a, b = 0, 1 count = 0 while count < n: yield a # 关键在这里，每次执行到yield，函数暂停，返回a，下次从这里继续 a, b = b, a + b count += 1 # 使用生成器 fib_gen = fibonacci_generator(10) print("使用next()获取值:") print(next(fib_gen)) # 0 print(next(fib_gen)) # 1 print(next(fib_gen)) # 1 print("n使用for循环遍历:") for num in fibonacci_generator(5): print(num) # 0, 1, 1, 2, 3
你也可以用生成器表达式，它看起来和列表推导式非常像，只不过把方括号
[]
换成了圆括号
()
：
# 列表推导式 my_list = [i * i for i in range(1000000)] # 立即生成所有元素并存入内存 # 生成器表达式 my_generator = (i * i for i in range(1000000)) # 返回一个生成器对象，按需生成
my_generator
在创建时并没有计算任何一个平方值，它只是“知道”如何计算。只有当你遍历它或者调用
next()
时，它才会一个接一个地计算并给出结果。这种“惰性求值”的特性，就是节省内存的秘密。
Python生成器与列表：内存效率对比，何时选择生成器？
说实话，这可能是很多人在考虑用生成器时最关心的问题了：它到底能省多少内存？什么时候我该用它，什么时候又该坚持用列表呢？
我们来做个小实验，用
sys.getsizeof()
看看列表和生成器在存储大量数据时的内存占用：
import sys # 创建一个包含100万个元素的列表 list_data = [i for i in range(1000000)] print(f"列表占用内存: {sys.getsizeof(list_data)} 字节") # 会是一个很大的数字 # 创建一个生成器对象 generator_data = (i for i in range(1000000)) print(f"生成器对象占用内存: {sys.getsizeof(generator_data)} 字节") # 会是一个很小的数字，因为它只存储了生成逻辑
你会发现，列表的内存占用会随着元素数量的增加而线性增长，而生成器对象本身的内存占用几乎是固定的，非常小。这是因为生成器只存储了生成值的逻辑和当前的状态，而不是所有的值。
那么，何时选择生成器呢？
- 处理海量数据或无限序列： 当你需要处理的数据量非常大，甚至可能是无限的（比如实时日志流、网络数据包），无法一次性加载到内存时，生成器是唯一的选择。
- 数据流式处理： 如果你的数据需要经过一系列的转换或过滤，生成器可以构建一个“管道”，数据像水流一样通过，而不是在每个阶段都创建一个完整的中间结果列表。
- 节省内存是首要考量： 在内存受限的环境下（比如嵌入式系统、低配服务器），或者你的程序本身就需要处理大量数据导致内存吃紧时，生成器能有效缓解压力。
- 一次性遍历： 生成器是单向的，一旦遍历完成，它就“耗尽”了，需要重新创建一个生成器对象才能再次遍历。如果你需要多次遍历同一个数据集，或者需要随机访问（通过索引获取某个元素），那么列表或元组会更合适。
反之，如果你的数据集比较小，或者你需要频繁地随机访问元素，又或者你需要多次遍历同一个数据集，那么列表通常是更方便、更直观的选择。毕竟，生成器的优势在于“按需”，而不是“全量”。
深入理解Python生成器：yield关键字的魔力与状态保持
yield
这个关键字，真是生成器魔法的核心。它不只是简单地返回一个值，它更像是一个“暂停并保存现场”的指令。
当我们调用一个生成器函数时，它并不会像普通函数那样直接执行到底，而是返回一个生成器对象。这个对象可以被看作是一个特殊的迭代器。当你第一次对它调用
next()
（或者在
for
循环中第一次迭代），生成器函数开始执行，直到遇到第一个
yield
。
这时，它会：
- 暂停执行： 函数的当前状态（包括局部变量、执行到的位置）会被完整地保存下来。
- 返回
yield
后面的值：
这个值就是当前迭代的结果。
下一次你再次调用
next()
时，生成器函数会从上次
yield
暂停的地方“苏醒”过来，继续执行，直到遇到下一个
yield
，或者函数执行完毕。如果函数执行完毕，没有更多的
yield
，那么再次调用
next()
就会抛出
StopIteration
异常，这正是
for
循环能够知道何时停止遍历的机制。
这种“暂停-返回-恢复”的机制，使得生成器能够非常高效地处理数据流。它不需要一次性地把所有数据都加载到内存中，而是每次只计算和处理一个数据点。这种状态保持的能力，让生成器在处理序列数据时显得非常优雅和高效。
举个例子，一个简单的计数器生成器：
def simple_counter(max_val): print("开始计数") i = 0 while i < max_val: print(f"即将yield {i}") yield i i += 1 print(f"继续执行，i现在是 {i}") print("计数结束") my_counter = simple_counter(3) print("第一次next()") print(next(my_counter)) # 会打印 "开始计数", "即将yield 0" print("第二次next()") print(next(my_counter)) # 会打印 "继续执行，i现在是 1", "即将yield 1" print("第三次next()") print(next(my_counter)) # 会打印 "继续执行，i现在是 2", "即将yield 2" try: print("第四次next()") print(next(my_counter)) # 会打印 "继续执行，i现在是 3", "计数结束", 然后抛出StopIteration except StopIteration: print("生成器已耗尽")
从这个例子，你应该能清楚地看到
yield
是如何控制函数执行流的，以及生成器如何保持其内部状态（
i
的值）的。这种机制是理解生成器强大之处的关键。
除了节省内存，Python生成器还有哪些高级应用场景？
当然，生成器不仅仅是内存优化这么简单，它在很多高级编程场景中都扮演着重要的角色。它的“按需生成”和“状态保持”特性，让它成为了构建数据处理管道、实现协程（coroutine）以及处理异步任务的利器。
-
构建数据处理管道（Pipeline）： 想象一下，你有一个巨大的日志文件，需要先过滤出特定错误信息，然后解析出时间戳，最后统计每个小时的错误数量。如果每一步都生成一个中间列表，那内存消耗会非常大。生成器可以完美地解决这个问题：
def read_large_log(filepath): with open(filepath, 'r') as f: for line in f: yield line.strip() # 逐行读取，不一次性加载所有行 def filter_errors(lines_gen): for line in lines_gen: if "ERROR" in line: yield line # 过滤错误行 def parse_timestamp(error_lines_gen): import re for line in error_lines_gen: match = re.search(r'[(d{4}-d{2}-d{2} d{2}:d{2}:d{2})]', line) if match: yield match.group(1) # 提取时间戳 # 实际使用时 # log_lines = read_large_log('my_app.log') # error_lines = filter_errors(log_lines) # timestamps = parse_timestamp(error_lines) # for ts in timestamps: # print(ts)这个链式调用中，数据像水流一样从一个生成器流向另一个，每一步都只处理当前需要的数据，极大地提高了效率和内存利用率。
-
实现自定义迭代器： 在Python中，任何可迭代对象（如列表、字符串、字典）都可以用
for
循环遍历，因为它们实现了迭代器协议（有
__iter__
方法返回一个迭代器，迭代器有
__next__
方法）。而生成器函数，本身就是一种创建迭代器最简洁的方式。你不需要手动去写一个类，实现
__iter__
和
__next__
方法，一个
yield
就搞定了。这对于需要自定义复杂迭代逻辑的场景非常方便。
-
协程（Coroutines）的基础： 虽然现在Python有了
async/await
语法来处理异步编程，但最初的协程概念，以及
async/await
的底层实现，其实是建立在生成器之上（特别是
yield from
语句）。生成器通过
yield
暂停和恢复执行的能力，天然适合处理那些需要等待I/O操作完成的任务，而不会阻塞整个程序。虽然我们日常写异步代码更常用
async/await
，但了解生成器是理解这些高级概念的基石。
总的来说，生成器远不止是“省内存”的工具，它提供了一种非常灵活和强大的控制流机制，让python程序在处理数据、构建复杂逻辑时更加高效、优雅。掌握它，你就能写出更具扩展性和性能的代码。
