python中什么是生成器_Python生成器(Generator)概念与用法

裘德小鎮的故事

发布时间：2025-09-15 19:56:01

324人浏览过

来源于php中文网

原创

生成器是一种特殊的迭代器，通过yield实现惰性求值，调用生成器函数返回生成器对象，每次迭代时暂停并返回值，节省内存。适用于处理大文件、无限序列等场景，避免一次性加载所有数据。创建方式有生成器函数和生成器表达式，前者用yield返回值，后者类似列表推导式但使用圆括号，更节省内存。yield from可委托其他生成器，简化嵌套逻辑。

python中什么是生成器_python生成器(generator)概念与用法

Python中的生成器（Generator）本质上是一种特殊的迭代器，它允许你以一种“惰性”的方式生成序列中的值，而不是一次性将所有值都存储在内存中。简单来说，它就像一个“按需供货”的工厂，只有当你真正需要下一个产品时，它才会生产出来，极大地节省了资源。

解决方案

理解Python生成器，核心在于它的工作机制和它所解决的问题。它通过

yield

关键字实现了一种“暂停-恢复”的执行模式。当你调用一个生成器函数时，它并不会立即执行函数体内的所有代码，而是返回一个生成器对象。只有当你对这个生成器对象进行迭代（例如使用

for

循环，或者手动调用

next()

函数）时，函数体内的代码才会开始执行，直到遇到第一个

yield

语句。此时，函数会“暂停”执行，将

yield

后面的值返回给调用者，并记住当前的执行状态。当下次继续迭代时，函数会从上次暂停的地方继续执行，直到遇到下一个

yield

或函数结束。这种机制使得生成器非常适合处理大型数据集或无限序列，因为它避免了将所有数据一次性加载到内存中，从而提高了效率和性能。

要创建一个生成器，最常见的方式有两种：

生成器函数（Generator Function）：这是最直接的方式，在函数定义中使用

yield

关键字。任何包含

yield

的函数都会自动成为一个生成器函数。

def simple_generator():
    print("开始生成...")
    yield 1
    print("生成了1")
    yield 2
    print("生成了2")
    yield 3
    print("生成了3")

# 调用生成器函数会返回一个生成器对象
gen = simple_generator()

# 迭代生成器
print(next(gen)) # 输出: 开始生成... \n 1
print(next(gen)) # 输出: 生成了1 \n 2
print(next(gen)) # 输出: 生成了2 \n 3
# print(next(gen)) # 会抛出 StopIteration 异常

# 也可以用for循环
print("\n使用for循环:")
for value in simple_generator():
    print(value)
# 输出:
# 开始生成...
# 1
# 生成了1
# 2
# 生成了2
# 3
# 生成了3

生成器表达式（Generator Expression）：这是一种更简洁的创建生成器的方式，语法上类似于列表推导式，但使用圆括号

()

而不是方括号

[]

。它通常用于创建一次性、简单的生成器。

# 列表推导式 (一次性创建所有元素并存储)
my_list = [i * 2 for i in range(5)] # [0, 2, 4, 6, 8]
print(f"列表占用内存: {my_list.__sizeof__()} bytes")

# 生成器表达式 (按需生成，不占用额外内存存储所有元素)
my_generator = (i * 2 for i in range(5))
print(f"生成器对象占用内存: {my_generator.__sizeof__()} bytes") # 明显小于列表

print("\n迭代生成器表达式:")
for value in my_generator:
    print(value) # 0, 2, 4, 6, 8 (逐个打印)

为什么我们需要生成器？它解决了哪些实际问题？

说实话，我刚接触生成器的时候，觉得它有点“玄乎”，不就是能迭代吗？列表不也能迭代？但随着项目经验的增长，我逐渐意识到生成器在特定场景下简直是救星。它最核心的价值在于内存效率和处理无限序列的能力。

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

