解释一下Python的生成器（Generator）和迭代器（Iterator）。

幻影之瞳

发布时间：2025-09-03 14:46:01

563人浏览过

来源于php中文网

原创

生成器是创建迭代器的简洁方式，通过yield按需生成值，节省内存；迭代器通过__iter__和__next__实现遍历协议，支持惰性计算，适用于处理大文件、无限序列和构建数据管道，提升性能与资源利用率。

解释一下python的生成器（generator）和迭代器（iterator）。

Python中的生成器（Generator）和迭代器（Iterator）是处理序列数据，尤其是大型或无限序列时非常重要的概念。简单来说，迭代器是一个对象，它能记住遍历的位置，并且可以通过

next()

方法逐个返回序列中的元素，直到序列结束。而生成器，则是创建迭代器的一种简洁方式，它本质上是一个特殊的函数，当被调用时会返回一个生成器对象（即一个迭代器），并通过

yield

语句而非

return

来“生成”值。

解决方案

理解生成器和迭代器，其实就是理解Python如何高效地处理数据流。

迭代器（Iterator）

迭代器是Python中一个非常基础且核心的协议。任何实现了迭代器协议的对象都可以被称为迭代器。这个协议要求对象必须实现两个特殊方法：

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

```
__iter__(self)
```
：这个方法应该返回迭代器本身。这是为了让迭代器可以被用在
```
for...in
```
循环中，或者作为
```
iter()
```
函数的参数。
```
__next__(self)
```
：这个方法必须返回序列中的下一个项目。当没有更多项目时，它必须抛出
```
StopIteration
```
异常，以信号通知迭代结束。

我们平时用的列表、元组、字符串、字典等都是“可迭代对象”（Iterable），它们内部实现了

__iter__

方法，但它们本身不是迭代器。当你对一个可迭代对象调用

iter()

函数时，它会返回一个真正的迭代器对象。

my_list = [1, 2, 3]
my_iterator = iter(my_list) # my_iterator 现在是一个迭代器

print(next(my_iterator)) # 输出 1
print(next(my_iterator)) # 输出 2
print(next(my_iterator)) # 输出 3
# print(next(my_iterator)) # 再次调用会抛出 StopIteration

迭代器的核心价值在于其“按需生成”的特性。它不会一次性把所有数据都加载到内存中，而是每次请求时才计算或读取下一个数据，这对于处理海量数据或无限序列尤其有效。

生成器（Generator）

生成器是创建迭代器的一种更优雅、更Pythonic的方式。你不需要手动去定义一个类，实现

__iter__

和

__next__

方法。你只需要编写一个普通的函数，但在函数体中使用

yield

关键字来“返回”数据。

当一个函数包含

yield

语句时，它就不再是一个普通函数，而变成了一个生成器函数。调用这个函数时，它不会立即执行函数体内的代码，而是返回一个生成器对象（它本身就是一个迭代器）。

每当你对这个生成器对象调用

next()

方法时（或者在

for

循环中），生成器函数就会从它上次暂停的地方继续执行，直到遇到下一个

yield

语句，然后“生成”一个值并再次暂停。它的所有局部变量状态都会被保存下来，直到下次

next()

调用时恢复。当函数执行完毕，或者遇到

return

语句（不带返回值），或者没有更多

yield

时，它会自动抛出

StopIteration

异常。

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

gen = simple_generator() # 调用函数，但代码未执行，返回一个生成器对象

print("第一次 next:")
print(next(gen)) # 执行到第一个 yield 1

print("第二次 next:")
print(next(gen)) # 从上次暂停处继续执行到 yield 2

print("第三次 next:")
print(next(gen)) # 从上次暂停处继续执行到 yield 3

# print(next(gen)) # 再次调用会抛出 StopIteration

除了生成器函数，Python还提供了生成器表达式，它类似于列表推导式，但使用圆括号而非方括号，直接返回一个生成器对象：

squares_generator = (x * x for x in range(5)) # 这是一个生成器表达式
print(list(squares_generator)) # 将生成器转换为列表，输出 [0, 1, 4, 9, 16]

生成器极大地简化了迭代器的创建过程，让代码更简洁、可读性更高，同时保留了迭代器按需生成、节省内存的优点。

Python中生成器与普通函数有什么本质区别？

生成器函数与普通函数的核心差异在于它们的执行模型和返回值机制。一个普通函数，从被调用开始，会一直执行到

return

语句或者函数体结束。一旦

return

语句被执行，函数就彻底结束了，它会返回一个值（如果没有

return

语句，则默认返回

None

），并且其内部的所有局部变量和执行状态都会被销毁。你可以把它想象成一个一次性的过程。

而生成器函数则完全不同。当一个包含

yield

关键字的函数被调用时，它并不会立即执行函数体内的任何代码。相反，它会返回一个生成器对象。这个生成器对象是一个特殊的迭代器。每次你对这个生成器对象调用

next()

方法时（或者在

for

循环中隐式调用），生成器函数才会从它上次暂停的地方（即上次

yield

语句之后）开始执行，直到遇到下一个

yield

语句。此时，它会“生成”一个值，并暂停执行，将控制权交还给调用者。最关键的是，它的所有局部变量和执行状态都会被保留下来。下次再调用

next()

时，它会从上次暂停的地方继续，就像什么都没发生过一样。这种“暂停-恢复”的机制，使得生成器函数能够维护自己的状态，并按需地、逐步地产生一系列值，而不是一次性计算并返回所有值。

这就像是普通函数给你一张照片，一次性的；而生成器函数则给你一台电影放映机，你可以随时暂停、播放，每次只看一帧，而且电影的状态（播放到哪了）始终是保存的。这种行为在很多场景下都非常有用，尤其是处理大量数据流时。

