Python：可迭代对象（对象语义角色）

在 Python 的对象模型中，“可迭代对象”（iterable）并不是一种独立的对象类型，也不是某种必须通过语法声明才能获得的特殊能力。所谓可迭代对象，本质上是在特定迭代语义语境下，能够为解释器提供迭代协议入口的一类对象语义角色。

理解可迭代对象，有助于理解 Python 数据流在协议层面的组织方式，因为几乎所有“逐项访问”的操作都以它为入口。

一、什么是可迭代对象

从对象模型角度看，可迭代对象（iterable）不是一种固定的对象类型，而是对象在迭代协议中的一种角色定位。

“可迭代”并不是对象内部固有的属性标签，而是解释器在特定语境下基于其结构作出的协议性判定结果。

在 Python 中，只要对象的类型定义了迭代入口（通常表现为实现 __iter__ 方法，或在兼容路径下通过 __getitem__ 提供顺序访问），且该入口返回一个，该对象即可在迭代协议中承担可迭代对象的语义角色。

当解释器需要从某个对象开始一次遍历时，其行为可概括为：

1、确认当前语境要求“顺序取值”（如 for、推导式、list() 等）。

2、解释器调用 iter(obj)，而 iter() 再触发对象的迭代入口。

因为语义上：

for x in obj:

等价于：

it = iter(obj)

例如：

（1）解释器确定 for 语句有“顺序取值”要求，触发迭代协议。

（2）解释器通过 iter(it) 触发其迭代入口（通常表现为调用其类型定义的 __iter__ 槽位）；若该入口不存在，则进入 __getitem__ 回退路径。

（3）此时返回一个迭代器对象，推动 for 循环的“逐个取值”。

由上例可以清楚地知道，可迭代对象只是担当迭代协议的入口角色，它并不负责保存遍历状态，也不直接参与“逐个取值”的推进过程。

说明：在分离式设计中，遍历状态由迭代器对象承担；在合一式设计（如生成器）中，两者合并。

真正执行遍历、保存当前位置、决定何时终止的，是由 __iter__ 返回的迭代器对象（实现了 __next__ 方法）。

二、可迭代对象与迭代器对象的区别

在迭代协议中，可迭代对象与迭代器对象承担着截然不同且互补的职责。

1、接口区别

• 可迭代对象：实现了 __iter__ 方法，调用它应返回一个迭代器对象。

• 迭代器对象：同时实现了 __iter__ 和 __next__，可以被 next() 调用逐步取值。

2、行为差异

在典型的数据容器型“可迭代对象”中，可以被多次遍历：

    print(x, end=' ') 

而迭代器对象只能使用一次：

原因是，一个迭代器对象内部保存了当前进度，每次 next() 调用都会推进位置，直到没有元素后抛出 StopIteration。所以，当对同一个迭代器对象再次实施 for 循环时，就不再可推进。

要注意的是，如果一个类的 __iter__ 返回的是自身（即本身也是迭代器），那么它虽然是“可迭代对象”，但不能多次遍历。

比如：

list(g)  # []

3、设计目的

可以这样说，可迭代对象是“能被遍历的容器”，迭代器对象则是“执行遍历的引擎”。

也就是说，可迭代对象能生成迭代器，迭代器对象负责逐个产出数据。

这一分工并非偶然设计，而是 Python 对“数据存在”与“过程推进”进行刻意解耦的结果。

因此，同一个数据容器可以创建多个独立的迭代器对象，互不干扰。

三、可迭代语义在类型体系中的体现

1、多数内置容器是可迭代对象

Python 中的大多数内置容器类型，都采用了上述设计模式：

• 所有序列类型：list、tuple、str、range

• 所有集合类型：set、frozenset

• 映射类型：dict（迭代时返回键）

• 文件对象

• 生成器对象

• 以及自定义实现了 __iter__() 方法的类

