处理 10GB 文件不爆内存，Python 迭代器凭什么

1. 场景案例：Python大文件处理

去年遇到一个数据清洗任务，日志文件足足有12GB。同事的第一反应很直接：用readlines()把文件全部读进内存，再逐条处理。结果程序跑了三分钟，直接报了个MemoryError。

其实只改了一个地方：把readlines()换成直接遍历文件对象。就这么一个调整，内存峰值从接近14GB降到了不足100MB。

背后的区别很简单：前者是一次性加载，后者则利用了Python迭代器的惰性特性。很多开发者写了多年Python，依然习惯用列表推导式处理一切。不是说不能用，但遇到大数据量时，迭代器和生成器才是那个“正解”。

2. 什么是迭代器

用大白话说，迭代器就是一个知道怎么“一个一个给”东西的对象。你每次问它要下一个，它就给你下一个；给完了，就抛个信号说“没了”，整个过程干净利落。

Python里那个熟悉的for x in something:语法，底层调用的正是迭代器协议。这个协议的核心，就两个方法：

• __iter__：返回迭代器对象本身。
• __next__：返回下一个元素。如果没元素了，就抛出StopIteration异常。

看，这就是迭代器协议的全部内容，两个方法，简单直接。

class Counter:
    def __init__(self, max_num):
        self.max_num = max_num
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.max_num:
            raise StopIteration
        self.current += 1
        return self.current

for i in Counter(5):
    print(i)  # 输出：1, 2, 3, 4, 5

上面这个Counter类就是一个自定义迭代器。__iter__返回自己，__next__每次递增并返回当前值，到上限就抛出异常结束迭代。

3. 可迭代对象 vs 迭代器

这两个概念经常被混用，但它们确实不是一回事。

• 可迭代对象：拥有__iter__()方法，能返回一个迭代器。比如列表（list）、元组（tuple）、字符串（str）、字典（dict）。
• 迭代器：不仅拥有__iter__()方法，还有__next__()方法，本身就能被遍历。

举个例子，列表是可迭代对象，但它本身不是迭代器。你可以用for循环遍历它，但不能直接对它调用next()。

lst = [1, 2, 3]
next(lst)  # TypeError: list object is not an iterator

it = iter(lst)  # 通过iter()函数获取它的迭代器
next(it)  # 1
next(it)  # 2
next(it)  # 3
next(it)  # 抛出StopIteration异常

这里的iter()函数，其实就是调用了对象内部的__iter__()方法。

简单总结一下：

• 可迭代对象不一定是迭代器。
• 迭代器一定是可迭代对象。
• 可迭代对象可以通过iter()函数得到一个迭代器。

4. 生成器：迭代器的快捷方式

实现一个完整的迭代器类需要定义两个方法，略显繁琐。而生成器提供了一种更简洁的实现方式，它会自动满足迭代器协议。

创建生成器，最常用的方式就是使用yield关键字。一个函数里只要包含了yield，它就变成了生成器函数。

def counter(max_num):
    current = 0
    while current < max_num:
        current += 1
        yield current

for i in counter(5):
    print(i)  # 输出：1, 2, 3, 4, 5

yield和return的关键区别在于：return执行完函数就彻底结束了，而yield会暂停函数执行，保存当前状态，下次调用next()时再从暂停的地方继续。这正是生成器节省内存的秘诀——它不事先存储所有结果，而是“用一次，算一次”。

(1) 生成器表达式

还有一种更轻量的创建方式：生成器表达式。只需把列表推导式的方括号[]换成圆括号()。

# 列表推导式 - 一次性生成所有结果，全部加载到内存
squares = [x*x for x in range(1000000)]  # 占内存约8.06MB

# 生成器表达式 - 惰性计算，用一次算一次
squares = (x*x for x in range(1000000))  # 内存占用极小，约200字节

当数据量达到一定规模时，这两种方式的区别就不再是“快一点”或“慢一点”，而是“能跑”和“根本跑不了”的天壤之别。

5. 实战场景

(1) 场景一：大文件处理

# 错误写法：一次性加载
with open('huge.log') as f:
    lines = f.readlines()  # 返回list，全部加载到内存
    for line in lines:
        process(line)

# 正确写法：利用文件对象自身的迭代器特性
with open('huge.log') as f:
    for line in f:  # 文件对象是迭代器，每次只读一行
        process(line)

Python的文件对象本身就是一个迭代器，直接遍历它，解释器会自动按行惰性读取，避免内存爆炸。

(2) 场景二：数据流处理

def read_api_pages(url):
    page = 1
    while True:
        response = requests.get(url, params={'page': page})
        data = response.json()
        if not data:
            break
        yield from data  # 将子迭代器的值直接产出
        page += 1

for item in read_api_pages('https://api.example.com/items'):
    process(item)

这里用到了yield from，它能将子迭代器的值直接传递出来。这种模式特别适合处理分页API、数据库游标等需要连续获取数据的场景。

(3) 场景三：管道式数据处理

def read_csv(filepath):
    with open(filepath) as f:
        for line in f:
            yield line.strip().split(',')

def filter_age(records, min_age):
    for record in records:
        if int(record[2]) >= min_age:
            yield record

def format_output(records):
    for record in records:
        yield f"{record[0]}|{record[1]}|{record[2]}"

# 像组装流水线一样组合起来
data = read_csv('users.csv')
filtered = filter_age(data, 18)
formatted = format_output(filtered)

for line in formatted:
    print(line)

每个函数都是一个生成器，数据像在流水线（pipeline）中传递。中间不需要任何额外的列表或容器来存储临时结果，内存效率极高。

6. 常见坑

第一个坑：迭代器和生成器是“一次性消耗品”。

gen = (x for x in range(5))
list(gen)  # 第一次转换，得到 [0, 1, 2, 3, 4]
list(gen)  # 第二次转换，得到 [] —— 因为生成器已经耗尽了

遍历完一次后，迭代器或生成器就空了。如果需要重复使用，要么将其转换为列表，要么重新创建。

第二个坑：生成器函数返回的是生成器对象，不是执行结果。

def my_gen():
    yield 1
    yield 2
    yield 3

result = my_gen()  # 这里只是得到了一个生成器对象，函数体内的代码并未执行
# 需要遍历（如用for循环或next()）才会触发yield语句执行

新手常会困惑：明明调用了函数，为什么没有输出？记住，调用生成器函数返回的是一个待“激活”的生成器对象，真正的计算发生在迭代时。

7. 总结

最后，我们来梳理一下这几个核心概念的关系：

• 可迭代对象 (Iterable)：有__iter__()方法。
• 迭代器 (Iterator)：继承自可迭代对象，多了__next__()方法。__iter__()通常返回self，并能保持迭代状态。文件对象就在这里。
• 生成器 (Generator)：一种特殊的迭代器，由生成器函数或生成器表达式创建。除了迭代器的方法，还有send(), throw(), close()等方法，使用yield关键字实现。

归根结底，迭代器和生成器的核心优势在于惰性：惰性访问、惰性计算，用一次算一次，对内存极其友好。它们的协议也足够简单，实现__iter__和__next__两个方法就能搞定。生成器则是更便捷的语法糖，yield让一个普通函数变身迭代器。

处理小数据时，列表和生成器的差异或许微不足道。可一旦数据量上来，这其中的区别，往往就决定了程序是顺利运行，还是中途崩溃。

文章开头那个12GB的日志文件案例，后来成了技术面试中的一个经典问题。题目本身不难，但能清晰地分辨出一个开发者，是否真正理解了Python迭代器与生成器的原理，以及能否在关键时刻做出正确的应用选择。