在 Python 中，迭代器和生成器是处理序列数据的强大工具，它们不仅能优化内存使用，还能让代码更简洁高效。很多开发者每天都在使用 for 循环遍历列表、字典，却未必清楚其背后的迭代原理。迭代器是实现迭代的基础机制，而生成器则是迭代器的高级形态，专为惰性计算设计。本文将从底层原理出发，解析这两种工具的工作机制、使用场景及核心差异。
一、迭代器：迭代的底层实现
迭代器（Iterator）是 Python 中实现了 __iter__() 和 __next__() 方法的对象，它定义了如何遍历一个容器中的元素。这种设计遵循"迭代器协议"，让不同数据结构可以用统一的方式进行遍历。
1. 迭代器的基本原理
所有可迭代对象（如列表、字符串、字典）都可以通过 iter() 函数转换为迭代器，再通过 next() 函数逐个获取元素：
# 可迭代对象转迭代器
numbers = [1, 2, 3]
it = iter(numbers) # 获取迭代器# 逐个获取元素
print(next(it)) # 输出: 1
print(next(it)) # 输出: 2
print(next(it)) # 输出: 3
print(next(it)) # 抛出 StopIteration 异常，标志迭代结束for 循环的本质就是自动处理迭代器的 next() 调用和 StopIteration 异常：
# for 循环等价逻辑
it = iter(numbers)
while True:try:print(next(it))except StopIteration:break2. 自定义迭代器
通过实现迭代器协议，我们可以创建自定义迭代器。例如实现一个生成斐波那契数列的迭代器：
class FibIterator:def __init__(self, max_count):self.max_count = max_count # 最大生成数量self.count = 0self.a, self.b = 0, 1 # 斐波那契数列初始值# 返回自身作为迭代器def __iter__(self):return self# 返回下一个元素def __next__(self):if self.count >= self.max_count:raise StopIteration # 终止迭代self.a, self.b = self.b, self.a + self.bself.count += 1return self.a# 使用自定义迭代器
fib = FibIterator(5)
for num in fib:print(num) # 输出: 1 1 2 3 5这个迭代器会按需生成下一个斐波那契数，而不是一次性创建整个序列，这是它与列表等容器的核心区别。
二、生成器：简化的迭代器
生成器（Generator）是一种特殊的迭代器，它无需手动实现 __iter__() 和 __next__() 方法，而是通过 yield 关键字自动生成迭代器协议。这种特性让生成器代码更简洁，且天生支持惰性计算。
1. 生成器函数的基本使用
包含 yield 关键字的函数就是生成器函数，调用它会返回一个生成器对象：
def fib_generator(max_count):a, b = 0, 1count = 0while count < max_count:a, b = b, a + bcount += 1yield a # 暂停执行并返回当前值# 生成器对象是迭代器的一种
fib = fib_generator(5)
print(isinstance(fib, iterator)) # 输出: Truefor num in fib:print(num) # 输出: 1 1 2 3 5与普通函数相比，生成器函数执行到 yield 时会暂停，保存当前状态，下次调用 next() 时从暂停处继续执行。这种"暂停-恢复"机制是生成器实现惰性计算的关键。
2. 生成器表达式
除了函数形式，生成器还可以通过表达式创建，语法与列表推导式类似，但使用圆括号：
# 生成器表达式
gen = (x * 2 for x in range(5))
print(type(gen)) # 输出: <class 'generator'>for val in gen:print(val) # 输出: 0 2 4 6 8生成器表达式与列表推导式的区别：
- 列表推导式
[x*2 for x in range(5)]会立即创建包含所有元素的列表 - 生成器表达式
(x*2 for x in range(5))仅在迭代时生成元素，节省内存
对于处理大数据集，生成器表达式的内存优势尤为明显：
import sys# 列表推导式：创建100万个元素的列表，占用大量内存
large_list = [x for x in range(10**6)]
print(sys.getsizeof(large_list)) # 输出: 8448728（约8MB）# 生成器表达式：不存储实际元素，内存占用极小
large_gen = (x for x in range(10**6))
print(sys.getsizeof(large_gen)) # 输出: 112（固定大小）三、迭代器与生成器的核心差异
尽管生成器是迭代器的子集，但两者在实现和使用上存在显著差异：
特性 | 迭代器 | 生成器 |
实现方式 | 需手动实现 | 通过 |
状态保存 | 需手动维护状态变量 | 自动保存函数执行状态 |
代码简洁性 | 实现复杂，适合复杂逻辑 | 代码简洁，适合简单序列生成 |
应用场景 | 自定义数据结构的迭代 | 惰性计算、流式处理、协程 |
1. 状态管理对比
迭代器需要显式维护状态（如 FibIterator 中的 count、a、b），而生成器通过函数的局部变量自动保存状态：
# 生成器自动管理状态
def counter():num = 0while True:num += 1yield numc = counter()
print(next(c)) # 1
print(next(c)) # 2（继续上次的num值）2. 异常处理
生成器可以通过 return 语句在迭代结束时返回值，这个值会包含在 StopIteration 异常中：
def limited_generator(max_val):for i in range(max_val):yield ireturn "迭代结束" # 结束时返回的值gen = limited_generator(2)
try:print(next(gen)) # 0print(next(gen)) # 1print(next(gen))
except StopIteration as e:print(e.value) # 输出: 迭代结束四、实战应用场景
1. 处理大型文件
读取大文件时，生成器可以逐行处理，避免一次性加载整个文件到内存：
def read_large_file(file_path, chunk_size=1024):"""生成器：逐块读取大文件"""with open(file_path, 'r', encoding='utf-8') as f:while True:chunk = f.read(chunk_size)if not chunk:breakyield chunk# 处理10GB日志文件，内存占用始终很低
for chunk in read_large_file('large_log.txt'):process(chunk) # 处理每块数据2. 无限序列生成
生成器可以轻松实现无限序列，因为它不需要提前存储所有元素：
def infinite_primes():"""生成器：无限生成质数"""num = 2while True:if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):yield numnum += 1# 获取前10个质数
primes = infinite_primes()
for _ in range(10):print(next(primes), end=' ') # 输出: 2 3 5 7 11 13 17 19 23 293. 流水线处理
多个生成器可以串联成处理流水线，实现数据的流式处理：
def read_data():"""读取原始数据"""for i in range(10):yield idef filter_even(numbers):"""过滤偶数"""for num in numbers:if num % 2 == 0:yield numdef square(numbers):"""计算平方"""for num in numbers:yield num **2# 流水线：读取→过滤→计算
pipeline = square(filter_even(read_data()))
print(list(pipeline)) # 输出: [0, 4, 16, 36, 64]这种方式每个环节只处理当前元素，内存效率极高。
五、常见误区与最佳实践
1.** 迭代器只能遍历一次 **迭代器和生成器都是一次性的，遍历结束后无法重置，需重新创建：
gen = (x for x in range(3))
print(list(gen)) # [0, 1, 2]
print(list(gen)) # []（已耗尽）2.** 避免在生成器中使用可变对象 **生成器保存的是变量引用，而非值，修改外部变量会影响生成器结果：
def bad_generator():data = [1, 2, 3]for x in data:yield xdata = [1, 2, 3]
gen = bad_generator()
data.append(4) # 修改会影响生成器
print(list(gen)) # 输出: [1, 2, 3, 4]3.** 合理选择迭代方式 **- 小数据集：用列表推导式更直观
- 大数据集/无限序列：用生成器表达式节省内存
- 复杂逻辑：用生成器函数提高可读性
4.** 生成器与协程 **Python 3.3+ 中，生成器通过 send()、throw() 等方法支持协程功能，可实现复杂的状态机和异步操作。
总结
迭代器是 Python 迭代机制的基础，通过 __iter__() 和 __next__() 方法实现了统一的遍历接口；生成器则是迭代器的简化版，用 yield 关键字优雅地实现了惰性计算。两者的核心价值在于：
- 惰性计算 ：按需生成元素，大幅降低内存占用
- 流式处理 ：适合处理大型文件、网络流等数据
- 代码简洁 ：避免手动管理迭代状态
理解迭代器和生成器不仅能帮助你写出更高效的代码，还能加深对 Python 迭代模型的理解。在处理数据时，应优先考虑生成器和迭代器，尤其是当数据量较大或来源未知时，它们的惰性计算特性会带来显著优势。记住：在 Python 中，"按需生成"往往比"一次创建"更高效。
)