Python迭代器(Iterator)vs生成器(Generator)使用及说明

目录

• 核心概念：可迭代对象 (Iterable)
• 一、什么是迭代器 (Iterator)？
• 1.1 “经典”迭代器：通过类实现
• 二、什么是生成器 (Generator)？
• 2.1 生成器函数：使用yield
• 三、关系与区别总结
• 关系
• 关键区别
• 四、何时使用？
• 五、一个重要问题：当yield在类的方法中时
• 特殊情况：当生成器是__iter__方法
• 六、总结

本文档旨在详细解释 Python 中迭代器和生成器的概念、它们之间的关系以及关键区别。

在深入了解迭代器之前，首先要明白什么是可迭代对象 (Iterable)。

简单来说，任何可以被 for 循环遍历的对象都是可迭代对象。例如，列表、元组、字典、集合、字符串等。从技术上讲，一个对象是可迭代的，如果它实现了 __iter__() 方法。

迭代器是一个表示数据流的对象。它实现了 Python 的迭代器协议，该协议要求对象必须实现以下两个方法：

1. __iter__(): 返回迭代器对象自身。这使得迭代器可以被用在 for 和 in 语句中。
2. __next__(): 返回数据流中的下一个元素。当没有更多元素时，它必须抛出 StopIteration 异常。

迭代器是惰性 (lazy) 的，它只在被请求时才计算并返回下一个值，这使得它在处理大数据集时非常节省内存。

这是创建迭代器的“手动”或“经典”方式。你需要自己编写一个类来管理迭代的状态。

示例：一个从 1 数到指定数字的计数器。

class Counter:
    """一个经典的迭代器类"""
    def __init__(self, max_num):
        self.max_num = max_num
        self.current = 0

    def __iter__(self):
        # 迭代器应该返回它自己
        return self

    def __next__(self):
        # 定义获取下一个元素的逻辑
        if self.current < self.max_num:
            self.current += 1
            return self.current
        else:
            # 当没有更多元素时，抛出 StopIteration
            raise StopIteration

# --- 如何使用 ---
my_counter = Counter(3)

# for 循环在幕后会自动调用 __iter__() 和 __next__()
for number in my_counter:
    print(number)

# 输出:
# 1
# 2
# 3

在这种模式下，我们必须手动管理状态（self.current）并显式地抛出 StopIteration 异常。

生成器是一种特殊的、更简洁的创建迭代器的方式。

您不需要编写一个完整的类。相反，您只需编写一个包含 yield 关键字的函数。Python 会自动为您处理好迭代器协议的所有细节。

当您在一个函数中使用了 yield，这个函数就不再是一个普通函数，而是一个生成器函数。调用它会返回一个生成器对象，而这个生成器对象就是一个功能完备的迭代器。

示例：使用生成器实现相同的计数器。

def counter_generator(max_num):
    """一个生成器函数"""
    current = 0
    while current < max_num:
        current += 1
        # 'yield' 产出值并暂停函数执行
        yield current

# --- 如何使用 ---
my_generator = counter_generator(3)

# my_generator 是一个生成器对象，也是一个迭代器
for number in my_generator:
    print(number)

# 输出:
# 1
# 2
# 3

yield 的魔力：

• 产出值: yield 会返回一个值给调用者，就像 return 一样。
• 暂停执行: 与 return 不同，yield 会“冻结”函数的当前状态（包括所有局部变量），然后暂停执行。
• 恢复执行: 当下一次调用生成器的 __next__() 方法时，函数会从上次暂停的地方恢复执行，直到遇到下一个 yield 或函数结束。
• 自动处理 StopIteration: 当生成器函数执行完毕（例如循环结束或遇到 return），Python 会自动在背后为您抛出 StopIteration 异常。

所有生成器都是迭代器，但并非所有迭代器都是生成器。

生成器是实现迭代器协议的一种语法糖 (syntactic sugar)。它是一种高级工具，可以让你用更少的代码、更清晰的逻辑来创建迭代器。

