写Python写过一阵子的人,十有八九都有过这样的念头:for循环到底是怎么把列表里的元素一个个取出来的?为什么字典也能for,集合也能for,文件对象也能for,但整数就不行?这个疑问背后,藏着的正是Python迭代器(Iterator)这套设计。我最早接触Python的时候,以为for循环就是像C语言那样按下标访问数组,后来才发现完全不是那么回事——Python的for循环本质上是一个不断向迭代器要下一个值的过程。这篇文章就把这层窗户纸捅破,从迭代器协议讲起,到手写迭代器类、生成器、itertools工具,再到动态修改容器时的各种坑,一次说清楚。适合刚学完Python基础语法、开始接触进阶特性的读者,也适合写了不少代码但一直没系统理解迭代机制的开发者。1. for循环到底在幕后做了什么1.1 发牌员与牌堆:先厘清两个概念在拆解for循环之前,得先分清楚两个极其容易混淆的概念:可迭代对象(Iterable)和迭代器(Iterator)。打个发牌的比方。牌堆是那副扑克牌,你可以反复从里面抽牌,也可以把它交给任意多个发牌员;而发牌员是那个记住自己发到哪一张的角色,他手里有一个进度状态,每一次发牌都会把进度往后推一格。这里的牌堆就是可迭代对象,发牌员就是迭代器。放到Python里:可迭代对象是可以被for循环遍历的东西,比如list、tuple、dict、set、str。它们的特点是实现了__iter__方法。迭代器是负责具体遍历流程的对象,它实现了__iter__和__next__两个方法,每次调用next()都会返回下一个值,直到没有值可返回时抛出StopIteration异常。判断一个对象是不是可迭代对象,最直接的方式是调用iter()函数,Python内部会尝试调用它的__iter__方法,拿不到就抛TypeError。比如iter(42)会直接报错,因为整数不是可迭代对象。1.2 for循环翻译成while循环之后把for循环展开成while循环,一切就透明了。假设有下面这段代码:lst [Python, 迭代器, for循环] for item in lst: print(item)Python解释器实际做的事情,翻译成while循环大概是这样:# 1. 获取迭代器 it iter(lst) # 2. 循环取下一个值 while True: try: item next(it) except StopIteration: # 迭代器说没有更多元素了,结束循环 break print(item)也就是说,for循环根本不需要知道lst是列表还是字典还是别的什么,它只认两件事:能不能拿到迭代器,以及迭代器能不能持续产出值。这套约定就是Python的迭代器协议(Iterator Protocol)。明白了这一点,很多现象就解释得通了:for循环遍历字典的时候,拿到的是字典的键,因为字典的迭代器默认产出键;for循环遍历文件对象的时候,拿到的是一行行字符串;一个对象只要正确实现了__iter__,哪怕它不是传统意义上的容器,也能放进for循环里跑。这个协议优先于类型的设计,贯穿了Python的很多机制,后面手写迭代器类的时候会看得更清楚。2. 迭代器协议的两个核心方法:__iter__与__next__的分工2.1 __iter__负责什么,__next__负责什么迭代器协议只有两个方法,职责划分非常明确:__iter__(self):返回一个迭代器对象。为什么可迭代对象和迭代器都要实现这个方法?因为for循环第一步永远调iter(),它不关心你到底是容器还是迭代器,只关心你能不能交出迭代器。对容器来说,__iter__返回一个新迭代器;对迭代器来说,__iter__通常返回自身。__next__(self):返回下一个可供使用的值。如果已经没有值了,必须抛出StopIteration异常,for循环靠捕获这个异常来正常终止。随手验证一下列表和它迭代器的差异:lst [1, 2, 3] print(hasattr(lst, __iter__)) # True print(hasattr(lst, __next__)) # False,列表本身不是迭代器 it iter(lst) print(hasattr(it, __iter__)) # True print(hasattr(it, __next__)) # True,迭代器两个方法都有这段代码能解释很多人的困惑:为什么next(lst)会报错?因为列表只是可迭代对象,不是迭代器,得先iter(lst)拿到迭代器才能取元素。2.2 为什么必须拆成两个方法而不是一个初学者最容易问的问题就是:既然迭代器一次只能产出一个值,为什么不干脆让每个对象自己实现一个__next__就完事,非要__iter__再包一层?答案是:可迭代对象需要支持多次独立遍历。举个例子,同一个列表可以被两个for循环同时遍历,互不影响:lst [1, 2, 3] for a in lst: for b in lst: print(a, b)如果列表本身充当迭代器,它就只有一个进度状态,第二个循环遍历的时候进度早被第一个循环消耗光了。所以列表只能作为牌堆,每次iter(lst)都会生成一个全新的发牌员,各自记住各自的位置。反过来,文件对象就有点特殊,它自己就是一个迭代器,所以遍历完一次之后再遍历,读到的是空内容。这是因为文件对象本身就有当前读取位置这个状态,天然适合做迭代器,而不是每次重新生成。这个差异是理解迭代器模式的核心:容器负责提供多个迭代器,迭代器负责维护单次遍历的进度。3. 手写迭代器:从模拟range到容器与迭代器分离3.1 用类实现一个简化版range纸上谈兵不如直接写代码。先来实现一个简化版的range,它既能接受range(start, stop, step)的完整参数,也能接受range(stop)的单参数形式。这个类完美展示了迭代器的工作机制:class MyRange: def __init__(self, start, stopNone, step1): if stop is None: # 只传了一个参数,当成 stop start, stop 0, start self.current start self.stop stop self.step step if self.step 0: raise ValueError(step 不能为 0) def __iter__(self): # 迭代器一般直接返回自身 return self def __next__(self): # 先判断边界,再返回当前值并推进 if self.step 0 and self.current self.stop: raise StopIteration if self.step 0 and self.current self.stop: raise StopIteration value self.current self.current self.step return value测试一下:for i in MyRange(1, 10, 2): print(i) # 1 3 5 7 9 print(list(MyRange(5))) # [0, 1, 2, 3, 4] print(list(MyRange(10, 0, -2))) # [10, 8, 6, 4, 2]这个类的核心在于__next__里的边界判断。注意step正负不同,终止条件也不一样,否则倒序迭代会死循环。这里有一个很关键的点:__iter__返回self,表示这个对象自己就是自己的迭代器。这种方式适合对象当前状态即遍历进度的场景,比如MyRange的运行期进度就存在self.current里。但它也有局限,后面马上说。3.2 容器返回独立迭代器的设计模式再来模拟一个更典型的场景:一个书架类,里面放着多本书,每次遍历书架都应该从第一本开始,而且两个for循环可以同时遍历互不打扰。class BookShelf: def __init__(self, books): self.books books def __iter__(self): return BookShelfIterator(self) class BookShelfIterator: def __init__(self, shelf): self.shelf shelf self.index 0 def __iter__(self): return self def __next__(self): if self.index len(self.shelf.books): raise StopIteration book self.shelf.books[self.index] self.index 1 return book这时候BookShelf是可迭代对象,BookShelfIterator才是迭代器。每次iter(shelf)都会创建一个全新的BookShelfIterator,互不干扰:shelf BookShelf([三体, 球状闪电, 超新星纪元]) it1 iter(shelf) it2 iter(shelf) print(next(it1)) # 三体 print(next(it1)) # 球状闪电 print(next(it2)) # 三体, it2 完全不受 it1 影响这种容器与迭代器分离的模式,是最标准的迭代器模式写法,Java里也长这样。Python里很多内置类型就是这个套路,虽然平时感觉不到,但理解之后,再看for循环就完全不是黑盒了。4. 生成器:更省事的迭代器写法4.1 yield关键字如何改变函数手写类实现迭代器虽然严谨,但日常开发里很少真的这么干,因为Python提供了更简洁的方案——生成器(Generator)。生成器是一种用函数语法写迭代器的方式,核心只有一个关键字:yield。凡是函数体里出现了yield,这个函数就不再是普通函数,而是一个生成器函数。调用它不会立刻执行函数体,而是返回一个生成器对象,这个生成器对象本身就是迭代器。def fibonacci(n): a, b 0, 1 count 0 while count n: yield a a, b b, a b count 1 g fibonacci(5) print(next(g)) # 0 print(next(g)) # 1 print(next(g)) # 1每次执行到yield a,函数就把a的值交出去,然后挂起。下一次next(g)再从挂起的地方继续走。这个挂起-恢复的机制,就是生成器和普通函数最大的区别。对比一下手写的MyRange,生成器版只要几行:def my_range(start, stopNone, step1): if stop is None: start, stop 0, start if step 0: raise ValueError(step 不能为 0) while (step 0 and start stop) or (step 0 and start stop): yield start start step4.2 类实现与生成器实现,选哪个生成器在代码量上的优势是碾压级的。文件逐行读取这种场景最典型:# 类实现版本 class FileLineIterator: def __init__(self, filepath): self.file open(filepath, encodingutf-8) def __iter__(self): return self def __next__(self): line self.file.readline() if not line: self.file.close() raise StopIteration return line.rstrip(\n) # 生成器版本 def file_lines(filepath): with open(filepath, encodingutf-8) as f: for line in f: yield line.rstrip(\n)生成器版本的with语句能自动管理文件关闭,类的版本反而要自己记得关,这就是为什么实际项目里几乎都用生成器。生成器还有一个常被忽略的好处:惰性求值。yield是一次产出一个,不会一次性把结果全部放进内存。比如遍历一个几GB的日志文件,生成器版本的内存占用几乎恒定。而如果你写成[line.strip() for line in f],那整个文件都会进内存,直接爆掉。另外要记住一个特征:生成器是不可重置的。它是一次性消耗品,遍历完就没了:g (x * x for x in range(5)) print(list(g)) # [0, 1, 4, 9, 16] print(list(g)) # [],第二次已经是空的了所以如果需要反复遍历,老老实实走集合或者重新调一次生成器函数。5. iter()还有哪些隐藏用法:哨兵模式与安全取值5.1 iter(obj)与iter(obj, sentinel)平时使用iter()都是单参数形式,拿一个可迭代对象去获取迭代器。但这个内置函数还有一个被严重低估的第二参数——哨兵值,签名是iter(callable, sentinel)。这种形式适合不断调用某个函数,直到返回某个特定值为止的场景。最经典的就是按块读取文件:from functools import partial with open(large_data.bin, rb) as f: for block in iter(partial(f.read, 4096), b): # 处理每一个 4KB 的数据块 print(len(block))f.read(4096)每次读4KB,当文件读完了返回空字节串b,iter看到返回值和哨兵相等,立刻停止,不会把空串交出来。这个写法比手写while True加break干净太多。5.2 next与默认值配合,拒绝裸奔的StopIteration写代码的时候,经常需要取迭代器的下一个元素,没有就返回默认值。这时候next(it, default)比手动捕获异常利落得多:it iter([1, 2, 3]) print(next(it, None)) # 1 print(next(it, None)) # 2 print(next(it, None)) # 3 print(next(it, None)) # None,迭代完之后不再抛异常在处理字典的values()、keys()迭代器时,这个技巧能省掉大量try/except。比如从一组字典中取第一个值,取不到就返回一个默认配置:def get_first_value(mapping): it iter(mapping.values()) return next(it, 默认值) print(get_first_value({name: Python})) # Python print(get_first_value({})) # 默认值iter和next这一对搭档,一个是入口,一个是出口,配合哨兵模式,很多循环就能写得既短又不容易出错。6. itertools:官方迭代器工具箱中的高频利器6.1 无限与拼接类工具Python标准库的itertools模块,专门用来操作迭代器。有些工具生成的序列看起来是无限的,这类工具必须配合islice或for循环的break一起用,否则程序就停不下来。count(start, step)生成无限递增的整数,配合islice限制数量是常见用法:from itertools import count, islice # 生成 5 个从 10 开始、步长为 3 的数 for n in islice(count(10, 3), 5): print(n) # 10 13 16 19 22cycle(iterable)无限循环遍历一个可迭代对象,很适合做状态轮换:from itertools import cycle lights cycle([红灯, 绿灯, 黄灯]) for _ in range(6): print(next(lights)) # 红灯 绿灯 黄灯 红灯 绿灯 黄灯chain(*iterables)把多个可迭代对象首尾拼接起来,省得手动写双重循环:from itertools import chain for item in chain([1, 2, 3], [a, b], (True, False)): print(item)这类工具返回的都是迭代器而不是列表,数据量大的时候内存优势特别明显。唯一的注意点是它们都是懒加载的,不能反复遍历,需要多遍就用list()固化下来。6.2 分组与组合类工具groupby按相邻相同键分组,用之前必须排序,否则相同的键被分隔到不同位置就分不出来了:from itertools import groupby data [(apple, 3), (apple, 2), (banana, 5), (banana, 1)] data.sort(keylambda x: x[0]) for key, group in groupby(data, keylambda x: x[0]): print(key, list(group))tee(iterable, n)可以把一个迭代器复制成n个独立迭代器,代价是内部会缓存数据:from itertools import tee it iter([1, 2, 3, 4]) it1, it2 tee(it, 2) print(list(it1)) # [1, 2, 3, 4] print(list(it2)) # [1, 2, 3, 4]还有一组组合数学工具:product(笛卡尔积)、permutations(排列)、combinations(组合)。比如想对比三组实验参数的所有组合:from itertools import product for params in product([0, 1], [low, high]): print(params) # (0, low) (0, high) (1, low) (1, high)itertools里的工具都很小,但组合起来能写出非常优雅的管道式迭代代码。建议初学者把官方文档里itertools那一页通读一遍,里面每个函数都是一个现成的思路。7. 迭代过程中的经典坑:动态修改容器的正确姿势7.1 遍历字典时修改字典:为什么会RuntimeError迭代字典的时候直接新增或删除键值对,大概率碰到这个错误:RuntimeError: dictionary changed size during iteration。d {a: 1, b: 2, c: 3} for k in d: if k b: del d[k] # RuntimeError原因不复杂:字典迭代器内部维护了一个版本号,每次增删键值对都会让版本号1,迭代器发现版本对不上,立刻拒绝继续工作。这是Python故意做的保护,防止你在迭代过程中产生无法预料的错乱。安全的做法是先复制出键的列表,遍历列表再去改字典:d {a: 1, b: 2, c: 3} for k in list(d): if k b: del d[k] print(d) # {a: 1, c: 3}更Pythonic的写法是用字典推导式重建:d {k: v for k, v in d.items() if k ! b}两种方式都行,核心思想是:不要在迭代的路上改路本身,先拍一张快照再动刀。7.2 遍历列表时删除元素:索引错位的陷阱字典会直接报错,列表却不会报错,更阴险——它悄悄给出错误结果。看这个例子:lst [2, 4, 3, 5] for item in lst: if item % 2 0: lst.remove(item) print(lst) # [4, 3, 5]期望是把所有偶数删掉,得到[3, 5],结果4留在里面了。原因是列表迭代器是按下标递增的,remove(2)之后,4的下标从1变成了0,迭代器继续从下标1开始,4就被跳过了。正确做法之一是列表推导式:lst [x for x in lst if x % 2 ! 0] print(lst) # [3, 5]如果逻辑复杂,也可以先收集再统一处理:lst [2, 4, 3, 5] to_remove [] for item in lst: if item % 2 0: to_remove.append(item) for item in to_remove: lst.remove(item)或者干脆用while循环手动控制下标,删了就把下标减回去。不过日常写代码,列表推导式永远是最优先的选择。这类坑提醒我一件事:迭代器协议本身没有问题,问题出在使用者试图修改正在被迭代的容器。理解迭代器只负责状态推进,不负责容器一致性之后,遇到这类问题就再也不慌了。最后留个小练习:不用zip,自己实现一个简化版zip函数,让它能同时遍历两个列表并返回元组。做完之后你会发现,迭代器协议已经刻进骨头里了。