企业官网建设流程全解析

你每天都在写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, 20

count配合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 Wed

cycle可以无限重复一个序列，做轮询任务、负载均衡、交替任务分配时非常好用。

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, key=lambda x: x["dept"]): print(dept, list(group))

这里有个经典坑：groupby只会把连续相同的元素分到一组，如果数据是A, B, A这样的顺序，两个 A 会被分成两组。所以用之前必须先排序。

4.2 内置函数搭配迭代器的经典组合

不只是 itertools，Python 内置的几个函数也是迭代器的好搭档。

enumerate 拿索引：

for index, value in enumerate(["a", "b", "c"], start=1): print(index, value) # 1 a / 2 b / 3 c

zip 并行遍历：

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_line=0): 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", encoding="utf-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_line=1000) for line in reader: if "ERROR" in line: print(line)

这个迭代器每次next()只从磁盘读一行，内存占用和文件总行数完全无关。文件句柄在迭代结束时自动关闭，不需要手动管理。

5.2 更优雅的替代方案：生成器写法

虽然自定义迭代器类能直观展示迭代器协议，但在实际开发中，我更推荐用生成器实现同等功能。同样的文件逐行读取，生成器写法简洁得多：

def read_file_lines(file_path, start_line=0): with open(file_path, "r", encoding="utf-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_line=1000): 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_hidden=0): 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。

一个典型的错误示范是：在生成器函数内部自己捕获StopIteration：

def 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 常见问题速查表

我整理了一张速查表，方便你以后排查问题直接对照：

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, start=1)一步到位，代码更干净。

迭代器是 Python 里一个“小但极其重要”的知识点。它不只是一个语法特性，而是理解 Python 内存模型、惰性求值、数据流式处理的一把钥匙。大部分初学者接触 for 循环时，脑子里只有“遍历”这个模糊概念，等真正理解第一步是iter()、每一步是next()、结束靠StopIteration之后，很多代码行为都变得可预测了——比如为什么文件对象能直接遍历、为什么生成器能处理超大文件、为什么迭代器不能用len()、为什么有的循环只能跑一次。

从面试的角度讲，把“Python for 循环和 C 语言 for 循环的区别”这个问题答透——一个是基于迭代器协议的元素消费过程，一个是基于下标的自增循环——已经能证明你不是止步于表面 API 的开发者。从实际工程的角度讲，把生成器和 itertools 用熟，写数据处理脚本时的内存占用和代码优雅程度都会有质的提升。我个人是在被内存打爆几次之后，才真正把这些东西内化的。希望你不用踩同样的坑，也能把这些工具用得顺手。