Python：迭代器对象

在 Python 的对象模型中，“迭代器”（iterator）并不是一种在语法层面被显式声明的特殊结构，也不是某类容器对象天然具备的固有属性。所谓迭代器对象（iterator object），本质上是解释器在特定迭代语义语境下，为了完成“逐个取值”这一语言行为，而所依赖的一类用于承载遍历过程状态的运行期对象。

理解迭代器对象，是澄清“可迭代”、“迭代”、“for 循环”、“生成器”、“一次性遍历”等概念边界的关键，也是理解 Python 迭代协议在对象模型中如何落地的重要一环。

一、从 for 语句谈起：迭代并非对象的主动行为

在严格的语言机制层面，“列表在迭代”、“for 循环遍历了列表”等并非准确表述，迭代首先指的是解释器在特定语义语境下的行为。

比如：

    print(x)

当解释器进入 for 这一迭代语义语境，它需要解决的问题是：“我该如何连续、受控地取得这个对象中的元素？”

因此，“迭代”首先是一种解释器行为，而非对象能力的自发表现。

而迭代器对象（iterator object），正是解释器在这一过程中通过迭代协议取得（通常由 __iter__ 返回）的、用于承载“逐个取值状态”的运行期对象。

二、迭代的执行路径

比如，上面的 for 循环，其语义执行过程可抽象为：

    print(x)

1、解释器确认 for 语句语法结构，触发“顺序取值”的语义。

2、在对象 [1,2,3] 的类型（list）上解析并调用 __iter__。

3、__iter__ 返回一个实现了 __next__ 的对象（迭代器对象）。

4、解释器进入迭代推进阶段，持续调用 __next__，依次获得元素。

5、当 __next__ 发现没有合法的下一个元素时，抛出 StopIteration。

6、解释器捕获到 StopIteration，终止迭代。

需要强调的是，[1, 2, 3] 在此语境中承担的是入口角色（常称为“可迭代对象”），真正执行“逐个取值”动作的，是解释器通过迭代协议取得的迭代器对象，该对象在一次迭代过程中维护并推进自身的遍历状态。

三、什么是迭代器对象

从对象模型角度看，一个对象只要实现了 __next__，并在 __iter__ 中返回 self，就可以在迭代协议中承担迭代器对象的语义角色。

示例：

    print(x)

输出：

2

（1）Counter 的类型实现了 __iter__ 和 __next__，因此其实例同时承担两项职责：保存遍历状态（如 current）和通过 __next__ 定义了逐步取值与终止条件。

（2）__iter__ 方法返回 self 的作用，并不是为了“重新开始遍历”，而是向解释器明确表示：当前对象本身已经是可供解释器推进的迭代器实体。

iter(it) is it   # True

这一示例清楚地揭示了迭代协议方法的一个关键分工：

• __iter__ 只负责在协议入口处提供“迭代器对象”

• __next__ 才真正承担遍历状态的推进、取值逻辑以及终止判定

要注意的是，__iter__ 既可以在对象本身即为迭代器时返回自身（return self），也可以返回一个新的迭代器对象。

四、将迭代器对象与容器对象分离的设计

当对象自身保存遍历状态、并描述“一次具体的遍历过程”时，__iter__ 返回 self 是合理且必要的设计。而当对象只是一个用于表示“可反复使用的数据集合”时，让 __iter__返回一个新的迭代器对象，才能保证每次遍历互不干扰。

示例：

（1）MyRange 的实例并不保存遍历进度，它只定义了“可遍历的范围”这一抽象语义。

（2）每一次调用 MyRange.__iter__，都会生成一个新的 MyRangeIterator 实例（迭代器对象）。

（3）遍历状态完全封装在这个迭代器对象中。

因此：

    print(x,end=" ")   # 0 1 2 3 4 

（1）实例对象 r 的类型实现了 __iter__。

（2）list(r) 使得 r 进入迭代语境，解释器才调用 r.__iter__()，返回一个自定义的迭代器对象。

（3）同理，for 语句也使得 r 进入迭代语境，返回另一个迭代器对象。

