1. 生成器是什么？从迭代器说起
第一次听说Python生成器时，我正被一个内存问题困扰着。当时需要处理一个10GB的日志文件，尝试用列表一次性读取所有行后，我的16GB内存电脑直接卡死。同事轻描淡写地说："用生成器啊"，从此打开了我的新世界。
生成器本质上是一种特殊的迭代器，但它的实现方式更为优雅。想象你在一家无限量供应的自助餐厅，传统做法是把所有食物一次性堆满你的盘子（列表），而生成器则是服务员按需上菜——你需要一道，他现做一道。
python复制# 传统列表方式
def get_numbers(n):
result = []
for i in range(n):
result.append(i)
return result # 一次性返回所有结果
# 生成器方式
def generate_numbers(n):
for i in range(n):
yield i # 每次只生成一个
关键区别在于内存使用。当n=1,000,000时，列表版本会立即占用约8MB内存，而生成器几乎不占额外内存。我在处理大型CSV文件时实测过：用生成器替代列表后，内存占用从2GB降到了不足50MB。
2. 生成器的两种创建方式
2.1 生成器函数：yield的魔法
生成器函数是定义生成器最常见的方式。当函数中包含yield语句时，它就自动变成了生成器函数。第一次看到yield时，我误以为它和return差不多——这个误解让我调试了整整一下午。
python复制def countdown(num):
print("Starting countdown!")
while num > 0:
yield num
num -= 1
# 使用示例
cd = countdown(3)
print(next(cd)) # 输出: Starting countdown! 然后 3
print(next(cd)) # 输出 2
print(next(cd)) # 输出 1
print(next(cd)) # 抛出StopIteration异常
yield的神奇之处在于函数执行状态的保存。每次调用next()，函数从上次暂停的yield处继续执行，所有局部变量都保持原样。这特性在处理流式数据时特别有用，比如我最近写的实时日志分析工具就重度依赖这种状态保持能力。
2.2 生成器表达式：列表推导式的懒加载版本
如果你熟悉列表推导式，生成器表达式就是它的内存友好版。只需把方括号换成圆括号：
python复制# 列表推导式
squares_list = [x**2 for x in range(1000000)] # 立即计算，占用大量内存
# 生成器表达式
squares_gen = (x**2 for x in range(1000000)) # 按需计算，几乎不占内存
我在数据分析项目中做过对比：处理1千万条数据时，列表推导式用了800MB内存，而生成器表达式只用了不到1MB。不过要注意：生成器只能迭代一次，如果需要重复使用，要么重新创建生成器，要么转换为列表（这就失去了内存优势）。
3. 为什么需要生成器？三大核心优势
3.1 内存效率：大数据处理的救星
上周我优化了一个图像处理脚本，原版本用列表存储所有图片数据，处理500张高清图就内存爆炸。改用生成器后，同一台机器能处理5000+张图。原理很简单——生成器不需要预加载所有数据，而是：
- 每次只处理当前需要的元素
- 处理完后立即释放内存
- 自动维护迭代状态
这对于网络爬虫、大型文件处理等场景简直是神器。我常用的一个模式是：
python复制def read_large_file(file_path):
with open(file_path, 'r') as f:
for line in f: # 文件对象本身就是生成器！
yield line.strip()
# 使用示例
for line in read_large_file('huge_log.txt'):
process(line) # 每次只处理一行
3.2 延迟计算：无限序列与实时处理
生成器能表示无限序列，这是列表绝对做不到的。比如这个无限斐波那契数列生成器：
python复制def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 使用示例
fib = fibonacci()
print(next(fib)) # 0
print(next(fib)) # 1
print(next(fib)) # 1
print(next(fib)) # 2
# 可以一直next下去...
在实时数据监控系统中，我用类似原理实现了滑动窗口计算——生成器持续产出最新统计指标，而不用担心内存增长。
3.3 管道处理：串联多个生成器
生成器可以像Unix管道一样串联，形成高效的数据处理流水线。这是我处理日志的典型流程：
python复制def read_logs(file_path):
with open(file_path) as f:
for line in f:
yield line.strip()
def filter_errors(logs):
for log in logs:
if 'ERROR' in log:
yield log
def extract_timestamps(error_logs):
for log in error_logs:
yield log.split(' ')[0]
# 构建处理管道
pipeline = extract_timestamps(filter_errors(read_logs('app.log')))
# 执行管道
for timestamp in pipeline:
print(timestamp)
这种组合方式不仅代码清晰，而且因为每个生成器只处理单个元素，内存占用始终很低。我曾用类似结构处理过日均10GB的日志数据，服务器内存使用量从未超过100MB。
4. 生成器进阶技巧与坑点
4.1 send()方法：双向通信
大多数人只知道用next()获取生成器的值，其实生成器还支持用send()发送数据：
python复制def accumulator():
total = 0
while True:
value = yield total
if value is None:
break
total += value
acc = accumulator()
next(acc) # 启动生成器，输出0
print(acc.send(10)) # 输出10
print(acc.send(20)) # 输出30
acc.close() # 关闭生成器
这个特性在协程和异步编程中特别有用。我在一个消息处理系统中用这种方式实现了生产-消费模式，生成器既接收消息又返回处理结果。
4.2 yield from：生成器委托
Python 3.3引入的yield from语法可以简化嵌套生成器：
python复制def chain(*iterables):
for it in iterables:
yield from it # 相当于 for i in it: yield i
# 等效于
def chain_the_hard_way(*iterables):
for it in iterables:
for i in it:
yield i
yield from不只是语法糖，它还能建立调用者和子生成器的直接通道，这在异步编程中至关重要。我重构过一个旧项目，用yield from替代多层yield后，代码行数减少了40%。
4.3 常见坑点与解决方案
-
生成器只能迭代一次：
python复制gen = (x for x in range(3)) list(gen) # [0, 1, 2] list(gen) # [] 第二次就是空的！解决方案：要么重新创建生成器，要么使用itertools.tee复制生成器
-
过早耗尽生成器：
python复制def get_numbers(): yield 1 yield 2 yield 3 nums = get_numbers() print(sum(nums)) # 6 print(max(nums)) # 报错：生成器已耗尽解决方案：如果需要多次使用，考虑转换为列表或使用itertools.tee
-
忘记启动生成器：
python复制def my_generator(): print("Starting") yield 1 gen = my_generator() # 不会有输出 next(gen) # 输出"Starting"，返回1这是新手常犯的错误，我也不例外。生成器函数在调用时只是返回生成器对象，不会执行任何代码，直到第一次调用next()
5. 生成器在实际项目中的应用案例
5.1 大数据文件处理
上周我优化了一个CSV处理脚本，原版本：
python复制def process_csv(file_path):
with open(file_path) as f:
data = list(csv.reader(f)) # 一次性加载所有数据
results = []
for row in data:
results.append(transform(row))
return results
当处理500MB的CSV时，内存峰值达到1.2GB。改进后的生成器版本：
python复制def process_csv_gen(file_path):
with open(file_path) as f:
reader = csv.reader(f) # reader本身就是生成器
for row in reader:
yield transform(row)
# 使用方式
for result in process_csv_gen('huge.csv'):
save_to_db(result) # 逐行处理
内存使用始终保持在50MB以下，处理速度还快了20%，因为不需要等待所有数据加载完毕。
5.2 流式API数据处理
在处理Twitter流API时，生成器表现出色：
python复制def get_tweets_stream(keywords):
while True:
try:
tweets = api.get_stream(keywords) # 返回最新推文
for tweet in tweets:
yield process_tweet(tweet)
except ConnectionError:
time.sleep(5)
continue
# 使用示例
for tweet in get_tweets_stream(['Python', 'AI']):
update_dashboard(tweet)
这个生成器会无限运行，自动处理连接中断，并保持处理状态。在我的舆情监控系统中，这种模式已经稳定运行了6个月。
5.3 性能敏感场景的优化
在图像处理管道中，我对比过两种实现：
python复制# 传统方式
def process_images(image_paths):
images = [load_image(p) for p in image_paths]
processed = [transform(img) for img in images]
return [save(img) for img in processed]
# 生成器方式
def process_images_gen(image_paths):
for path in image_paths:
img = load_image(path)
transformed = transform(img)
yield save(transformed)
测试结果（处理1000张图）：
- 内存占用：列表版1.2GB → 生成器版80MB
- 响应时间：首张图处理时间从15秒降至0.5秒
- 总耗时：基本相同
生成器版本的最大优势是能立即开始输出结果，而不是等所有图片都加载完。这对需要快速响应的Web应用至关重要。
6. 生成器与协程：异步编程基础
虽然现代Python有async/await，但理解生成器对掌握协程至关重要。实际上，asyncio的早期版本就是用生成器实现的。来看这个简单的协程示例：
python复制def simple_coroutine():
print("-> coroutine started")
x = yield
print("-> coroutine received:", x)
coro = simple_coroutine()
next(coro) # 启动协程，输出"-> coroutine started"
coro.send(42) # 发送值，输出"-> coroutine received: 42"
这种"暂停-恢复"的能力正是异步编程的核心。我在教学时发现，先掌握生成器再学asyncio的学生，对事件循环的理解要深刻得多。
生成器还能用来实现简单的任务调度：
python复制def task(name, n):
for i in range(n):
print(f"{name} executing")
yield
# 简单调度器
def scheduler(tasks):
while tasks:
task = tasks.pop(0)
try:
next(task)
tasks.append(task)
except StopIteration:
pass
# 创建任务
tasks = [task("A", 3), task("B", 5)]
scheduler(tasks)
虽然简陋，但这正是操作系统任务调度的基本原理。理解这点后，再学习gevent或asyncio就会豁然开朗。