别再只会用 for 循环了！深入理解 Python 迭代器 (核心原理 + 实战)

摘要：你是否以为 for i in list 就是 Python 遍历的全部？其实背后隐藏着一套强大的“迭代器协议”。今天，我们不仅要看懂它，还要学会用它写出更省内存、更优雅的代码。

在日常写代码时，for 循环可以说是我们最亲密的伙伴了。无论是遍历列表、读取文件，还是处理数据，for 循环无处不在。

但是，你有没有想过：

  • 为什么列表可以用 for 循环，整数却不行？
  • 为什么处理大文件时，直接 read() 会爆内存，而逐行读取却没事？
  • yield 关键字到底施展了什么魔法？

如果你对这些问题的答案模棱两可，那么这篇文章就是为你准备的。今天，我们要彻底搞懂 Python 迭代器（Iterator）。

01 可迭代对象 vs 迭代器

很多初学者容易混淆这两个概念。我们先来做个区分。

在 Python 中，有两个重要的抽象基类：Iterable（可迭代对象）和 Iterator（迭代器）。

📦 可迭代对象 (Iterable)

定义：实现了 __iter__() 方法的对象。
特点：它可以被迭代，但它本身不一定能记住迭代的位置。
常见例子：list, tuple, dict, set, str。

🏃 迭代器 (Iterator)

定义：同时实现了 __iter__() 和 __next__() 方法的对象。
特点：它是一个带状态的对象，它记得当前读到哪里了。调用 next() 会返回下一个值，直到耗尽。
核心：惰性计算（用多少取多少，不一次性加载到内存）。

🔍 代码验证

我们可以用 collections.abc 来检测：

1
2
3
4
5
6
7
8
from collections.abc import Iterable, Iterator

lst = [1, 2, 3]
print(isinstance(lst, Iterable))  # True
print(isinstance(lst, Iterator))  # False (列表不是迭代器！)

it = iter(lst) # 通过 iter() 获取迭代器
print(isinstance(it, Iterator))   # True

💡 形象比喻：

  • 可迭代对象 就像一本书，里面有很多页。
  • 迭代器 就像你的手指（或书签），它指着当前这一页。你每读一页（next），手指就往后挪一页。书本身不会动，动的是手指。

02 迭代器协议：幕后发生了什么？

当你写下这行代码时：

1
2
for item in [1, 2, 3]:
    print(item)

Python 解释器在幕后实际上执行了以下逻辑（伪代码）：

1
2
3
4
5
6
7
8
9
10
11
# 1. 获取迭代器
iterator = iter([1, 2, 3]) 

while True:
    try:
        # 2. 不断获取下一个值
        item = next(iterator)
        print(item)
    except StopIteration:
        # 3. 没有值了，跳出循环
        break

关键点：

  1. iter()：调用对象的 __iter__ 方法。
  2. next()：调用迭代器的 __next__ 方法。
  3. StopIteration：当没有更多元素时，__next__ 必须抛出这个异常，通知循环结束。

03 手写一个迭代器类

为了加深理解，我们不用 list，而是自己实现一个斐波那契数列的迭代器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Fibonacci:
    def __init__(self, max_count):
        self.max_count = max_count
        self.count = 0
        self.a, self.b = 0, 1

    def __iter__(self):
        # 迭代器必须返回自身
        return self

    def __next__(self):
        if self.count >= self.max_count:
            raise StopIteration
        
        result = self.a
        self.a, self.b = self.b, self.a + self.b
        self.count += 1
        return result

# 使用
for num in Fibonacci(5):
    print(num, end=' ') 
# 输出：0 1 1 2 3

思考：如果用列表存储前 100 万个斐波那契数，内存会怎样？用迭代器呢？

  • 列表：一次性生成 100 万个整数，占用大量内存。
  • 迭代器：每次只算一个数，用完即丢，内存占用几乎不变。这就是惰性求值的威力。

04 生成器：迭代器的极简写法

