25 python 迭代器与生成器

在办公室里，每个员工每天都要处理一堆任务：回复邮件、整理报表、参加会议...
Python 中的迭代器就像一个严格按顺序处理任务的员工，从第一个任务开始，直到所有任务完成，不会回头。

一、迭代器

迭代器是实现了__iter__()和__next__()方法的对象，遵循迭代器协议（Iterator Protocol）。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。

核心特点：

• 只能向前，不能后退（类似每天的工作日程表）
• 内存高效（处理一个任务释放一个任务的资源）

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
for x in it:
    print(x, end=" ")

tasks = ['回复客户邮件', '整理周报', '提交报销']
task_iterator = iter(tasks)  # 生成任务迭代器

print(next(task_iterator))  # 执行第一个任务：回复客户邮件
print(next(task_iterator))  # 执行第二个任务：整理周报
print(next(task_iterator))  # 执行第三个任务：提交报销

 二、生成器

办公室的打印机不会一次性打印所有文件，而是根据需求逐页输出。
Python 中的生成器就像智能打印机，按需生成数据，节省内存资源。

在 Python 中，使用了 yield 的函数被称为生成器（generator）。注意：生成器是一个而函数。
yield 是定义生成器函数的关键。当生成器函数执行到 yield 语句时，函数就会暂停执行，就好像工匠暂时放下手中的活，然后把 yield 后面的表达式作为当前迭代的值返回给你。当你再次要求获取下一个值时（比如调用生成器的 next() 方法，或者使用 for 循环进行迭代），函数会从上次暂停的地方接着干，直到又遇到 yield 语句，再次暂停并返回新的值。这样，生成器函数就能逐步产生值，而不用一次性把所有结果都计算出来。

def number_generator():
    num = 0
    while num < 5:
        yield num
        num = num + 1

# 调用生成器函数，返回一个迭代器对象
gen = number_generator()

# 使用 next() 方法获取生成器的下一个值
print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
print(next(gen))  # 输出: 3
print(next(gen))  # 输出: 4

# 如果再调用 next()，会抛出 StopIteration 异常，因为已经没有更多的值了
try:
    print(next(gen))
except StopIteration:
    print("已经没有更多的值了")

# 也可以使用 for 循环来迭代生成器
gen = number_generator()
for num in gen:
    print(num)

def generate_sales_data(days):
    for day in range(1, days+1):
        yield f"第{day}天销售额：{day * 1000}元"  # 逐天生成数据

sales_generator = generate_sales_data(30)

print(next(sales_generator))  # 查看第一天数据
print(next(sales_generator))  # 查看第二天数据
# 第1天销售额：1000元
# 第2天销售额：2000元

三、迭代器和生成器的区别

功能	迭代器	生成器
数据存储	一次性加载所有任务到内存	按需生成数据，不存储完整列表
内存占用	高（适合小规模数据）	低（适合大规模数据）
适用场景	固定流程的任务处理	动态生成或实时计算的数据

四、职场中的应用场景

4.1 周报生成系统

def weekly_report(days):
    for day in range(1, days+1):
        yield f"第{day}天：完成{day}项任务"

report = weekly_report(5)
for entry in report:
    print(entry)

4.2 客户名单处理

def process_clients(clients):
    for client in clients:
        yield f"处理客户：{client}（已发送跟进邮件）"

client_list = ['张三', '李四', '王五']
processing = process_clients(client_list)
print(next(processing))  # 处理张三
print(next(processing))  # 处理李四

五、实现自定义迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

_iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
# 1
# 2
# 3
# 4
# 5

假设你是项目经理，需要按顺序追踪每个项目的进度：

class ProjectTracker:
    def __init__(self, projects):
        self.projects = projects
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.projects):
            raise StopIteration  # 项目处理完毕
        project = self.projects[self.index]
        self.index += 1
        return f"项目{project}进度：{self.index}/{len(self.projects)}"

# 使用迭代器追踪项目
projects = ['A', 'B', 'C']
tracker = ProjectTracker(projects)
for status in tracker:
    print(status)
# 项目A进度：1/3
# 项目B进度：2/3
# 项目C进度：3/3

六、异常处理

确保迭代器遇到无效数据时优雅终止：

def safe_iterator(data):
    for item in data:
        if not item:
            continue  # 跳过空数据
        yield process_item(item)