在Python编程中，迭代器和生成器是处理数据流和惰性计算的核心工具。它们通过按需生成数据的方式优化内存使用，特别适合处理大规模数据集或无限序列。本文将从概念、实现方式、区别和实际应用场景四个方面进行详细解析，并提供丰富的代码示例。
一、迭代器（Iterator）
1.1 核心概念
迭代器是一个实现了迭代协议的对象，必须包含两个特殊方法：
__iter__()：返回迭代器自身__next__()：返回下一个元素，无元素时抛出StopIteration
核心特点：
- 惰性计算：按需生成数据，不预加载
- 单向遍历：只能向前取值，不能后退
- 状态保留：记录当前迭代位置
1.2 创建方式
方式1：内置函数转换
L = [1, 3, 5, 7]
it = iter(L) # 将列表转为迭代器
print(next(it)) # 输出：1
print(next(it)) # 输出：3
方式2：自定义迭代器类
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):
result = self.data[self.index]
self.index += 1
return result
raise StopIteration
# 使用示例
my_iter = MyIterator([10, 20, 30])
for item in my_iter:
print(item) # 输出：10 20 30
1.3 应用场景
-
大数据集处理：
class FileChunkIterator: def __init__(self, filename, chunk_size=1024): self.filename = filename self.chunk_size = chunk_size def __iter__(self): self.file = open(self.filename, 'r') return self def __next__(self): data = self.file.read(self.chunk_size) if not data: self.file.close() raise StopIteration return data -
自定义数据结构遍历：
class TreeNode: def __init__(self, value): self.value = value self.children = [] class TreeDFSIterator: def __init__(self, root): self.stack = [root] def __iter__(self): return self def __next__(self): if not self.stack: raise StopIteration node = self.stack.pop() self.stack.extend(reversed(node.children)) return node.value
二、生成器（Generator）
2.1 核心概念
生成器是一种特殊迭代器，通过yield关键字实现：
- 函数执行到
yield时暂停并返回值 - 下次调用从暂停处继续执行
- 自动实现迭代协议，无需定义
__iter__和__next__
核心优势：
- 代码更简洁
- 自动状态管理
- 内存效率极高
2.2 创建方式
方式1：生成器函数
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield b
a, b = b, a + b
# 使用示例
for num in fibonacci(10):
print(num, end=" ") # 输出：1 1 2 3 5 8 13 21 34 55
方式2：生成器表达式
squares = (x*x for x in range(10))
print(next(squares)) # 0
print(next(squares)) # 1
2.3 高级用法
-
双向通信：
def interactive_gen(): total = 0 while True: value = yield total if value is None: break total += value gen = interactive_gen() next(gen) # 启动生成器 print(gen.send(5)) # 输出：5 print(gen.send(3)) # 输出：8 -
管道处理：
def read_lines(file): with open(file) as f: for line in f: yield line.strip() def filter_comments(lines): for line in lines: if not line.startswith('#'): yield line def uppercase(lines): for line in lines: yield line.upper() # 构建处理管道 pipeline = uppercase(filter_comments(read_lines('config.txt')))
2.4 应用场景
-
流式数据处理：
def process_logs(log_file): for line in read_large_file(log_file): if "ERROR" in line: yield parse_error(line) -
无限序列生成：
def prime_generator(): yield 2 primes = [2] num = 3 while True: if all(num % p != 0 for p in primes if p*p <= num): primes.append(num) yield num num += 2 -
状态机实现：
def traffic_light(): states = ["RED", "GREEN", "YELLOW"] index = 0 while True: yield states[index] index = (index + 1) % len(states)
三、核心区别对比
| 特性 | 迭代器 | 生成器 |
|---|---|---|
| 实现复杂度 | 需手动实现协议方法 | 自动实现协议 |
| 代码简洁度 | 较冗长（需定义类） | 极简洁（函数+yield） |
| 状态管理 | 需手动维护状态变量 | 自动保存函数执行状态 |
| 内存效率 | 高（惰性加载） | 极高（无额外对象开销） |
| 适用场景 | 复杂迭代逻辑 | 简单数据流和状态机 |
| 创建方式 | 类实现或iter()转换 | 函数或表达式 |
| 通信能力 | 单向输出 | 支持双向通信（send()） |
四、实际应用场景对比
4.1 迭代器最佳场景
-
复杂数据结构遍历：
class MatrixIterator: def __init__(self, matrix): self.matrix = matrix self.row = 0 self.col = 0 def __iter__(self): return self def __next__(self): if self.row >= len(self.matrix): raise StopIteration value = self.matrix[self.row][self.col] self.col += 1 if self.col >= len(self.matrix[self.row]): self.row += 1 self.col = 0 return value -
需要精细控制的状态机：
class ParseStateMachine: def __init__(self, input_str): self.input = input_str self.pos = 0 self.state = "START" def __iter__(self): return self def __next__(self): if self.pos >= len(self.input): raise StopIteration char = self.input[self.pos] self.pos += 1 if self.state == "START": if char.isalpha(): self.state = "WORD" return ("START_WORD", char) # 其他状态转换...
4.2 生成器最佳场景
-
数据管道处理：
def data_pipeline(): # 阶段1：数据采集 raw_data = (fetch_data(id) for id in id_stream()) # 阶段2：数据清洗 cleaned = (clean(d) for d in raw_data if is_valid(d)) # 阶段3：数据分析 analyzed = (analyze(d) for d in cleaned) # 阶段4：结果输出 for result in analyzed: yield format_result(result) -
协程实现：
def customer_service(): while True: issue = yield if "退款" in issue: response = handle_refund(issue) elif "投诉" in issue: response = handle_complaint(issue) else: response = default_response(issue) yield response # 使用协程 cs = customer_service() next(cs) # 启动 cs.send("我要退款") # 发送问题 print(cs.send(None)) # 获取响应
五、性能对比实验
import time
import sys
# 迭代器实现
class RangeIterator:
def __init__(self, n):
self.n = n
self.i = 0
def __iter__(self):
return self
def __next__(self):
if self.i < self.n:
result = self.i
self.i += 1
return result
raise StopIteration
# 生成器实现
def range_generator(n):
i = 0
while i < n:
yield i
i += 1
# 内存测试
n = 1000000
print("迭代器内存:", sys.getsizeof(RangeIterator(n)), "bytes")
print("生成器内存:", sys.getsizeof(range_generator(n)), "bytes")
# 速度测试
def test_speed(func):
start = time.time()
for _ in func(n):
pass
return time.time() - start
print("迭代器耗时:", test_speed(RangeIterator))
print("生成器耗时:", test_speed(range_generator))
典型输出结果：
迭代器内存: 48 bytes
生成器内存: 128 bytes
迭代器耗时: 0.15s
生成器耗时: 0.12s
结论：生成器在内存效率和执行速度上均有优势，尤其在处理大规模数据时差异更明显
总结
迭代器和生成器是Python中处理数据流的两种强大工具：
- 迭代器 提供基础协议，适合需要精细控制的场景
- 生成器 通过
yield简化实现，在大多数场景更高效 - 核心区别 在于实现方式、状态管理和代码复杂度
- 实际选择 应基于：数据规模、状态复杂度、性能需求
掌握这两者的区别和适用场景，能够帮助开发者编写出更高效、更优雅的Python代码，特别是在数据处理、流式计算和内存优化等关键领域。
扫一扫
3155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