想象一下，你正在处理一个巨大的日志文件，可能有几十GB甚至上百GB，或者需要从数据库中查询数百万条记录。如果试图一次性将所有数据都加载到内存中，你的程序很可能直接崩溃，或者变得异常缓慢。这时候，生成器就派上用场了。它允许你逐行（或逐条）读取和处理数据，每次只在内存中保留当前正在处理的那一小部分，而不是整个文件或所有记录。这对于资源受限的环境（比如嵌入式系统）或者需要处理“流式”数据（如网络数据包、实时传感器数据）的场景尤其重要。

再比如，你需要生成一个斐波那契数列，但你不知道到底需要多少个，或者可能需要一个“无限”长的数列。列表是无法存储无限序列的，但生成器可以。你可以编写一个生成器函数，它会按需不断地生成下一个斐波那契数，而不会耗尽内存。

def fibonacci_generator():
    a, b = 0, 1
    while True: # 理论上可以无限生成
        yield a
        a, b = b, a + b

# 只需要前10个斐波那契数
fib_gen = fibonacci_generator()
for _ in range(10):
    print(next(fib_gen), end=" ") # 0 1 1 2 3 5 8 13 21 34
print()

# 如果需要更多，只需继续迭代，而不会预先计算所有值

此外，生成器还能让代码变得更简洁、更符合“迭代器模式”的设计理念。当你的操作天然就是逐个处理元素时，用生成器来封装这个过程，代码会显得更清晰、更易于维护。它将“如何生成数据”和“如何使用数据”的逻辑优雅地分离开来。

生成器函数与普通函数有什么不同？

yield

关键字是如何工作的？

这大概是初学者最容易感到困惑的地方。我记得我当时就一直在想，

yield

到底是个什么鬼？它和

return

看起来有点像，但行为又完全不同。

最主要的区别在于：

Programming Helper

AI代码自动生成器，在AI的帮助下更快地编程

下载

返回类型和行为：
- 普通函数：执行到
```
return
```
  语句时，函数会彻底结束，并将
```
return
```
  后面的值返回给调用者。函数内部的所有局部变量和执行状态都会被销毁。每次调用普通函数，它都会从头开始执行。
- 生成器函数：当它包含
```
yield
```
  关键字时，它不再是一个普通的函数。调用它不会立即执行函数体，而是返回一个生成器对象。这个对象是一个迭代器，你可以对它调用
```
next()
```
  方法或者用
```
for
```
  循环迭代。当执行到
```
yield
```
  语句时，函数会“暂停”执行，将
```
yield
```
  后面的值发送给调用者，但它会保留当前的执行状态（包括局部变量的值、当前的执行位置等）。下次调用
```
next()
```
  时，函数会从上次暂停的地方继续执行，直到遇到下一个
```
yield
```
  或函数结束。
状态管理：
- 普通函数是无状态的（在两次调用之间）。
- 生成器函数是有状态的，它能够记住自己上次运行到哪里，这正是它实现“惰性”计算的关键。

yield

关键字的工作方式，可以理解为一个“生产-暂停”的机制。当你调用

next(gen_obj)

时：

生成器函数从上次
```
yield
```
之后的地方开始执行。
执行代码直到遇到下一个
```
yield expression
```
。
函数暂停，
```
expression
```
的值被返回给
```
next()
```
的调用者。
生成器函数的状态（包括所有局部变量）被保存下来。
当再次调用
```
next(gen_obj)
```
时，它会从第1步继续，恢复到上次暂停的状态。
如果生成器函数执行完毕，没有更多的
```
yield
```
语句，或者显式地执行了
```
return
```
（没有返回值），那么
```
next()
```
调用就会抛出
```
StopIteration
```
异常，表示迭代结束。

def my_counter(n):
    print("计数器启动")
    i = 0
    while i < n:
        print(f"即将生成 {i}")
        yield i
        i += 1
        print(f"生成 {i-1} 后，i变为 {i}")
    print("计数器结束")

counter = my_counter(3)