容器对象本身通常不是迭代器对象，其类型只实现 __iter__，而由 __iter__ 返回的迭代器类型实现 __next__。

以列表为例：

it1 is it2   # False

（1）列表 lst 是可迭代对象。

（2）内置函数 基于可迭代对象创建并返回一个迭代器对象（实现了 __next__ 方法）。

（3）it1 与 it2 是两个不同的迭代器对象，它们共享同一个数据源，但维护各自独立的遍历状态。

正是这种设计，使得列表等容器对象天然具备“可反复遍历”的语义特征。

示例：for 如何从 lst 取得迭代器

    print(x)

说明（分步骤）：

（1）lst 是可迭代对象：因为 type(lst)（即 list）实现了 __iter__，因此它能在迭代语境中作为协议入口被使用。

（2）当 for 语法触发迭代语义时，解释器会调用 iter(lst)（其内部通过 __iter__ 槽位获取迭代器对象）。

（3）之所以能“逐个取值”，是因为这个迭代器对象的类型实现了 __next__。

（4）因此，for 循环中每次推进时，实际调用的是迭代器对象的 __next__（即 next(it)）。

（5）当迭代器判断元素耗尽时，它会抛出 StopIteration，for 据此结束循环。

lst 提供的是迭代入口（通过 __iter__ 创建/返回新的迭代器对象），真正具备 __next__、承担“逐个产出”职责的是那个新生成的迭代器对象。

2、生成器也是可迭代对象

生成器对象在创建时即同时实现了 __iter__ 与 __next__，因此既是可迭代对象，也是迭代器对象。

    print(x)    # 继续输出 1, 4, 9, 16

生成器让我们无需显式编写迭代器类，即可创建同时具备“可迭代”与“迭代器”双重语义角色的对象。

3、很多内置函数返回可迭代对象

由于所有可迭代对象都能通过 iter() 获得迭代器对象，它们可以像“管道”一样组合使用，实现惰性计算。

print(list(mapped))                            # [0, 4, 16, 36, 64] 转为列表时才触发计算

这里的 range、filter、map 返回的都是“可迭代对象”，它们形成了一条惰性计算管道。这些对象本质上是“迭代器适配器”，其计算逻辑嵌入在 __next__ 的执行路径中。只有当 list() 消耗数据时，迭代过程才真正发生。

四、旧式可迭代对象

若对象未提供迭代入口（__iter__），但实现了 __getitem__() 且支持从索引 0 开始连续取值，也能被视为“旧式可迭代对象”。

在 Python 2.2 之前，尚未引入完整的迭代协议；解释器通过从索引 0 开始调用 __getitem__ 来模拟遍历。

为了保持兼容性，Python 3 仍保留了这条“回退路径”。

输出：

a b c

解释器会在检测到没有 __iter__() 时，自动尝试使用这种方式进行遍历。

这正是为什么一些“看似没定义迭代”的类仍能在 Python 3 中被 for 循环使用的原因。

五、从对象模型角度的统一理解

综合以上分析，可以从对象模型角度给出一个统一判断。

1、可迭代对象

在迭代语义语境下，能够为解释器提供迭代器对象的对象实体，通常承担数据容器语义。

2、是否可重复遍历

取决于 __iter__ 是否返回新的迭代器对象。

3、遍历状态归属

不属于可迭代对象本身，而归属于每一次生成的迭代器对象。

这一设计使得 Python 在保持语义清晰的同时，也获得了极高的灵活性。

小结

可迭代对象并不是一种特殊类型，而是对象在迭代语义语境下所承担的协议角色。当解释器触发迭代协议时，它通过 iter(obj) 获取一个迭代器对象（其内部通过 __iter__ 槽位完成调度），并将遍历状态的维护与推进职责交由该迭代器完成。这一设计实现了“数据存在”与“过程推进”的语义解耦，使同一数据源能够生成多个独立的遍历过程，从而构成 Python 迭代模型的核心结构。

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