Python迭代器与生成器：for循环底层机制与内存优化实战

你每天都在写for item in list:但你真的知道 for 循环在底层做了什么吗很多 Python 开发者用了几年的for却说不出迭代器和可迭代对象的区别更别提生成器为什么能省内存了。我刚开始学 Python 的时候也一样直到有一次写数据管道处理上千万行日志时内存直接爆掉才被迫把迭代器、生成器、懒加载这些东西彻底啃了一遍。那之后再看for循环视角完全不一样了。这篇博文就把迭代器这条线彻底讲透for 循环背后的执行机制、迭代器协议到底长什么样、生成器怎么做到几乎不占内存地遍历超大序列、以及我在实际项目中用迭代器踩过的坑和总结出来的经验。适合刚入门 Python、想深入理解语言机制的人也适合写数据处理和业务脚本时想优化性能的同学。看完你就能回答一个经典面试题“Python 的 for 循环和 C 语言的 for 循环本质区别是什么”1. 你天天写 for 循环但 for 循环到底在做什么1.1 一次性搞懂 for 循环的执行流程很多从 C、Java 转过来的朋友刚接触 Python 的for会有点不适应。在 C 语言里for循环本质是“初始化变量、判断条件、更新变量”的三段式操作你操作的是下标for (int i 0; i 10; i) { printf(%d\n, arr[i]); }Python 的for完全不是这个逻辑。它不管下标不关心容器有多大甚至不要求你拿到的是一个“容器”。它只做一件事反复向一个对象要“下一个”元素直到对方说“没有了”。看一个最基础的例子fruits [apple, banana, cherry] for fruit in fruits: print(fruit)这段代码在你的脑子里可能还停留在“遍历列表把每个元素赋值给 fruit”的层面。但真实执行过程是这样的fruits [apple, banana, cherry] # for 循环内部的真实流程 iterator iter(fruits) # 第1步调用 iter() 拿到迭代器对象 while True: try: fruit next(iterator) # 第2步反复调用 next() 取下一个元素 print(fruit) except StopIteration: # 第3步捕获 StopIteration 异常后退出 break这三步就是 Python 里所有for循环的统一底层逻辑。无论是遍历列表、元组、字典、集合还是文件对象、数据库游标全部走的是这条流程。没有例外。这里面的关键角色有三个可迭代对象Iterable、迭代器Iterator、StopIteration 异常。搞懂这三者的关系你就掌握了 Python 迭代机制的半壁江山。1.2 用生活例子理解迭代器的工作方式把迭代器想象成一个发牌员。你坐在牌桌前不需要提前知道整副牌有多少张、也不需要知道下一张是什么你只需要做一件事伸手要牌。发牌员每次给你一张直到牌发完了告诉你一句“没牌了”。这里有个容易被忽略的细节发牌员不需要把整副牌一次性摊在桌面上。他手里攥着牌一张一张发桌子上的空间始终只占一张牌的位置。如果这副牌有一百万张你也只需要一张一张看而不是把一百万张牌全部摆在桌上才能开始。Python 的迭代器就是这个发牌员。iter()是“让发牌员就位”next()是“给我下一张牌”StopIteration是“没牌了”的那句话。在 C 语言风格的循环里你更像是一个拿着清单的管理员必须提前知道这一批数据有多大、索引从几到几。但在 Python 的迭代模型里你完全不需要关心数据规模——这才有了后面要讲的“无限序列”和“惰性求值”这些玩法。2. 迭代器协议iter与next的契约2.1 可迭代对象不等于迭代器很多人栽在这里这两个概念是 Python 面试的高频考点也是实际写代码时最容易踩混的地方。可迭代对象Iterable实现了__iter__()方法的对象可以理解为“可以拿来创建迭代器的对象”。调用iter(obj)时会执行这个方法。列表、元组、字典、集合、字符串都是可迭代对象。迭代器Iterator同时实现了__iter__()和__next__()的对象。__iter__()返回自身__next__()每次返回下一个元素没有元素时抛出StopIteration。通俗点说可迭代对象是“可以提供发牌员的人”迭代器本身就是“发牌员”。每次调用iter()可迭代对象都会给你一个新的发牌员。这带来一个非常实用的特性同一个可迭代对象可以同时被多个 for 循环独立遍历互不干扰。看我说的区别numbers [1, 2, 3] # 列表是可迭代对象不是迭代器 print(hasattr(numbers, __iter__)) # True print(hasattr(numbers, __next__)) # False # 调用 iter() 之后得到迭代器 it iter(numbers) print(hasattr(it, __iter__)) # True print(hasattr(it, __next__)) # True # 迭代器消费元素 print(next(it)) # 1 print(next(it)) # 2 print(next(it)) # 3 print(next(it)) # StopIteration能区分这个你就能解释很多看起来“诡异”的现象。比如下面这个经典坑values [1, 2, 3] for v in values: print(v) # 1, 2, 3 # 再遍历一次完全正常 for v in values: print(v) # 1, 2, 3但是换成一个迭代器试试it iter([1, 2, 3]) for v in it: print(v) # 1, 2, 3 for v in it: print(v) # 啥也不输出迭代器已经被消费完了第二个循环什么都不打印不是因为it空了而是迭代器内部有一个“当前位置指针”已经移到了末尾不能再从头开始。这就是“迭代器是一次性消费品”的含义。后面第 6 章我会给出具体的应对方案。2.2iter()的隐藏用法哨兵值与自定义终止条件iter()函数大多数人只用过单参数形式也就是iter(obj)。但 Python 还提供了一个双参数版本签名是iter(callable, sentinel)意思是反复调用callable直到返回值等于sentinel时停止。这个用法在处理流式数据时非常有用。比如从一个二进制文件里反复读取固定长度的块直到文件结束with open(data.bin, rb) as f: for chunk in iter(lambda: f.read(8192), b): process(chunk) # 每次拿到 8192 字节读到空字节就停再比如逐行读取标准输入直到遇到空行for line in iter(input, ): print(你输入了:, line)这段代码会一直弹输入框你输入一个空字符串就结束。如果不了解双参数iter()你可能要写一个while True加break的结构。对比一下while True: line input() if line : break print(你输入了:, line)双参数iter()的写法更紧凑逻辑也更集中。它本质上把“反复调用 终止判断”两件事封装进了一次调用里。在处理日志流、传感器数据、分块读取大文件时这个小技巧能省不少事。3. 惰性求值与生成器不把数据一次性装进内存3.1 生成器是怎么做到“无限数据也不怕”的生成器Generator是迭代器最经典的实现方式基于yield关键字构建。一个函数里只要出现yield它就不再是普通函数而是生成器函数——调用它不会执行函数体而是返回一个生成器对象。看一个最简单的例子def count_up_to(n): i 1 while i n: yield i i 1 counter count_up_to(5) print(counter) # generator object count_up_to at 0x... for num in counter: print(num) # 1 2 3 4 5关键在于yield的行为它把当前函数的所有状态局部变量、指令位置冻结把值返回给调用方下次调用next()时从冻结的位置继续执行而不是从头开始。这就是“惰性求值”的核心——生成器不会一次性把所有元素算出来而是你要一个它算一个。对比一下内存占用情况。假设你要处理 1 亿个数字的平方和# 一次性生成整个列表 —— 内存爆炸 squares [i * i for i in range(100_000_000)] total sum(squares) # 用生成器 —— 内存占用几乎为常数 squares_gen (i * i for i in range(100_000_000)) # 注意是圆括号 total sum(squares_gen)第一种写法列表推导式会把 1 亿个平方值全部算好存在内存里按每个整数 28 字节算光列表就占大约 2.8GB再加上列表本身的指针开销机器很容易直接卡死。第二种写法生成器表达式每生成一个平方值sum立刻消费掉内存里永远只存在一个整数。这就是为什么我前面说处理千万行日志时把“先读进列表再处理”改成“用生成器逐行处理”后内存占用能下降几个数量级。3.2 yield 的执行顺序代码逐行走一遍新手最容易搞不懂的是生成器函数里yield前后的代码到底什么时候执行我自己当年也被这个绕晕过。用一个带打印的示例把执行顺序完整走一遍def my_generator(): print(生成器启动) yield 1 print(第一次被唤醒) yield 2 print(第二次被唤醒) yield 3 print(生成器结束) gen my_generator() print(创建生成器函数体尚未执行) print(next(gen)) print(---) print(next(gen)) print(---) print(next(gen)) print(---) print(next(gen))输出结果是创建生成器函数体尚未执行 生成器启动 1 --- 第一次被唤醒 2 --- 第二次被唤醒 3 --- 生成器结束 StopIteration看到没有print(生成器启动)是在第一次调用next(gen)时才执行的而不是创建生成器时。yield 1执行完把 1 返回给调用方函数就暂停在这里。下一次调用next(gen)从yield 1的下一行继续跑也就是先打印“第一次被唤醒”再执行yield 2以此类推。理解了这个执行顺序你就能明白生成器为什么天然适合做“流水线”。它不是一个把所有结果计算好的函数而是一个可以暂停、可以恢复、可以反复进入的计算过程。这种“挂起-恢复”的机制是协程、async/await 的基础也是 Python 里很多高性能库的核心实现方式。3.3 斐波那契数列生成器秒杀递归版本把生成器用到经典算法题里感受最直观。以斐波那契数列为例递归版本虽然写起来漂亮但算到第 30 项就会明显变慢算到第 40 项已经很吃力因为存在大量重复计算。def fib_recursive(n): if n 2: return n return fib_recursive(n - 1) fib_recursive(n - 2) # 算到第 35 项就开始卡生成器版本可以做到“无限长度的斐波那契数列”而且每一项都是即时计算、即时返回想算几个算几个def fibonacci(): a, b 0, 1 while True: yield a a, b b, a b fib fibonacci() for _ in range(10): print(next(fib)) # 0 1 1 2 3 5 8 13 21 34这个版本里while True是无限循环但每次只算一个数内存占用不受“计算了多少项”影响。你就算调用next(fib)一百万次内存增长也可以忽略不计。而换一种写法用列表累积def fib_list(n): result [0, 1] for _ in range(n - 2): result.append(result[-1] result[-2]) return result列表版本每次都要保存所有的中间结果当 n 很大时列表越积越长。虽然已经比递归高效但还是不如生成器省内存。所以生成器特别适合处理“序列本身很长但你只想逐个消费”的场景。4. itertools 与内置迭代工具把迭代器玩出花4.1 itertools 核心工具速查与实战Python 标准库里的itertools模块是迭代器操作的“瑞士军刀”。它提供的所有函数都返回迭代器天然惰性几乎不占额外内存。我这里挑几个工作中最常用的配上可直接复用的示例。count 无限计数器和 takewhile 截断from itertools import count, takewhile # 无限递增的整数序列从 10 开始步长 2 for num in takewhile(lambda x: x 20, count(10, 2)): print(num) # 10, 12, 14, 16, 18, 20count配合takewhile可以替代常见的while加break结构语义更清晰。islice 切片无限迭代器from itertools import islice # 先构造一个无限迭代器再取前 5 个 natural_numbers count(1) first_five list(islice(natural_numbers, 5)) print(first_five) # [1, 2, 3, 4, 5]普通列表可以直接切片lst[2:5]但迭代器不能。islice就是专门给迭代器做切片的工具。chain 串联多个迭代器from itertools import chain list_a [1, 2, 3] list_b [4, 5, 6] combined list(chain(list_a, list_b)) print(combined) # [1, 2, 3, 4, 5, 6]chain的好处是它不会把两个列表复制拼接成一个新列表而是逐个从各个迭代器里取数据。如果要合并几个大型数据源这个特性很关键。cycle 循环遍历from itertools import cycle weekdays [Mon, Tue, Wed, Thu, Fri] day_cycle cycle(weekdays) for _ in range(8): print(next(day_cycle)) # Mon Tue Wed Thu Fri Mon Tue Wedcycle可以无限重复一个序列做轮询任务、负载均衡、交替任务分配时非常好用。groupby 分组from itertools import groupby data [{name: Alice, dept: A}, {name: Bob, dept: A}, {name: Cathy, dept: B}] # 注意groupby 要求数据必须先按分组键排好序 for dept, group in groupby(data, keylambda x: x[dept]): print(dept, list(group))这里有个经典坑groupby只会把连续相同的元素分到一组如果数据是A, B, A这样的顺序两个 A 会被分成两组。所以用之前必须先排序。4.2 内置函数搭配迭代器的经典组合不只是 itertoolsPython 内置的几个函数也是迭代器的好搭档。enumerate 拿索引for index, value in enumerate([a, b, c], start1): print(index, value) # 1 a / 2 b / 3 czip 并行遍历names [Alice, Bob, Cathy] scores [90, 85, 88] for name, score in zip(names, scores): print(f{name}: {score})zip 也是惰性的可以拉链式并行消费多个可迭代对象。注意zip 按最短的那个对象长度截断。如果希望按最长的走缺失部分用默认值填充可以用itertools.zip_longest。map / filter 的函数式操作numbers [1, 2, 3, 4, 5] squared list(map(lambda x: x * x, numbers)) evens list(filter(lambda x: x % 2 0, numbers))map 和 filter 返回的都是迭代器。需要真正拿到元素时再用list()或 for 循环消费。在大数据处理时推荐把它做成链路result map(lambda x: x * 2, filter(lambda x: x % 2 0, range(1_000_000)))这样的写法不会在中间步骤生成完整列表整个处理过程只在最终迭代时逐个产生结果。5. 自定义迭代器从文件读取到树遍历5.1 一个实用案例按需逐行读取大文件前面讲的都是 Python 内置的迭代器。如果你想实现自己的迭代器只需要定义一个类实现__iter__和__next__两个方法。我实际项目中就碰到过一个场景从几十 GB 的日志文件里查找关键字如果用readlines()一次性读入内存直接崩。自定义迭代器可以很好地解决这个问题。class FileLineReader: 按行读取文件的迭代器支持从指定行开始。 def __init__(self, file_path, start_line0): self.file_path file_path self.start_line start_line self.current_line 0 def __iter__(self): # 每次迭代都返回一个新的迭代器保证可以多次遍历 return self def __next__(self): # 用内部状态控制整个迭代过程 if not hasattr(self, _handle): self._handle open(self.file_path, r, encodingutf-8) # 跳过前 start_line 行 for _ in range(self.start_line): next(self._handle, None) line self._handle.readline() if not line: # 读完了关闭文件并抛出 StopIteration self._handle.close() raise StopIteration return line.strip() # 使用 reader FileLineReader(huge_log.txt, start_line1000) for line in reader: if ERROR in line: print(line)这个迭代器每次next()只从磁盘读一行内存占用和文件总行数完全无关。文件句柄在迭代结束时自动关闭不需要手动管理。5.2 更优雅的替代方案生成器写法虽然自定义迭代器类能直观展示迭代器协议但在实际开发中我更推荐用生成器实现同等功能。同样的文件逐行读取生成器写法简洁得多def read_file_lines(file_path, start_line0): with open(file_path, r, encodingutf-8) as f: for _ in range(start_line): next(f, None) for line in f: yield line.strip() for line in read_file_lines(huge_log.txt, start_line1000): if ERROR in line: print(line)生成器的好处是代码结构接近普通函数逻辑更直观with语句自动管理文件关闭不需要手动维护内部状态变量。这也是 Python 社区的主流写法——能用生成器解决的问题尽量不写迭代器类。5.3 用迭代器实现树的深度优先遍历文件逐行读取还不能体现自定义迭代器的全部威力。我再写一个树的深度优先遍历这个场景更能看出迭代器“按需取用”的价值——你不需要先把整棵树拍平成列表可以遍历一点、处理一点。class TreeNode: def __init__(self, value): self.value value self.children [] def add_child(self, child): self.children.append(child) return self def depth_first_traverse(root): 深度优先遍历生成器先访问节点自身再访问子节点 yield root.value for child in root.children: yield from depth_first_traverse(child) # 构造一棵树 root TreeNode(root) a TreeNode(A) b TreeNode(B) c TreeNode(C) root.add_child(a).add_child(b).add_child(c) a.add_child(TreeNode(A1)) b.add_child(TreeNode(B1)).add_child(TreeNode(B2)) # 遍历 for node_value in depth_first_traverse(root): print(node_value) # root A A1 B B1 B2 C这里用了yield from语法它的作用是“把子生成器里的元素逐个 yield 出来”相当于嵌套遍历的语法糖。yield from generator写法上等同于for item in generator: yield item树的深度可能很深但每次迭代只保留当前路径上的帧不会有递归计算整棵树的额外开销。5.4 迭代器与深度循环模型的时间步概念如果你接触过循环神经网络或者训练过序列模型对“逐时间步消费数据”这个概念应该不陌生。RNN 处理文本时的逻辑其实和迭代器的思路如出一辙一个词一个词地读取序列每一步更新隐藏状态用上一步的输出作为下一步的输入。def simple_rnn_step(prev_hidden, input_word): 一个简化版的 RNN 时间步计算 # 真实项目中这里的 weight、bias 是模型训练出来的 return prev_hidden * 0.7 input_word def rnn_process(text_sequence, init_hidden0): hidden init_hidden for word_vector in text_sequence: # 迭代器逐项供给数据 hidden simple_rnn_step(hidden, word_vector) # 可以在这里把 hidden 收集起来也可以继续传下去 return hidden在这个简化模型里text_sequence完全可以是生成器——比如一个从数据库游标里逐条取出的文本向量流一个无限的数据增强管道或者一个分块读取的磁盘文件。迭代器的惰性求值天然契合这种“逐时间步处理序列”的模型结构不需要把整个序列全部加载到内存来一个处理一个处理完即丢弃。这个概念对理解 PyTorch / TensorFlow 里的DataLoader也很有帮助。DataLoader就是一个在大数据集上逐批次产出数据的迭代器内部大量运用了生成器、迭代器和惰性加载的思想。理解了 Python 迭代器再看这些深度学习框架的数据流水线会顺畅很多。6. 常见问题与排查经验6.1 “为什么 for 循环第二次就没数据了”——迭代器耗尽问题这是迭代器领域最经典的问题前面 2.1 节展示过一次。要彻底解决它先要分清你手里拿的是“可迭代对象”还是“迭代器”。如果你持有的是列表、元组这类可迭代对象每次 for 都会调用iter()生成新的迭代器所以可以反复遍历。如果你持有的是迭代器生成器、文件对象、zip/map 对象等它是有状态的遍历一次就到底了。遇到“第二次循环没数据”的情况按以下顺序排查# 场景一手里的变量到底是哪种类型 data [1, 2, 3] print(hasattr(data, __next__)) # False可迭代对象可以反复用 gen (x for x in range(3)) print(hasattr(gen, __next__)) # True迭代器用完即弃如果业务确实需要多次遍历同一个生成器产生的数据有两个方案。数据量小时可以提前转成列表data list(generate_sequence()) # 现在 data 可以随便遍历多少次数据量大、不能转列表时把生成器改成“可以重新创建的工厂函数”def generate_sequence(): yield from range(1000000) # 每次遍历都重新调用函数得到全新的生成器 for _ in range(3): for item in generate_sequence(): process(item)6.2 迭代过程中修改列表结果比你想的奇怪这是另一个高频陷阱。很多人在 for 循环里做删除操作结果发现列表变短了甚至跳过了元素。numbers [1, 2, 3, 4, 5] for num in numbers: if num % 2 0: numbers.remove(num) print(numbers) # 预期 [1, 3, 5]实际 [1, 3, 5]不一定换个数据就出错换个例子numbers [1, 2, 3, 4, 5, 6] for num in numbers: if num % 2 0: numbers.remove(num) print(numbers) # [1, 3, 5] # 好巧这次对了再换一组 numbers [1, 3, 2, 4, 6, 8] for num in numbers: if num % 2 0: numbers.remove(num) print(numbers) # [1, 3, 4, 8]出问题了为什么最后一个结果不对因为 for 循环内部的迭代器维护着一个“当前索引位置”。当你删除列表中的元素时列表整体左移但迭代器的索引不会回退于是跳过了下一个元素。这是迭代器和可变容器交互时的经典错误。正确的做法是要么创建一个新列表要么倒序遍历删除要么先收集要删的元素再统一处理。# 方案一列表推导式生成新列表 numbers [1, 2, 3, 4, 5, 6] numbers [num for num in numbers if num % 2 ! 0] print(numbers) # [1, 3, 5] # 方案二倒序遍历 numbers [1, 2, 3, 4, 5, 6] for num in reversed(numbers): if num % 2 0: numbers.remove(num) print(numbers) # [1, 3, 5]我自己更推荐方案一因为列表推导式语义清晰且不修改原列表避免各种隐蔽问题。6.3 StopIteration 处理不当变成 RuntimeError看这个代码gen (x for x in range(3)) print(next(gen)) # 0 print(next(gen)) # 1 print(next(gen)) # 2 print(next(gen)) # StopIteration如果你直接调用next()而没有捕获StopIteration程序会抛异常。更麻烦的情况是在生成器内部错误地处理了StopIteration导致外部循环提前退出或者变成 RuntimeError。一个典型的错误示范是在生成器函数内部自己捕获StopIterationdef broken_generator(): items [1, 2, 3] for i in items: yield i gen broken_generator() # 在 Python 3.7 中生成器内部如果错误捕获 StopIteration会变成 RuntimeError通常不建议在生成器内部捕获StopIteration。如果某个函数可能耗尽迭代器用next(it, default)提供默认值更安全gen (x for x in range(3)) print(next(gen, 默认值)) # 0 print(next(gen, 默认值)) # 1 print(next(gen, 默认值)) # 2 print(next(gen, 默认值)) # 默认值带默认值的next()不会抛异常适合处理可能为空的迭代器。6.4 常见问题速查表我整理了一张速查表方便你以后排查问题直接对照表现根本原因解决方案for 循环第二次没数据变量是迭代器已遍历到底数据量小转列表数据量大改成生成器工厂函数循环里删元素结果跳项列表修改导致迭代索引错位用列表推导式生成新列表或倒序遍历next() 调用直接崩溃迭代器耗尽未捕获 StopIteration用 next(it, default) 或 try/except内存占用过大用列表推导式把全量数据加载进内存改成生成器表达式或生成器函数groupby 分组结果“不对”相邻相同才归一组数据未排序先对分组键排序再 groupby同一个迭代器被多个 for 使用迭代器有状态只消费一次改用可迭代对象或每次重新创建6.5 几个平时不会写进文档的经验最后分享几个我自己踩过坑后总结出来的经验。经验一能用生成器就别写迭代器类。自定义迭代器类是理解协议的好方法但实际项目里生成器的表达能力足够覆盖绝大多数场景。生成器更短、更易维护、出错概率更低。只有当你要实现一个需要多处独立状态的复杂迭代逻辑比如同时管理多个游标时才考虑类。经验二文件对象本身就是一个迭代器。很多人写逐行读文件还在用for line in f.readlines()这会先把所有行读进内存然后遍历。正确的做法是直接for line in f:因为文件对象内部实现了按行读取的迭代机制一次只读一行。# 低效先把所有行读入内存 with open(big_file.log) as f: for line in f.readlines(): process(line) # 高效逐行惰性读取 with open(big_file.log) as f: for line in f: process(line)经验三迭代器和函数式编程的组合很强大。map、filter、itertools和生成器可以组成一条“惰性数据管道”整个管道直到最后消费时才真正计算。这种写法的性能优势在大数据量场景下非常明显。我写数据处理代码时习惯先把整个管道组织出来最后再一次性消费改动起来非常灵活。经验四enumerate的start参数经常被忽略。很多人遍历列表时想从 1 开始计数只会写index 1。实际上enumerate(items, start1)一步到位代码更干净。迭代器是 Python 里一个“小但极其重要”的知识点。它不只是一个语法特性而是理解 Python 内存模型、惰性求值、数据流式处理的一把钥匙。大部分初学者接触 for 循环时脑子里只有“遍历”这个模糊概念等真正理解第一步是iter()、每一步是next()、结束靠StopIteration之后很多代码行为都变得可预测了——比如为什么文件对象能直接遍历、为什么生成器能处理超大文件、为什么迭代器不能用len()、为什么有的循环只能跑一次。从面试的角度讲把“Python for 循环和 C 语言 for 循环的区别”这个问题答透——一个是基于迭代器协议的元素消费过程一个是基于下标的自增循环——已经能证明你不是止步于表面 API 的开发者。从实际工程的角度讲把生成器和 itertools 用熟写数据处理脚本时的内存占用和代码优雅程度都会有质的提升。我个人是在被内存打爆几次之后才真正把这些东西内化的。希望你不用踩同样的坑也能把这些工具用得顺手。