特性	经典迭代器 (Class)	生成器 (Generator)
实现方式	编写一个完整的类，实现 __iter__ 和 __next__ 方法。	编写一个包含 yield 关键字的函数。
代码量	更冗长，结构更复杂。	非常简洁，易于阅读。
状态管理	手动。需要使用实例变量（如 self.current）来保存状态。	自动。Python 自动保存函数的整个执行上下文（局部变量、执行位置等）。
StopIteration	手动。必须在 __next__ 方法中显式 raise StopIteration。	自动。当函数执行结束时，Python 自动抛出。
灵活性	更灵活。可以在类中添加其他方法，使其不仅仅是一个迭代器。	主要用于创建迭代过程本身。

• 优先使用生成器: 在绝大多数情况下，当您需要创建一个迭代器时，生成器都是首选。它更简单、更快速、更 Pythonic。
• 使用经典迭代器类: 当您的迭代逻辑非常复杂，或者您希望将迭代逻辑封装在一个具有其他方法和属性的更丰富的对象中时，自定义迭代器类可能是更好的选择。

这是一个常见的困惑点：如果一个类的方法里包含了 yield，那么是这个类变成了生成器，还是这个方法变成了生成器？

答案是：方法是生成器，而不是类。

当一个类的方法中包含 yield 关键字时，这个方法就变成了一个生成器函数。这个类本身仍然是一个普通的类，它的实例也仍然是一个普通的对象。

示例：

class MyData:
    def __init__(self, name):
        self.name = name
        print(f"'{self.name}' 实例被创建，它是一个普通的对象。")

    def get_name(self):
        # 这是一个普通的方法
        return self.name

    def create_number_generator(self):
        # 这是一个生成器函数（因为它包含 yield）
        print(f"'{self.name}' 的生成器函数被调用，即将返回一个生成器对象...")
        for i in range(1, 4):
            yield i

# --- 使用 ---
my_data_object = MyData("数据包")

# 调用生成器方法，返回一个生成器对象（它是一个迭代器）
generator_iterator = my_data_object.create_number_generator()

print(f"my_data_object 的类型是: {type(my_data_object)}")
print(f"generator_iterator 的类型是: {type(generator_iterator)}")

# 现在，我们可以遍历这个“生成器对象”
print("开始遍历生成器...")
for number in generator_iterator:
    print(f"  从生成器中拿到了: {number}")

输出分析：

'数据包' 实例被创建，它是一个普通的对象。
'数据包' 的生成器函数被调用，即将返回一个生成器对象...
my_data_object 的类型是: <class '__main__.MyData'>
generator_iterator 的类型是: <class 'generator'>
开始遍历生成器...
  从生成器中拿到了: 1
  从生成器中拿到了: 2
  从生成器中拿到了: 3

关键点：

1. my_data_object 的类型始终是 <class '__main__.MyData'>。这个类实例本身并不是一个生成器。
2. generator_iterator 的类型是 <class 'generator'>。这个生成器对象是由调用 create_number_generator() 方法创建的。
3. 您不能直接 for num in my_data_object:，因为 MyData 类没有实现 __iter__ 方法。

现在，让我们把这个概念与 __iter__ 这个特殊方法联系起来。

如果一个类恰好将包含 yield 的逻辑放在了 __iter__ 方法中，那么这个类的实例就变得可迭代 (iterable) 了。

class IterableData:
    def __iter__(self):
        # 因为 __iter__ 方法包含了 yield，
        # 调用它会返回一个生成器对象。
        # for 循环会自动调用这个方法来获取迭代器。
        print("IterableData 的 __iter__ 被调用了！")
        for i in range(1, 4):
            yield i

# --- 使用 ---
iterable_object = IterableData()

# 现在可以直接遍历这个对象了！
for number in iterable_object:
    print(f"  从 iterable_object 中拿到了: {number}")

这是因为 for 循环的协议就是去调用对象的 __iter__ 方法来获取一个迭代器。在这种情况下，__iter__ 方法恰好返回了一个生成器（它本身就是一种完美的迭代器），所以一切都能顺利工作。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持风君子博客。

您可能感兴趣的文章:

• python迭代器和生成器的区别解析
• Python 的with语句及其与迭代器的交互详解(最新整理)
• 一文详解Python中的可迭代对象与迭代器
• 从基础到高级详解Python迭代器手动访问完全指南
• Python可迭代对象、迭代器与生成器实现示例详解
• Python迭代器和生成器之迭代器协议详解
• Python 迭代器和生成器概念及场景分析