需要强调的是，实例对象 r 承担的是可迭代对象（数据容器语义），只有在进入迭代语境时，解释器才会通过其 __iter__ 方法取得一个迭代器对象（MyRangeIterator 实例）。

这一分离体现了一个明确的设计判断：遍历状态不应属于数据容器对象，而应属于一次具体的遍历过程。

五、内置容器类型与迭代器的关系

Python 中常见的内置容器类型，在迭代语义语境下都可以作为“可迭代对象”（数据容器语义）使用：

• list

• tuple

• range

• str

• bytes

• bytearray

• memoryview

它们的类型均实现了 __iter__ 方法，为解释器提供迭代协议的入口。

以最常见的列表为例：

lst = [1, 2, 3]

lst 可以直接用于 for 循环，但它本身并不是迭代器对象：

it is lst    # False

（1）内置函数返回一个迭代器对象，可用于 next() 或循环遍历。

（2）list 对象并不保存遍历进度，因为 type(lst) 并未实现 __next__。

（3）type(lst) 中的 __iter__ 的职责，与前面示例中的 MyRange.__iter__ 在语义上完全一致：返回一个新的迭代器对象。

因此：

it1 is it2     # False

这说明，两个迭代器对象引用同一个列表对象，并各自维护独立的遍历状态且互不干扰。这正是内置容器类型对象可以被安全、反复遍历的根本原因。

需要特别说明的是，迭代器对象并不存在一个统一的类型。例如：

type((x for x in range(3)))  # generator

但在迭代协议中，它们承担的语义角色完全一致：

在一次迭代过程中，负责保存遍历所需的最小状态，并逐步产出元素。

六、迭代器对象的“一次性”语义与状态归属

在 Python 中，数据容器类型对象负责“数据存在”，而迭代器对象则负责对该数据源的一次具体遍历过程。

例如：

next(it)  # 抛出 StopIteration

在这一过程中：

• 原始列表对象始终保持不变，且遍历进度并未写回列表

• 每一次 next(it)，推进的都是迭代器对象自身的内部状态

在使用迭代器对象时，一个常见但极易被误解的现象是：

list(it)   # []

这说明，迭代器对象描述的是“一次具体的遍历过程”，而不是“一个可反复遍历的数据集合”。

在第一次遍历过程中，迭代器对象的内部状态已推进至终点；再次取值时，协议所定义的“下一元素”已不再存在，因此直接终止。

若希望重新遍历同一组数据，就必须重新生成一个新的迭代器对象：

it2 = iter(nums)

这里的 it1 与 it2 引用同一个容器对象，各自维护独立的遍历状态，描述的是两次彼此无关的遍历过程。

从迭代协议与对象模型的角度看：

迭代器对象是状态化的，它的“一次性”并非偶然行为，而是其语义定义的必然结果；遍历状态不属于容器对象，而完全归属于迭代器对象本身。

七、迭代器的应用场景

1、惰性计算

迭代器通过按需调用 __next__ 逐步产出元素，使数据生成与计算过程延迟到真正需要时才发生，从而降低内存占用并提升可扩展性。

2、统一的数据流接口

迭代协议为不同类型的数据源提供统一的推进方式，使各种对象在数据处理函数中以一致的接口被消费。

3、流式数据处理

迭代器以状态推进的形式逐段读取数据，使大规模或无限数据源能够在有限资源下持续处理。

4、自定义遍历策略

通过在迭代器中实现特定的 __next__ 逻辑，可以将遍历规则与数据结构分离，从而独立定义元素的生成与推进方式。

详情请参阅：

小结

迭代器对象不是语法结构，也不是容器对象的内在组成部分，而是解释器在迭代语义语境中取得或生成的、用于承载遍历过程所需最小状态的运行期对象。它通过 __next__ 推进取值过程，通过 StopIteration 明确终止边界，是 Python 迭代协议中真正执行“逐个获取元素”职责的核心实体。

理解迭代器对象，有助于从对象模型层面准确把握 Python 对状态、行为与语义角色的清晰分工。

“点赞有美意，赞赏是鼓励”