Python3 迭代器与生成器详解：从入门到实践

在Python编程中，迭代器和生成器是处理数据序列的"隐形引擎"。它们像智能指针一样，能按需逐个访问数据，却不会一次性加载所有内容到内存。这种"用多少取多少"的特性，让它们成为处理大数据、实现复杂逻辑的利器。本文将用通俗易懂的方式，结合真实场景，带你看透这两个工具的核心原理与实战技巧。

一、迭代器：数据遍历的"智能指针"

1.1 迭代器的本质

迭代器是一个能记住遍历位置的对象。就像翻书时用手指跟踪当前页，迭代器会记住自己"停"在集合的哪个元素上。每次调用next()时，它移动到下一个元素，直到翻完最后一页（抛出StopIteration异常）。

示例：遍历列表的底层逻辑

python 复制代码

my_list = [1, 2, 3]
list_iter = iter(my_list)  # 将列表转为迭代器
print(next(list_iter))  # 输出1
print(next(list_iter))  # 输出2
print(next(list_iter))  # 输出3
print(next(list_iter))  # 抛出StopIteration异常

这段代码揭示了for循环的底层机制：Python先调用iter()获取迭代器，再反复调用next()直到异常终止。

1.2 自定义迭代器的实现

要实现一个迭代器，需定义一个类并实现两个魔法方法：

iter()：返回迭代器自身（通常是return self）
next()：返回下一个元素，无元素时抛出StopIteration

案例：生成平方数序列

python 复制代码

class Squares:
    def __init__(self, max_n):
        self.max_n = max_n  # 最大迭代次数
        self.current = 0      # 当前迭代位置
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if self.current >= self.max_n:
            raise StopIteration
        value = self.current ** 2
        self.current += 1
        return value
 
# 使用示例
squares = Squares(5)
for num in squares:
    print(num)  # 输出: 0, 1, 4, 9, 16

这个迭代器会按需生成平方数，内存中始终只保存当前状态。

1.3 迭代器的核心优势

惰性计算：只在需要时生成值，适合处理无法一次性加载的大数据（如1GB日志文件）。

封装复杂逻辑：可自定义遍历规则，例如：

树形结构的深度优先遍历
跳过特定条件的元素
生成无限序列（如斐波那契数列）

案例：无限斐波那契数列

python 复制代码

class Fibonacci:
    def __init__(self):
        self.a, self.b = 0, 1  # 初始两个数
 
    def __iter__(self):
        return self
 
    def __next__(self):
        result = self.a
        self.a, self.b = self.b, self.a + self.b
        return result
 
# 使用示例（需手动控制终止条件）
fib = Fibonacci()
for _ in range(10):
    print(next(fib))  # 输出前10项: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

二、生成器：迭代器的"语法糖"

2.1 生成器的本质

生成器是简化版的迭代器，通过yield关键字自动实现迭代协议。它像一条"数据生产线"，每次next()调用时生产一个值，然后暂停，直到下次被唤醒。

对比迭代器与生成器

特性	迭代器	生成器
实现方式	手动定义`__iter__`和`__next__`	使用`yield`关键字
状态管理	需手动维护	自动保存局部变量和执行位置
代码复杂度	高（需处理边界条件）	低（一行代码实现复杂逻辑）

2.2 生成器的三种实现方式

方式1：生成器函数

python 复制代码

def fibonacci():
    a, b = 0, 1
    while True:
        yield a  # 暂停并返回值
        a, b = b, a + b  # 更新状态
 
# 使用示例
gen = fibonacci()
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 1

方式2：生成器表达式

类似列表推导式，但用圆括号()代替方括号[]：

python 复制代码

# 生成0-4的平方数生成器
squares_gen = (x**2 for x in range(5))
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

方式3：高级特性（send()/throw()/close()）

生成器支持与外部交互：

python 复制代码

def receiver():
    while True:
        item = yield  # 接收外部发送的值
        print(f"收到: {item}")
 
r = receiver()
next(r)  # 启动生成器
r.send("消息1")  # 输出: 收到: 消息1
r.send("消息2")  # 输出: 收到: 消息2
r.throw(ValueError("错误"))  # 向生成器抛出异常
r.close()  # 终止生成器

2.3 生成器的核心优势

