Python迭代器与生成器详解
迭代器（Iterator）和生成器（Generator）是Python中用于高效处理序列数据的重要概念。它们不仅可以提高代码的可读性和效率，还能节省内存空间。本文将详细介绍Python迭代器与生成器的概念、实现原理、用法和最佳实践。
一、迭代器概述
1. 什么是迭代器？
迭代器是一个实现了迭代器协议的对象，用于遍历可迭代对象（Iterable）。迭代器协议要求对象必须实现两个方法：
__iter__()：返回迭代器对象本身__next__()：返回下一个元素，如果没有元素，则抛出StopIteration异常
迭代器的核心思想是惰性计算，即只在需要时才生成元素，而不是一次性生成所有元素。
2. 可迭代对象与迭代器的区别
可迭代对象（Iterable）：
- 可以被
for循环遍历的对象 - 实现了
__iter__()方法，返回一个迭代器 - 例如：列表、元组、字符串、字典、集合、文件对象等
迭代器（Iterator）：
- 实现了迭代器协议的对象
- 同时实现了
__iter__()和__next__()方法 - 只能被遍历一次
- 例如：通过
iter()函数获取的对象
3. 迭代器的工作原理
迭代器的工作原理是：
- 调用可迭代对象的
__iter__()方法获取迭代器对象 - 调用迭代器对象的
__next__()方法获取下一个元素 - 重复步骤2，直到抛出
StopIteration异常
# 迭代器的工作原理示例
# 创建可迭代对象
my_list = [1, 2, 3, 4, 5]
# 获取迭代器对象
my_iterator = iter(my_list)
print(my_iterator) # <list_iterator object at 0x...>
# 调用__next__()方法获取元素
print(next(my_iterator)) # 1
print(next(my_iterator)) # 2
print(next(my_iterator)) # 3
print(next(my_iterator)) # 4
print(next(my_iterator)) # 5
print(next(my_iterator)) # 抛出StopIteration异常
二、迭代器的使用
1. 基本用法
迭代器最常见的用法是在for循环中：
# 迭代器的基本用法示例
# 遍历列表
for item in [1, 2, 3, 4, 5]:
print(item)
# 遍历字符串
for char in "hello":
print(char)
# 遍历字典
for key in {"a": 1, "b": 2, "c": 3}:
print(key)
# 遍历文件
with open("example.txt", "r") as file:
for line in file:
print(line.strip())
2. 创建自定义迭代器
我们可以通过实现迭代器协议来创建自定义迭代器：
# 创建自定义迭代器示例
class MyIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current > self.end:
raise StopIteration
else:
value = self.current
self.current += 1
return value
# 使用自定义迭代器
my_iterator = MyIterator(1, 5)
for item in my_iterator:
print(item)
# 输出：1 2 3 4 5
# 再次遍历（迭代器已耗尽）
for item in my_iterator:
print(item)
# 无输出
# 创建一个新的迭代器
my_iterator = MyIterator(6, 10)
for item in my_iterator:
print(item)
# 输出：6 7 8 9 10
3. 内置迭代器函数
Python提供了一些内置函数来操作迭代器：
iter()：将可迭代对象转换为迭代器next()：获取迭代器的下一个元素enumerate()：同时获取元素的索引和值zip()：将多个可迭代对象的元素配对map()：对可迭代对象的每个元素应用函数filter()：过滤可迭代对象的元素reversed()：反向遍历可迭代对象
# 内置迭代器函数示例
# iter()和next()
my_list = [1, 2, 3]
my_iterator = iter(my_list)
print(next(my_iterator)) # 1
print(next(my_iterator)) # 2
# enumerate()
for index, value in enumerate(["a", "b", "c"]):
print(f"索引: {index}, 值: {value}")
# 输出：索引: 0, 值: a
# 索引: 1, 值: b
# 索引: 2, 值: c
# zip()
for a, b in zip([1, 2, 3], ["x", "y", "z"]):
print(f"{a}: {b}")
# 输出：1: x
# 2: y
# 3: z
# map()
for result in map(lambda x: x * 2, [1, 2, 3]):
print(result)
# 输出：2 4 6
# filter()
for result in filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5]):
print(result)
# 输出：2 4
# reversed()
for item in reversed([1, 2, 3, 4, 5]):
print(item)
# 输出：5 4 3 2 1
4. 迭代器的应用场景
迭代器适用于以下场景：
- 遍历大型数据集（避免一次性加载到内存）
- 处理无限序列
- 实现惰性计算
- 自定义遍历逻辑
# 迭代器的应用场景示例
# 处理大型文件
class LargeFileReader:
def __init__(self, file_path):
self.file_path = file_path
def __iter__(self):
with open(self.file_path, "r") as file:
for line in file:
yield line.strip()
# 使用迭代器逐行读取大文件
for line in LargeFileReader("large_file.txt"):
process_line(line)
# 生成无限序列
class InfiniteSequence:
def __init__(self):
self.current = 0
def __iter__(self):
return self
def __next__(self):
value = self.current
self.current += 1
return value
# 使用无限序列
for i, num in enumerate(InfiniteSequence()):
print(num)
if i >= 9: # 只打印前10个元素
break
# 输出：0 1 2 3 4 5 6 7 8 9
三、生成器概述
1. 什么是生成器？
生成器是一种特殊的迭代器，它不需要手动实现迭代器协议。生成器可以通过两种方式创建：
- 生成器函数：使用
yield关键字定义的函数 - 生成器表达式：类似于列表推导式的表达式
生成器的核心特点是惰性计算，即只在需要时才生成元素。
2. 生成器函数
生成器函数是使用yield关键字定义的函数。当调用生成器函数时，它返回一个生成器对象，而不是执行函数体。当调用next()方法时，函数体开始执行，直到遇到yield关键字，返回yield后面的值，并暂停执行。再次调用next()方法时，函数体从上次暂停的位置继续执行。
# 生成器函数示例
def my_generator():
print("开始执行生成器函数")
yield 1
print("继续执行生成器函数")
yield 2
print("继续执行生成器函数")
yield 3
print("生成器函数执行完毕")
# 调用生成器函数，返回生成器对象
gen = my_generator()
print(gen) # <generator object my_generator at 0x...>
# 调用next()方法执行生成器函数
print(next(gen)) # 输出：开始执行生成器函数
# 1
print(next(gen)) # 输出：继续执行生成器函数
# 2
print(next(gen)) # 输出：继续执行生成器函数
# 3
print(next(gen)) # 输出：生成器函数执行完毕
# 抛出StopIteration异常
3. 生成器表达式
生成器表达式类似于列表推导式，但使用圆括号()而不是方括号[]。生成器表达式返回一个生成器对象，而不是列表。
# 生成器表达式示例
# 列表推导式
list_comp = [i ** 2 for i in range(5)]
print(list_comp) # [0, 1, 4, 9, 16]
# 生成器表达式
gen_expr = (i ** 2 for i in range(5))
print(gen_expr) # <generator object <genexpr> at 0x...>
# 遍历生成器表达式
for item in gen_expr:
print(item) # 输出：0 1 4 9 16
# 生成器表达式只能遍历一次
gen_expr = (i ** 2 for i in range(5))
print(list(gen_expr)) # [0, 1, 4, 9, 16]
print(list(gen_expr)) # []（生成器已耗尽）
4. 生成器的特点
生成器具有以下特点：
- 惰性计算：只在需要时才生成元素
- 节省内存：不需要一次性存储所有元素
- 只能遍历一次：遍历结束后，生成器对象被耗尽
- 支持无限序列：可以生成无限数量的元素
- 代码简洁：比传统的迭代器实现更简洁
四、生成器的高级用法
1. 生成器的send()方法
生成器的send()方法可以向生成器发送数据，并恢复生成器的执行。send()方法的参数将作为yield表达式的值返回给生成器函数。
# 生成器的send()方法示例
def my_generator():
print("生成器开始执行")
value = yield 1
print(f"接收到的值: {value}")
value = yield 2
print(f"接收到的值: {value}")
yield 3
# 创建生成器对象
gen = my_generator()
# 第一次调用next()方法，启动生成器
print(next(gen)) # 输出：生成器开始执行
# 1
# 发送数据给生成器
print(gen.send("Hello")) # 输出：接收到的值: Hello
# 2
# 再次发送数据给生成器
print(gen.send("World")) # 输出：接收到的值: World
# 3
2. 生成器的throw()方法
生成器的throw()方法可以向生成器抛出异常，生成器可以捕获并处理该异常。
# 生成器的throw()方法示例
def my_generator():
try:
yield 1
yield 2
yield 3
except ValueError:
print("捕获到ValueError异常")
yield "异常后的值"
except StopIteration:
print("捕获到StopIteration异常")
# 创建生成器对象
gen = my_generator()
print(next(gen)) # 1
print(next(gen)) # 2
# 向生成器抛出异常
print(gen.throw(ValueError)) # 输出：捕获到ValueError异常
# 异常后的值
print(next(gen)) # 抛出StopIteration异常
3. 生成器的close()方法
生成器的close()方法可以关闭生成器，调用后无法再从生成器获取元素。
# 生成器的close()方法示例
def my_generator():
yield 1
yield 2
yield 3
# 创建生成器对象
gen = my_generator()
print(next(gen)) # 1
# 关闭生成器
gen.close()
print(next(gen)) # 抛出StopIteration异常
4. 生成器中的return语句
在Python 3.3及以上版本中，生成器函数可以包含return语句，用于结束生成器的执行并返回一个值。当生成器遇到return语句时，它会抛出StopIteration异常，并将return语句的值作为异常的value属性。
# 生成器中的return语句示例
def my_generator():
yield 1
yield 2
return "生成器执行完毕"
gen = my_generator()
print(next(gen)) # 1
print(next(gen)) # 2
try:
next(gen)
except StopIteration as e:
print(f"捕获到StopIteration异常，值为: {e.value}")
# 输出：捕获到StopIteration异常，值为: 生成器执行完毕
五、迭代器与生成器的区别与联系
1. 联系
- 生成器是一种特殊的迭代器
- 生成器自动实现了迭代器协议
- 都支持惰性计算
- 都只能遍历一次
2. 区别
| 特性 | 迭代器 | 生成器 |
|---|---|---|
| 实现方式 | 手动实现__iter__()和__next__()方法 |
使用yield关键字或生成器表达式 |
| 代码复杂度 | 较高 | 较低 |
| 内存占用 | 较低 | 极低 |
| 功能 | 基础遍历功能 | 支持send()、throw()、close()等高级功能 |
| 创建方式 | 类实现 | 函数或表达式 |
# 迭代器与生成器的区别示例
# 迭代器实现
class MyIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current > self.end:
raise StopIteration
else:
value = self.current
self.current += 1
return value
# 生成器实现
def my_generator(start, end):
current = start
while current <= end:
yield current
current += 1
# 使用迭代器
print("使用迭代器：")
iterator = MyIterator(1, 5)
for item in iterator:
print(item)
# 使用生成器
print("\n使用生成器：")
generator = my_generator(1, 5)
for item in generator:
print(item)
六、高级话题
1. 协程与生成器
在Python中，生成器可以用作协程（Coroutine），即可以暂停执行并在后续恢复执行的函数。协程是实现异步编程的基础。
# 协程示例
def coroutine():
print("协程准备接收数据")
while True:
value = yield
print(f"协程接收到数据: {value}")
# 创建协程对象
co = coroutine()
# 启动协程（执行到第一个yield）
next(co)
# 发送数据给协程
co.send("Hello") # 输出：协程接收到数据: Hello
co.send("World") # 输出：协程接收到数据: World
# 关闭协程
co.close()
2. 异步生成器
Python 3.6及以上版本支持异步生成器（Asynchronous Generator），它结合了异步编程和生成器的特性。异步生成器使用async def定义，并使用yield关键字生成值。
# 异步生成器示例
import asyncio
async def async_generator():
for i in range(5):
await asyncio.sleep(0.1) # 模拟异步操作
yield i
async def main():
print("开始执行异步生成器")
async for item in async_generator():
print(f"获取到值: {item}")
print("异步生成器执行完毕")
# 运行异步函数
asyncio.run(main())
3. 无限序列生成器
生成器可以用于生成无限序列，因为它不需要一次性存储所有元素。
# 无限序列生成器示例
# 生成无限整数序列
def infinite_integers():
i = 0
while True:
yield i
i += 1
# 生成无限斐波那契数列
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 使用无限整数序列
print("无限整数序列（前10个）：")
for i, num in enumerate(infinite_integers()):
print(num, end=" ")
if i >= 9:
break
print()
# 使用无限斐波那契数列
print("斐波那契数列（前10个）：")
for i, num in enumerate(fibonacci()):
print(num, end=" ")
if i >= 9:
break
print()
4. 生成器管道
生成器可以组合成管道，用于处理数据流。每个生成器处理数据的一部分，然后将结果传递给下一个生成器。
# 生成器管道示例
# 生成器1：生成数字
def generate_numbers(n):
for i in range(n):
yield i
# 生成器2：过滤偶数
def filter_even(numbers):
for num in numbers:
if num % 2 == 0:
yield num
# 生成器3：计算平方
def square(numbers):
for num in numbers:
yield num ** 2
# 组合生成器管道
n = 10
result = square(filter_even(generate_numbers(n)))
print(f"0到{n-1}中偶数的平方：")
for num in result:
print(num, end=" ")
# 输出：0 4 16 36 64
七、性能分析
1. 内存性能
迭代器和生成器的最大优势是节省内存，因为它们只在需要时才生成元素，而不是一次性生成所有元素。
# 内存性能比较示例
import sys
# 列表（一次性生成所有元素）
list_comp = [i for i in range(1000000)]
print(f"列表占用内存: {sys.getsizeof(list_comp)} 字节")
# 生成器表达式（只生成生成器对象）
gen_expr = (i for i in range(1000000))
print(f"生成器表达式占用内存: {sys.getsizeof(gen_expr)} 字节")
# 结果示例（具体数值可能因Python版本和系统而异）
# 列表占用内存: 8448728 字节
# 生成器表达式占用内存: 104 字节
2. 时间性能
生成器的时间性能通常与迭代器相当，甚至略好，因为生成器的实现更加高效。
# 时间性能比较示例
import time
# 生成器函数
def generator_function(n):
for i in range(n):
yield i
# 迭代器类
class IteratorClass:
def __init__(self, n):
self.n = n
self.current = 0
def __iter__(self):
return self
def __next__(self):
if self.current >= self.n:
raise StopIteration
value = self.current
self.current += 1
return value
# 列表
def list_function(n):
return list(range(n))
# 测试性能
n = 1000000
# 测试生成器函数
start_time = time.time()
for i in generator_function(n):
pass
end_time = time.time()
print(f"生成器函数耗时: {end_time - start_time:.6f}秒")
# 测试迭代器类
start_time = time.time()
for i in IteratorClass(n):
pass
end_time = time.time()
print(f"迭代器类耗时: {end_time - start_time:.6f}秒")
# 测试列表
start_time = time.time()
for i in list_function(n):
pass
end_time = time.time()
print(f"列表耗时: {end_time - start_time:.6f}秒")
八、最佳实践
1. 优先使用生成器
生成器比传统的迭代器实现更简洁、更易读，因此应优先使用生成器。
# 优先使用生成器示例
# 不推荐：手动实现迭代器
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
value = self.data[self.index]
self.index += 1
return value
# 推荐：使用生成器
def my_generator(data):
for item in data:
yield item
2. 避免一次性加载大量数据
对于大型数据集，应使用迭代器或生成器，而不是一次性加载到内存。
# 处理大型文件示例
# 不推荐：一次性加载所有行
with open("large_file.txt", "r") as file:
lines = file.readlines() # 可能导致内存不足
for line in lines:
process_line(line)
# 推荐：使用迭代器逐行读取
with open("large_file.txt", "r") as file:
for line in file: # 文件对象是迭代器
process_line(line)
3. 使用生成器表达式替代列表推导式
当只需要遍历一次数据时，应使用生成器表达式替代列表推导式，以节省内存。
# 使用生成器表达式替代列表推导式示例
# 不推荐：使用列表推导式（一次性生成所有元素）
squares = [i ** 2 for i in range(1000000)]
for square in squares:
process_square(square)
# 推荐：使用生成器表达式（按需生成元素）
squares = (i ** 2 for i in range(1000000))
for square in squares:
process_square(square)
4. 合理使用生成器的高级功能
生成器的send()、throw()、close()等高级功能应谨慎使用，只在必要时使用。
九、常见错误
1. 重复遍历生成器
生成器只能遍历一次，遍历结束后，生成器对象被耗尽。
# 错误：重复遍历生成器示例
def my_generator():
yield 1
yield 2
yield 3
gen = my_generator()
# 第一次遍历
print("第一次遍历：")
for item in gen:
print(item)
# 第二次遍历（生成器已耗尽）
print("\n第二次遍历：")
for item in gen:
print(item) # 无输出
# 正确：创建新的生成器对象
gen = my_generator()
print("\n创建新生成器后遍历：")
for item in gen:
print(item)
2. 忘记启动生成器
使用send()方法之前，必须先调用next()方法启动生成器。
# 错误：忘记启动生成器示例
def my_generator():
value = yield
print(f"接收到的值: {value}")
gen = my_generator()
# 错误：直接调用send()方法
gen.send("Hello") # 抛出TypeError异常
# 正确：先调用next()方法启动生成器
gen = my_generator()
next(gen) # 启动生成器
gen.send("Hello") # 输出：接收到的值: Hello
3. 生成器中的return语句
在Python 3.3之前的版本中，生成器函数中不能使用return语句（除了无值return）。
# 错误：在旧版本Python中使用return语句示例
def my_generator():
yield 1
return "结束" # 在Python 3.3之前会抛出SyntaxError异常
yield 2
4. 混淆迭代器与可迭代对象
迭代器是可迭代对象，但可迭代对象不一定是迭代器。
# 混淆迭代器与可迭代对象示例
my_list = [1, 2, 3]
# 错误：直接调用next()方法
next(my_list) # 抛出TypeError异常
# 正确：先转换为迭代器
my_iterator = iter(my_list)
next(my_iterator) # 1
十、总结
迭代器和生成器是Python中用于高效处理序列数据的重要概念。它们的核心特点是惰性计算，即只在需要时才生成元素，从而节省内存空间。
1. 迭代器
- 实现了迭代器协议（
__iter__()和__next__()方法） - 用于遍历可迭代对象
- 支持惰性计算
- 只能遍历一次
2. 生成器
- 特殊的迭代器，自动实现迭代器协议
- 通过生成器函数（
yield关键字）或生成器表达式创建 - 代码简洁，易于实现
- 支持高级功能（
send()、throw()、close()等）
3. 应用场景
- 处理大型数据集
- 生成无限序列
- 实现惰性计算
- 构建数据处理管道
- 异步编程
通过掌握Python迭代器与生成器的概念、实现原理和用法，可以编写出更高效、更简洁、更易读的Python代码。
发布网站：荣殿教程（zhangrongdian.com）
作者：张荣殿
