Python:迭代器与生成器,一篇让你彻底搞懂

在Python学习过程中，迭代器和生成器这两个概念经常让初学者感到困惑。它们看起来相似，但又有着微妙的区别。今天，我们就用最通俗易懂的方式，把它们彻底讲清楚！

迭代器：像点读机一样的存在

什么是迭代器

想象你有一本永远不能翻回去的书，每次只能看下一页，这就是迭代器的本质。

# 迭代器就像这本书
book = BookIterator(["第1页", "第2页", "第3页"])

next(book)  # 得到 "第1页"
next(book)  # 得到 "第2页"  
next(book)  # 得到 "第3页"
next(book)  # 报错！书翻完了

迭代器的核心特征

1. 1. 惰性计算：一次只处理一个元素，不占用大量内存
2. 2. 单向流动：只能向前，不能后退
3. 3. 一次性：遍历完成后就失效了
4. 4. 节省内存：不需要把整个数据集加载到内存

判断是否为迭代器

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. 1. 处理大数据集：文件太大，内存装不下
2. 2. 流式处理：网络数据流、实时数据
3. 3. 无限序列：不知道什么时候结束
4. 4. 管道模式：链式数据处理
5. 5. 懒加载：不确定是否需要所有数据

不适合使用生成器的场景

1. 1. 需要随机访问：列表可以[index]，生成器不行
2. 2. 需要多次遍历：生成器只能用一次
3. 3. 数据量很小：列表更简单直观
4. 4. 需要获取长度：生成器没有len()

决策树

开始
  ↓
数据量是否很大？
  ├─ 否 → 使用列表/普通循环
  └─ 是 → 需要全部数据吗？
      ├─ 是 → 考虑内存，可能还是要用生成器
      └─ 否 → 果断使用生成器
          ↓
      需要控制暂停/继续？
          ├─ 是 → 使用生成器 + 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文件并进行数据清洗，你会选择迭代器还是列表？为什么？

欢迎在评论区分享你的答案！