内存效率：逐个生成值，不占用额外空间。例如处理1GB日志文件时，生成器每次只读取一行。
代码简洁：用yield替代复杂的状态管理逻辑。
支持无限序列：如自然数、素数等无法预先计算的序列。

案例：逐行处理大文件

python 复制代码

def read_large_file(file_path):
    with open(file_path, 'r') as f:
        for line in f:  # 文件对象本身就是迭代器
            yield line.strip().split(',')  # 返回处理后的行数据
 
# 使用示例
csv_reader = read_large_file('huge_data.csv')
for row in csv_reader:
    process_row(row)  # 每次处理一行，内存占用恒定

三、迭代器与生成器的实战场景

3.1 大数据处理：内存优化利器

场景：处理100万条用户数据的CSV文件。

错误方式（列表推导式）：

ini 复制代码

# 一次性加载所有数据到内存
all_users = [line.strip().split(',') for line in open('users.csv')]  # 内存爆炸！

正确方式（生成器）：

python 复制代码

def load_users(file_path):
    with open(file_path) as f:
        for line in f:
            yield line.strip().split(',')
 
# 按需处理数据
user_gen = load_users('users.csv')
for user in user_gen:
    if user[2] == 'VIP':  # 筛选VIP用户
        send_promotion(user)

3.2 自定义数据流：实现复杂逻辑

场景：生成符合特定规则的密码（8位，包含大小写字母和数字）。

生成器实现：

lua 复制代码

import random
import string
 
def password_generator(length=8):
    while True:
        chars = [
            random.choice(string.ascii_lowercase),
            random.choice(string.ascii_uppercase),
            random.choice(string.digits)
        ]
        # 补充剩余长度
        chars.extend(random.choice(string.ascii_letters + string.digits) 
                    for _ in range(length - 3))
        random.shuffle(chars)
        yield ''.join(chars)
 
# 使用示例
gen = password_generator()
print(next(gen))  # 输出类似: "aB3xY7pQ"
print(next(gen))  # 输出类似: "K9mN2zL8"

3.3 流水线处理：组合多个生成器

场景：从日志文件中提取IP地址，统计访问频率。

实现：

python 复制代码

def extract_ips(file_path):
    with open(file_path) as f:
        for line in f:
            if 'GET' in line:  # 简单过滤
                parts = line.split()
                yield parts[0]  # 假设IP在第一列
 
def count_ips(ip_gen):
    ip_count = {}
    for ip in ip_gen:
        ip_count[ip] = ip_count.get(ip, 0) + 1
    return ip_count
 
# 组合使用
ips = extract_ips('access.log')
result = count_ips(ips)
print(result)  # 输出: {'192.168.1.1': 10, '10.0.0.2': 5...}

四、常见问题与避坑指南

4.1 生成器只能遍历一次

scss 复制代码

gen = (x for x in range(3))
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [] （已耗尽）

解决方案：重新创建生成器或转换为列表（若数据量可接受）。

4.2 迭代器与可迭代对象的区别

可迭代对象：实现了__iter__()方法的对象（如列表、字典）。
迭代器：实现了__iter__()和__next__()方法的对象。

验证方法：

python 复制代码

from collections.abc import Iterable, Iterator
 
print(isinstance([], Iterable))   # True
print(isinstance([], Iterator))    # False
print(isinstance(iter([]), Iterator))  # True

4.3 生成器中的异常处理

生成器内部可通过try/except捕获异常：

python 复制代码

def safe_divide():
    while True:
        try:
            x = yield
            y = yield
            yield x / y
        except ZeroDivisionError:
            yield "错误：除数不能为零"
 
gen = safe_divide()
next(gen)  # 启动生成器
gen.send(10)
gen.send(2)
print(gen.send(0))  # 输出: "错误：除数不能为零"

五、总结：如何选择迭代器或生成器？

场景	推荐工具	理由
处理大数据文件	生成器	内存占用低，逐行处理
实现复杂遍历逻辑	自定义迭代器	可精细控制状态和边界条件
需要与外部交互	生成器（`send`）	支持双向数据传递
快速实现简单序列	生成器表达式	代码简洁，可读性强

迭代器和生成器是Python中"用空间换时间"的经典实践。它们通过延迟计算，让程序能以优雅的方式处理海量数据。无论是读取大文件、实现自定义数据流，还是构建复杂的数据处理管道，掌握这两个工具都能让你的代码更高效、更Pythonic。