在Python学习过程中，迭代器和生成器这两个概念经常让初学者感到困惑。它们看起来相似，但又有着微妙的区别。今天，我们就用最通俗易懂的方式，把它们彻底讲清楚！
迭代器：像点读机一样的存在
什么是迭代器
想象你有一本永远不能翻回去的书，每次只能看下一页，这就是迭代器的本质。
# 迭代器就像这本书
book = BookIterator(["第1页", "第2页", "第3页"])
next(book) # 得到 "第1页"
next(book) # 得到 "第2页"
next(book) # 得到 "第3页"
next(book) # 报错！书翻完了
迭代器的核心特征
- 1. 惰性计算：一次只处理一个元素，不占用大量内存
判断是否为迭代器
from collections.abc import Iterator, Iterable
# 能被for循环遍历的都是可迭代对象（Iterable）
my_list = [1, 2, 3]
print(isinstance(my_list, Iterable)) # True
print(isinstance(my_list, Iterator)) # False
# 调用iter()方法后得到迭代器
my_iterator = iter(my_list)
print(isinstance(my_iterator, Iterator)) # True
自定义迭代器
class CountDown:
def __init__(self, start):
self.start = start
def __iter__(self):
return self
def __next__(self):
if self.start <= 0:
raise StopIteration
self.start -= 1
return self.start + 1
# 使用
cd = CountDown(5)
for num in cd:
print(num) # 输出：5, 4, 3, 2, 1
生成器：迭代器的智能升级版
什么是生成器
生成器是一种特殊的迭代器，它通过yield关键字自动实现了迭代器协议，写起来更简单。
# 生成器函数：只要有yield就是生成器函数
def count_down(n):
while n > 0:
yield n # 暂停并返回值
n -= 1
# 调用生成器函数得到生成器对象（此时函数体不执行）
cd = count_down(5)
# 通过next()执行
print(next(cd)) # 5：执行到yield暂停
print(next(cd)) # 4：从上次暂停处继续执行
生成器的执行机制
def demo_generator():
print("开始执行")
yield 1
print("继续执行")
yield 2
print("结束执行")
gen = demo_generator() # 什么都不打印，只是创建生成器
next(gen) # 打印"开始执行"，返回1（停在第一个yield）
next(gen) # 打印"继续执行"，返回2（停在第二个yield）
next(gen) # 打印"结束执行"，抛出StopIteration
yield from：简化嵌套生成
# 不使用yield from
def chain1():
for i in [1, 2, 3]:
yield i
for c in "abc":
yield c
# 使用yield from（更简洁）
def chain2():
yield from [1, 2, 3]
yield from "abc"
# 两者效果相同：1, 2, 3, 'a', 'b', 'c'
生成器表达式
# 列表推导式（立即计算，占用内存）
squares_list = [x**2 for x in range(10)]
# 生成器表达式（惰性计算，省内存）
squares_gen = (x**2 for x in range(10))
print(type(squares_list)) # <class 'list'>
print(type(squares_gen)) # <class 'generator'>
核心区别
# 1. 一次性特性（相同）
nums = (x for x in [1,2,3])
print(list(nums)) # [1,2,3]
print(list(nums)) # [] - 第二次就没了
# 2. 生成器的send()方法（独有）
def calculator():
total = 0
while True:
value = yield total
if value:
total += value
calc = calculator()
next(calc) # 启动生成器
print(calc.send(10)) # 发送10，输出10
print(calc.send(20)) # 发送20，输出30
应用场景
处理超大文件
# 逐行读取10GB的日志文件
def read_large_log(file_path):
with open(file_path, 'r', encoding='utf-8') as f:
for line in f:
yield line.strip()
# 处理每一行，内存占用极小
for log_line in read_large_log('huge_app.log'):
if 'ERROR' in log_line:
print(log_line)
分页获取API数据
import requests
def fetch_paginated_data(api_url, page_size=100):
page = 1
while True:
response = requests.get(
f"{api_url}?page={page}&size={page_size}"
)
data = response.json()
if not data:
break
for item in data:
yield item
page += 1
# 优雅地处理所有分页
for user in fetch_paginated_data('https://api.example.com/users'):
process_user(user)
无限序列生成
# 生成无限ID（永远不占满内存）
def infinite_id_generator():
id = 1
while True:
yield id
id += 1
# 配合itertools使用
import itertools
id_gen = infinite_id_generator()
first_100_ids = list(itertools.islice(id_gen, 100))
数据管道处理
# 构建处理流水线
def read_data(source):
for item in source:
yield item
def filter_positive(numbers):
for num in numbers:
if num > 0:
yield num
def square(numbers):
for num in numbers:
yield num ** 2
# 链式处理
data = [1, -2, 3, -4, 5, -6, 7]
pipeline = square(filter_positive(read_data(data)))
print(list(pipeline)) # [1, 9, 25, 49]
异步编程
import asyncio
async def async_data_stream():
for i in range(10):
await asyncio.sleep(1)
yield i
async def main():
async for data in async_data_stream():
print(f"收到数据: {data}")
# asyncio.run(main())
什么时候使用生成器
应该使用生成器的场景
不适合使用生成器的场景
- 1. 需要随机访问：列表可以
[index]，生成器不行
决策树
开始
↓
数据量是否很大？
├─ 否 → 使用列表/普通循环
└─ 是 → 需要全部数据吗？
├─ 是 → 考虑内存，可能还是要用生成器
└─ 否 → 果断使用生成器
↓
需要控制暂停/继续？
├─ 是 → 使用生成器 + send()
└─ 否 → 普通生成器即可
性能对比测试
import memory_profiler
import time
# 列表方式
def list_version(n):
result = []
for i in range(n):
result.append(i ** 2)
return result
# 生成器方式
def generator_version(n):
for i in range(n):
yield i ** 2
# 测试1000万个数字
@memory_profiler.profile
def test_list():
data = list_version(10_000_000)
return sum(data)
@memory_profiler.profile
def test_generator():
data = generator_version(10_000_000)
return sum(data)
# 结果：列表占用约381MB内存，生成器占用约0.1MB内存
实用技巧
使用itertools增强生成器
import itertools
# 无限斐波那契数列
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 取前10个
first_10 = list(itertools.islice(fibonacci(), 10))
# 取小于1000的
less_than_1000 = list(itertools.takewhile(lambda x: x < 1000, fibonacci()))
生成器链式调用
# 管道操作符风格
def pipeline(data):
return (
data
|> (x for x in _ if x > 0) # 过滤正数
|> (x**2 for x in _) # 平方
|> (sum(_)) # 求和
)
# Python 3.8+ 的海象运算符也很有用
上下文管理器配合生成器
from contextlib import contextmanager
@contextmanager
def managed_resource():
print("获取资源")
resource = "some_resource"
try:
yield resource
finally:
print("释放资源")
# 使用
with managed_resource() as res:
print(f"使用{res}")
📌 思考题：如果要读取一个10GB的CSV文件并进行数据清洗，你会选择迭代器还是列表？为什么？
欢迎在评论区分享你的答案！