手写 __iter__ 和 __next__ 太麻烦了，还要维护状态。Python 提供了生成器（Generator），它是实现迭代器最优雅的方式。

🛠 使用 yield

只要函数里包含 yield，它就不再是普通函数，而是一个生成器函数。

1
2
3
4
5
6
7
8
9
10
11
def fibonacci_gen(max_count):
    count = 0
    a, b = 0, 1
    while count < max_count:
        yield a  # 暂停在这里，返回 a，下次从这继续
        a, b = b, a + b
        count += 1

# 使用方式完全一样
for num in fibonacci_gen(5):
    print(num, end=' ')

yield 的魔法：
它保存了函数的执行上下文（局部变量、指令指针）。每次调用 next()，函数从 yield 处“醒来”，继续执行，直到遇到下一个 yield。

🚀 生成器表达式

类似列表推导式，但用圆括号 ()。

1
2
3
4
5
6
7
8
# 列表推导式：立即生成所有数据
lst = [x * 2 for x in range(1000000)] 

# 生成器表达式：只生成一个对象，按需计算
gen = (x * 2 for x in range(1000000)) 

print(next(gen)) # 0
print(next(gen)) # 2

建议：在处理大数据流时，优先使用生成器表达式，节省内存！

05 神器 itertools 标准库

Python 有一个专门处理迭代器的标准库 itertools，里面全是高效工具。不要重复造轮子！

1. 无限迭代器

1
2
3
4
5
6
import itertools

# 无限计数
counter = itertools.count(10, 2) # 10, 12, 14...
print(next(counter)) # 10
print(next(counter)) # 12

2. 有限迭代器处理

1
2
3
4
5
6
7
8
# 链式连接多个可迭代对象
for i in itertools.chain([1, 2], ['a', 'b']):
    print(i, end=' ') # 1 2 a b

# 切片 (不加载全部数据到内存)
data = range(100)
for i in itertools.islice(data, 10, 15):
    print(i, end=' ') # 10 11 12 13 14

3. 分组

1
2
3
4
5
data = ['A', 'A', 'B', 'B', 'B', 'C']
# 按相邻相同元素分组
for key, group in itertools.groupby(data):
    print(key, list(group))
# 输出：A ['A', 'A'], B ['B', 'B', 'B'], C ['C']

06 常见坑与最佳实践

⚠️ 坑 1：迭代器只能消费一次

1
2
3
gen = (x for x in range(3))
list(gen) # [0, 1, 2]
list(gen) # [] (空了！)

解决：如果需要多次使用，请转为列表 list()，或者重新创建生成器。

⚠️ 坑 2：在遍历中修改列表

1
2
3
4
nums = [1, 2, 3, 4, 5]
for n in nums:
    if n % 2 == 0:
        nums.remove(n) # 危险！会跳过元素

解决：使用列表推导式生成新列表，或遍历副本 nums[:]。

✅ 最佳实践

  1. 处理大文件：使用 for line in open('file.txt')，不要 readlines()。
  2. 数据管道：利用生成器串联数据处理步骤，类似 Unix 管道。
  3. 内存敏感：只要不需要随机访问，优先用生成器代替列表。

07 总结

今天我们深入了 Python 迭代器的核心：

  1. 区分概念：Iterable 是容器，Iterator 是游标。
  2. 理解协议：iter() 获取迭代器，next() 取值，StopIteration 结束。
  3. 掌握工具：yield 是写迭代器的捷径，itertools 是进阶利器。
  4. 核心优势：省内存、惰性计算、代码优雅。

掌握迭代器，标志着你的 Python 水平从“写脚本”迈向了“工程化”。希望你在接下来的代码中，能更多地运用迭代思维！

👇 互动话题
你在工作中遇到过因为列表太大导致内存溢出的情况吗？你是怎么解决的？欢迎在评论区留言分享！

喜欢这篇文章吗？点个「在看」，分享给更多小伙伴！👇