《迭代器 VS 生成器：Python 惰性计算的两种实现方案详解》

从生活场景理解核心概念

想象你在超市买零食：

• 如果你把整箱零食全抱回家（一次性加载所有数据），占地方还累 —— 这就像列表、字典等可迭代对象。
• 如果你每次只拿一包，吃完再拿下一包（用一个取一个），既省空间又轻松 —— 这就是迭代器和生成器的 "懒加载" 思想。

核心区别一句话总结：

• 迭代器：是一种 "工具"，能逐个返回数据，需要手动实现遍历逻辑（像自己做了个取零食的机器）。
• 生成器：是特殊的迭代器，用更简单的语法实现（像买了个现成的自动取零食机，不用自己做）。

1.迭代器 - Iterator

        迭代器提供了一种惰性（lazy evaluation）获取数据的方法，它的核心是按需返回数据，使得我们能够逐步访问序列中的元素，而无需一次性加载所有数据。其主要优点包括节省内存、提高性能、支持自定义遍历逻辑等。

1.1特点

1. 惰性计算：按需生成数据，节省内存。

2. 实现协议：

   • __iter__()：返回自身。

   • __next__()：返回下一个元素；如果没有更多元素，则抛出 StopIteration 异常。

3. 可迭代对象（Iterable）与迭代器不同：

   • 可迭代对象实现 __iter__() 方法，返回一个迭代器。

   • 迭代器既实现 __iter__() 又实现 __next__()。

1.2迭代器的创建

• 迭代器只能往前取值,不会后退

• 用iter函数可以返回一个可迭代对象的迭代器

# 示例 可迭代对象
L = [1, 3, 5, 7]
it = iter(L)  # 从L对象中获取迭代器
next(it)  # 1  从迭代器中提取一个数据
next(it)  # 3
print(next(it))   # 5
next(it)  # 7
# 示例2 生成器函数
It = iter(range(1, 10, 3))
next(It)  # 1
print(next(It))  # 4
next(It)  # 7

1.3自定义迭代器

# 自定义迭代器类
class MyIterator:def __init__(self, data):self.data = dataself.index = 0def __iter__(self):return self  # 迭代器返回自身def __next__(self):if self.index < len(self.data):result = self.data[self.index]self.index += 1return resultelse:raise StopIteration  # 数据迭代结束# 使用自定义迭代器
my_iter = MyIterator([1, 2, 3])
for item in my_iter:print(item)

1.4 可迭代对象 vs 迭代器：别搞混了！

        很多人分不清 "可迭代对象" 和 "迭代器"，其实简单说：

• 可迭代对象：是能产生迭代器的对象（如列表、字符串、range），它只实现了__iter__()方法。
• 迭代器：是能直接取数据的对象，同时实现了__iter__()和__next__()方法。

举例区分：

# 列表是可迭代对象（不是迭代器）
my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__'))  # 输出：True（有__iter__）
print(hasattr(my_list, '__next__'))  # 输出：False（没有__next__）# 用iter()把可迭代对象转成迭代器
my_iter = iter(my_list)
print(hasattr(my_iter, '__iter__'))  # 输出：True
print(hasattr(my_iter, '__next__'))  # 输出：True（是迭代器）# 用next()取数据
print(next(my_iter))  # 输出：1
print(next(my_iter))  # 输出：2

2.生成器 - Generator

        生成器是一种特殊的迭代器，通过函数定义，用 yield 语句生成值。生成器可以自动实现迭代协议，无需手动实现 __iter__() 和 __next__()。

2.1特点

1. 简洁：比手动实现迭代器更易写。

2. 惰性计算：生成器在每次调用 next()时生成一个值，而不是一次性生成所有值。

3. yield：暂停函数执行并返回值，保留函数的状态，以便下一次继续执行。

4. 普通函数用return返回值，返回后函数结束。
5. 生成器函数用yield返回值，返回后会 "暂停"，下次调用时从暂停的地方继续。

def num_generator():print("准备生成1")yield 1  # 返回1，然后暂停print("准备生成2")yield 2  # 返回2，然后暂停print("准备生成3")yield 3print("准备生成4")yield 4print("准备生成5")yield 5# 创建生成器（调用函数不会执行，只返回生成器对象）
gen = num_generator()# 用next()触发执行
print(next(gen))  # 输出：准备生成1 → 1
print(next(gen))  # 输出：准备生成2 → 2
print(next(gen))  # 输出：准备生成3 → 3

运行流程解析：

• 第一次调用next(gen)：函数执行到yield 1，返回 1，然后 "暂停"（记住当前位置）。
• 第二次调用next(gen)：从上次暂停的地方继续，执行到yield 2，返回 2，再暂停。
• 直到所有yield执行完，再次调用会抛出StopIteration。

示例：

def Descendorder(n):while n > 0:yield nn -= 1# 创建生成器对象
generator = Descendorder(5)# 通过迭代生成器获取值
print(next(generator))  #5
print(next(generator))  #4# 使用 for 循环迭代生成器
for i in generator:print('for循环：', i)  #3  2  1

2.2生成器表达式

        生成器可以用表达式形式定义，类似列表推导式，但使用小括号 ()。

        语法：（  表达式   for   变量    in    可迭代对象    [   if    真值表达式   ]  ）

# 列表推导式：一次性生成所有数据（占内存）
list_expr = [x*2 for x in range(5)]
print(list_expr)  # 输出：[0, 2, 4, 6, 8]# 生成器表达式：按需生成（省内存）
gen_expr = (x*2 for x in range(5))
print(gen_expr)  # 输出：<generator object <genexpr> at 0x...>（不是直接返回数据）# 用next()取数据
print(next(gen_expr))  # 输出：0
print(next(gen_expr))  # 输出：2
for num in gen_expr:print(num)  # 输出：4 → 6 → 8

核心区别：

• 列表推导式[x*2 ...]：立即计算所有结果，存到内存。
• 生成器表达式(x*2 ...)：不计算，等next()或for循环时才计算，适合大数据。

2.3生成器的经典应用：处理大数据

        比如读取 10GB 的大文件，用生成器一行行读，而不是一次性加载到内存：

def read_large_file(file_path):with open(file_path, 'r', encoding='utf-8') as f:for line in f:  # 逐行读取（本身就是迭代器）yield line.strip()  # 返回一行内容，暂停# 使用生成器读大文件
for line in read_large_file('big_file.txt'):print(line)  # 一行行处理，不占大量内存

2.4 练习

        代码实现斐波那契数列前十个

参考代码：

def fibonacci(n):a, b = 0, 1for _ in range(n):yield ba, b = b, a + bfib_seq = fibonacci(10)for i in fib_seq:print(i, end=" ")# 运行结果
# 1 1 2 3 5 8 13 21 34 55

2.5应用场景

• 数据流处理：处理大文件或流式数据，避免内存耗尽。

• 无限序列生成：如斐波那契数列、素数序列。

• 管道化数据处理：与 itertools 模块结合使用。

参考代码：

def read_large_file(file_path):with open(file_path, 'r') as file:for line in file:yield line.strip()for line in read_large_file('large_file.txt'):print(line)

3. 区别对比

总结：懒加载是精髓

        迭代器和生成器的核心思想都是"懒加载"——不提前准备所有数据，而是用的时候再生成。这种思想在处理大数据、流式数据时尤为重要，能帮你避免内存溢出，提高程序效率。  

        简单说：如果你需要一个"取数工具"，优先用生成器（简单）；如果生成器满足不了复杂需求，再自己实现迭代器（灵活）。