迭代协议（Iteration Protocol）是Python中一个核心但常被误解的概念。它并非对象主动具备的某种“超能力”，而是解释器在处理for循环、推导式等需要“逐个取值”的语法时，所遵循的一套规则。理解这套规则，能让你真正看清for x in obj:背后的执行路径，而不是停留在“列表可以被循环”这样的表层认知。
一、什么是迭代协议？
1. 为什么称为“协议”？
“迭代”（iteration）这个行为，并非对象主动发起。当你写下for x in obj:时，实际上是解释器进入了需要顺序取值的特定语境。此时，解释器不会假定对象“会迭代”，而是按照一套既定的规则（即协议），检查对象的类型结构，并据此决定如何建立、推进和终止这次取值过程。
所以，迭代协议关注的是：在“顺序取值”的语境下，解释器该如何行动。
2. 协议的核心方法
现代Python的迭代协议主要依赖两个核心方法：
- 容器级协议方法：
__iter__(self)
- 迭代器级协议方法：
__next__(self)
这些方法只是定义在类中的普通函数。它们是否具有“迭代”的语义，完全取决于解释器是否在迭代语境中选择了这条解释路径。
3. 迭代过程拆解
当你写下一个简单的for循环：
for x in [10, 20, 30]:
print(x)
在解释器看来，其行为逻辑等价于以下代码：
iter_obj = iter([10, 20, 30]) # 调用 __iter__()，获取迭代器
while True:
try:
item = next(iter_obj) # 调用 __next__()，获取下一个元素
print(item)
except StopIteration: # 捕获终止信号，结束循环
break
这个过程清晰地揭示了协议的分工：
iter() 触发 __iter__ 方法，返回一个迭代器对象。next() 触发迭代器对象的 __next__ 方法，逐个取出元素。- 当元素耗尽时，
__next__ 抛出 StopIteration 异常，循环终止。
在整个过程中，__iter__ 是迭代的入口，而 __next__ 负责推进。
二、协议触发的必要条件
迭代协议并非随时随地都会生效，它的触发需要满足两个条件。
1. 语法语境触发
解释器仅在需要“顺序取值”的特定语法中才会启动协议判定流程，包括：
for x in obj- 各种推导式（列表、集合、字典）和生成器表达式
tuple(obj)、list(obj) 等基于迭代的构造*obj 解包语法（不包括映射解包）
在这些语境中，解释器的目标是建立一条可持续取值的执行路径，而非简单地调用一个函数。
2. 类型层判定
协议判定发生在类型层面。解释器检查的是“对象的类型是否提供了协议方法”，而非实例的字典里是否有某个属性。这种分派通常基于类型槽位实现。
因此，即使你动态地为实例添加一个 __iter__ 方法，也无法让它变得可迭代：
class A:
pass
a = A()
a.__iter__ = lambda: iter([1, 2, 3])
for x in a: # TypeError: ‘A’ object is not iterable
...
因为解释器检查的是类 A 的 __iter__，而非实例 a 的属性。
三、迭代协议的两条解释路径
当解释器进入迭代语境时，它并非只有一条路可走，而是有明确的优先级规则。
1. 现代首选路径：__iter__ -> __next__
这是当前Python主要采用的路径，优先级最高。
- 检查
__iter__：解释器首先检查对象类型是否实现了 __iter__ 方法。
- 获取迭代器：若有，则调用
iter(obj)（即 type(obj).__iter__(obj)）来获取一个独立的迭代器对象。
- 驱动迭代器：在循环中反复调用
next(iterator)（即 type(iterator).__next__(iterator)）来取值。
- 终止迭代：当
__next__ 抛出 StopIteration 异常时，解释器捕获它并结束循环。
示例：一个自定义的可迭代计数器
class Count:
def __init__(self, n):
self.n = n
def __iter__(self):
self.i = 0 # 初始化迭代状态
return self # 返回自身作为迭代器
def __next__(self):
if self.i >= self.n:
raise StopIteration
value = self.i
self.i += 1
return value
for x in Count(3):
print(x, end=" ") # 输出: 0 1 2
说明：
Count(3) 的实例在 for 语境中扮演“可迭代对象”的角色。for 触发协议，调用 __iter__ 获得迭代器（此处是self）。- 随后反复调用该迭代器的
__next__ 方法获取值。
2. 兼容路径：__getitem__ 的序列回退
如果对象的类型没有实现 __iter__，解释器会进入一条兼容性路径。
- 检查
__getitem__：检查类型是否实现了 __getitem__ 方法。
- 模拟序列访问：解释器会从索引
0 开始，尝试 obj[0], obj[1], obj[2]... 直到捕获 IndexError（视为序列结束）。
示例：
class Seq:
def __init__(self):
self.data = [10, 20, 30]
def __getitem__(self, index):
return self.data[index]
for x in Seq():
print(x, end=" ") # 输出: 10 20 30
说明：Seq 类没有 __iter__，但其 __getitem__ 允许解释器通过索引模拟迭代过程。这条路径是为了兼容更早期的Python代码或某些特殊的序列类。
四、生成器对象与迭代协议
从协议视角看，生成器对象是迭代器的完美范例。它天然满足迭代器协议的所有条件：
- 实现了
__next__ 方法以产出值。
- 实现了
__iter__ 方法且返回自身。
- 通过抛出
StopIteration 来终止迭代。
def gen():
yield 1
yield 2
g = gen()
print(iter(g) is g) # True: __iter__ 返回自身
print(next(g)) # 1: __next__ 工作
print(next(g)) # 2
# print(next(g)) # 抛出 StopIteration
因此，生成器既是可迭代对象，也是迭代器对象。for循环能驱动生成器，本质上正是因为生成器遵循了迭代协议。
g = gen()
# for循环内部只会调用 __iter__ 和 __next__
for x in g:
print(x) # 1 2
五、抽象基类与类型检查
Python 的 collections.abc 模块提供了与迭代协议相关的抽象基类（ABC），用于类型检查和标注。
Iterable：要求实现 __iter__() 方法的对象。Iterator：要求同时实现 __iter__() 和 __next__() 方法的对象，并且 __iter__() 应返回自身。
from collections.abc import Iterable, Iterator
lst = [1, 2, 3]
it = iter(lst)
print(isinstance(lst, Iterable)) # True，列表是可迭代对象
print(isinstance(lst, Iterator)) # False，列表本身不是迭代器
print(isinstance(it, Iterator)) # True，iter(lst)返回的是迭代器
这清晰地划分了角色：可迭代对象（如列表）是数据的容器，而迭代器是负责遍历的“光标”或“状态机”。
六、典型应用场景
迭代协议渗透在Python的方方面面：
for循环与推导式：最直接的语法糖应用。- 内置容器类型：
list, dict, set, tuple 都实现了 __iter__。
- 文件对象：
for line in open(‘file.txt’): 实现了惰性逐行读取。
- 生成器与惰性计算：用于处理大数据流或无限序列。
- 自定义数据流/状态机：例如实现一个网络数据包解析器或一个复杂的算法状态机（如分页遍历、二分查找）。
这些场景的共同点是：对象本身并不“知道”如何循环，而是在特定的语法语境中，被解释器依据迭代协议解释为元素的来源。
小结
总结一下，迭代协议并非对象模型中的某个实体接口，而是由Python解释器维护的一套语义分派规则。它明确规定了在需要顺序取值的语法语境下，解释器应如何检查类型、选择路径（__iter__优先，__getitem__回退）以及管理迭代生命周期。
一个对象能否用在for循环中，不取决于它是否有“可迭代”的标签，而是取决于解释器在运行时，能否根据其类型结构成功走通迭代协议所定义的某条路径。理解这一点，就从“用法”层面深入到了“机制”层面，这也是在云栈社区深入讨论Python核心概念的意义所在。
发表于 8 小时前
|
查看: 2|
回复: 0