超级简历WonderCV

免费求职简历模版下载制作，应届生职场人必备简历制作神器

下载

什么时候应该优先选择使用生成器而不是列表？

在实际开发中，选择生成器还是列表，主要取决于你对数据的处理需求以及资源的考量，特别是内存。通常来说，以下几种情况，我会倾向于优先使用生成器：

处理海量数据或无限序列： 这是生成器最典型的应用场景。如果你的数据量非常大，比如几GB甚至几十GB的日志文件，或者你需要处理一个理论上无限的序列（例如斐波那契数列），将所有数据一次性加载到内存中会迅速耗尽系统资源，甚至导致程序崩溃。生成器能够按需生成数据，每次只在内存中保留当前处理的数据项，极大地降低了内存占用。比如，读取一个大文件时，逐行使用
```
f.readline()
```
或者直接
```
for line in f:
```
（文件对象本身就是迭代器）比
```
f.readlines()
```
（一次性读取所有行到列表中）要高效得多。
“惰性计算”（Lazy Evaluation）： 当你不需要立即获得所有结果，或者结果的计算成本很高时，生成器是理想选择。它只在你真正请求下一个值时才进行计算。例如，你可能需要对一个非常大的数据集进行一系列复杂的转换，但最终只需要前100个结果。如果使用列表，所有的转换都会被立即执行，即使大部分结果最终会被丢弃。而生成器则只会计算并转换你需要的那100个结果，节省了大量的计算资源和时间。
构建数据管道（Data Pipelines）： 在数据处理流程中，经常需要将多个操作串联起来，形成一个处理链。生成器非常适合构建这种管道。每个生成器可以负责一个特定的转换步骤，并将处理后的数据“yield”给下一个生成器，形成一个高效、低内存占用的数据流。这比创建多个中间列表来存储每个步骤的结果要优雅和高效得多。
生成器表达式的简洁性： 对于一些简单的、一次性的序列生成需求，生成器表达式比列表推导式更节省内存，也更简洁。比如
```
(x*x for x in range(10**6))
```
比
```
[x*x for x in range(10**6)]
```
在内存上要友好得多。

总结一下，如果你的数据量可控且你确实需要随机访问或多次遍历整个数据集，那么列表可能更方便。但只要涉及到大规模数据、按需计算或构建高效数据流，生成器几乎总是更优的选择。

如何理解Python迭代协议及其在实际开发中的应用？

Python的迭代协议是其语言设计中一个非常核心且优雅的机制，它定义了对象如何被遍历。简单来说，一个对象如果想被

for

循环、

list()

、

tuple()

、

sum()

等内置函数以及各种需要遍历的场景使用，它就必须遵循迭代协议。这个协议由两个特殊方法构成：

__iter__()

和

__next__()

。

```
__iter__(self)
```
方法：
- 这个方法被调用时，应该返回一个迭代器对象。如果对象本身就是迭代器，那么它应该返回
```
self
```
  。
- ```
iter()
```
  内置函数就是通过调用对象的
```
__iter__()
```
  方法来获取迭代器的。
- 一个实现了
```
__iter__()
```
  方法的对象被称为可迭代对象（Iterable）。列表、元组、字符串、字典、文件对象等都是可迭代对象。它们内部存储了所有数据，但它们本身不是迭代器，因为它们没有
```
__next__()
```
  方法来逐个吐出数据。
```
__next__(self)
```
方法：
- 这个方法是迭代器实际工作的核心。每次被调用时，它应该返回序列中的下一个元素。
- 当序列中所有元素都被返回完毕，没有更多元素可供返回时，
```
__next__()
```
  方法必须抛出
```
StopIteration
```
  异常。这是Python通知迭代结束的标准方式。
- ```
next()
```
  内置函数就是通过调用迭代器对象的
```
__next__()
```
  方法来获取下一个元素的。
- 一个同时实现了
```
__iter__()
```
  （返回
```
self
```
  ）和
```
__next__()
```
  方法的对象，就是一个迭代器（Iterator）。

在实际开发中，理解迭代协议及其应用，能让你写出更灵活、更高效、更符合Python惯例的代码：

自定义可迭代对象和迭代器： 当你需要创建自己的数据结构，并希望它能像内置类型一样被

for

循环遍历时，你就需要实现迭代协议。比如，你可能有一个表示二叉树的类，你想遍历树中的所有节点。你可以为这个树类实现

__iter__

方法，让它返回一个遍历树的迭代器对象。这个迭代器对象则需要实现

__next__

方法来按某种顺序（如前序、中序、后序）返回节点。

class MyRange:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self # MyRange 实例本身就是迭代器

    def __next__(self):
        if self.current < self.end:
            num = self.current
            self.current += 1
            return num
        raise StopIteration

# 应用：自定义一个像range()一样的序列
for i in MyRange(1, 5):
    print(i) # 输出 1 2 3 4

资源管理和数据流处理： 文件对象就是一个很好的例子。当你打开一个文件，
```
for line in file_object:
```
可以直接逐行读取，而不会一次性加载整个文件。这是因为文件对象实现了迭代协议，它的
```
__next__
```
方法负责读取下一行。在处理大型数据集、网络流或数据库游标时，这种模式可以有效管理内存和外部资源。
生成器作为迭代协议的语法糖： 正如前面提到的，生成器函数和生成器表达式是创建迭代器最简单、最Pythonic的方式。它们自动处理了
```
__iter__
```
和
```
__next__
```
的实现细节，以及
```
StopIteration
```
异常的抛出。这意味着，只要你的需求是按需生成一系列值，而不是存储所有值，生成器几乎总是你的首选。它让你专注于数据生成的逻辑，而不用关心迭代协议的底层实现。