print("第一次next()")
print(next(counter)) # 输出: 计数器启动 \n 即将生成 0 \n 0

print("第二次next()")
print(next(counter)) # 输出: 生成 0 后，i变为 1 \n 即将生成 1 \n 1

print("第三次next()")
print(next(counter)) # 输出: 生成 1 后，i变为 2 \n 即将生成 2 \n 2

print("第四次next() (会报错)")
try:
    print(next(counter)) # 输出: 生成 2 后，i变为 3 \n 计数器结束 \n StopIteration
except StopIteration:
    print("迭代结束了")

通过这个例子，你可以清楚地看到

yield

如何控制了函数的执行流程，让它像一个可暂停、可恢复的播放器。

除了生成器函数，还有哪些创建生成器的方法？它们各自的适用场景是什么？

除了生成器函数，Python还提供了另一种非常便捷的方式来创建生成器：生成器表达式。此外，对于更复杂的生成器组合场景，

yield from

语句也值得一提。

生成器表达式 (Generator Expressions)
- 语法：
```
(expression for item in iterable if condition)
```
- 特点：
  - 与列表推导式非常相似，但使用圆括号
```
()
```
    而不是方括号
```
[]
```
    。
  - 它会立即返回一个生成器对象，而不是像列表推导式那样立即构建一个完整的列表。
  - 惰性求值，只在迭代时按需生成值。
  - 通常比生成器函数更简洁，尤其适用于简单的、一次性的生成需求。
- 适用场景：
  - 当你需要对一个可迭代对象进行简单的转换或过滤，并且不希望一次性在内存中创建所有结果时。
  - 作为函数参数直接传递，例如
```
sum((x*x for x in range(10)))
```
    ，这比先创建一个列表再求和要高效得多。
  - 处理大型数据集的中间步骤，避免创建临时列表。
```
# 过滤偶数的平方
even_squares_gen = (x * x for x in range(10) if x % 2 == 0)
print("生成器表达式结果:")
for val in even_squares_gen:
    print(val) # 0, 4, 16, 36, 64

# 直接在函数中使用，无需创建中间列表
total_sum = sum(x for x in range(1, 1000001)) # 计算1到100万的和，不会创建百万元素的列表
print(f"1到100万的和: {total_sum}")
```
```
yield from
```
语句 (Python 3.3+)
- 语法：
```
yield from iterable
```
- 特点：
  - ```
  yield from
```
  是一个更高级的特性，主要用于将控制权委托给另一个生成器（或任何可迭代对象）。
- 它能有效地“扁平化”嵌套的生成器调用，使代码更简洁，避免了手动循环
```
  for item in sub_generator: yield item
```
  。
- 它还提供了更复杂的双向通信机制（
```
  send()
```
  、
```
  throw()
```
  、
```
  close()
```
  ），这在协程（coroutines）中尤为重要，但对于普通生成器，我们主要关注其委托迭代的能力。
- 适用场景：
  - 当你需要将多个生成器串联起来，或者在一个生成器中调用另一个生成器来生成值时。
  - 处理嵌套的可迭代结构，例如，扁平化一个包含列表的列表，或者从多个数据源依次读取数据。
  - 构建更复杂的、可组合的迭代逻辑。
```
def sub_generator(start, end):
    for i in range(start, end):
        yield i

def main_generator():
    print("开始生成第一个序列")
    yield from sub_generator(1, 3) # 委托给sub_generator(1,3)
    print("开始生成第二个序列")
    yield from sub_generator(10, 12) # 委托给sub_generator(10,12)
    print("生成完毕")

for val in main_generator():
    print(val)
# 输出:
# 开始生成第一个序列
# 1
# 2
# 开始生成第二个序列
# 10
# 11
# 生成完毕
```
```
yield from
```
让代码看起来更像是在直接
```
yield
```
子生成器的内容，而不是手动迭代。这在处理复杂的数据管道或异步编程时，能带来巨大的便利。