阐述 `Iterator Protocol` 和 `Iterable Protocol` 的设计意图，以及如何自定义可迭代对象。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位听众，晚上好！今天咱们来聊聊Python里两个有点神秘，但其实非常重要的概念：Iterator Protocol 和 Iterable Protocol。别被这些高大上的名字吓着，说白了，它们就是Python处理循环的底层机制。学会了它们，你就能更好地理解Python的循环，甚至能创造出自己的可迭代对象，让你的代码更加优雅高效。

准备好了吗？系好安全带，咱们开始今天的“Python可迭代对象探险之旅”！

一、什么是Iterable Protocol？（可迭代协议）

首先，我们来聊聊 Iterable Protocol。你可以把它想象成一个“承诺书”。一个对象如果想“承诺”自己是可以被循环访问的（比如用 for 循环），它就必须遵守这个协议。

那这个协议具体是什么呢？其实很简单，它只有一个要求：

必须实现 __iter__() 方法。

这个 __iter__() 方法就像一个“发牌员”，它负责返回一个迭代器（Iterator）。迭代器才是真正干活的，负责一个一个地把元素吐出来。

简单来说，如果一个对象有 __iter__() 方法，那么Python就认为它是可迭代的（Iterable）。

class MyIterable:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        # 这里我们简单地返回一个列表的迭代器
        return iter(self.data)

# 创建一个 MyIterable 对象
my_iterable = MyIterable([1, 2, 3])

# 现在我们可以用 for 循环来遍历 my_iterable 了
for item in my_iterable:
    print(item)

这段代码展示了一个最简单的可迭代对象。 MyIterable 类实现了 __iter__() 方法，并返回了一个列表的迭代器。因此，我们可以用 for 循环来遍历 my_iterable 对象。

设计意图：

Iterable Protocol 的设计意图很明确，就是为了提供一个统一的接口，让Python能够识别哪些对象是可以被循环访问的。这样，Python就可以用统一的方式来处理各种不同的数据类型，比如列表、元组、字典等等。

二、什么是Iterator Protocol？（迭代器协议）

现在，我们再来看看 Iterator Protocol。既然 Iterable Protocol 是一个“承诺书”，那么 Iterator Protocol 就是一个“行动指南”。迭代器（Iterator）必须遵守这个协议，才能真正地把元素一个一个地吐出来。

这个协议有两个要求：

必须实现 __next__() 方法。 这个方法负责返回序列中的下一个元素。如果没有更多元素了，就必须抛出一个 StopIteration 异常。
必须实现 __iter__() 方法。 这个方法必须返回迭代器自身。 (是的，迭代器也是可迭代对象！)

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

    def __iter__(self):
        return self

# 创建一个 MyIterator 对象
my_iterator = MyIterator([4, 5, 6])

# 可以使用 next() 函数来获取下一个元素
print(next(my_iterator)) # 输出 4
print(next(my_iterator)) # 输出 5
print(next(my_iterator)) # 输出 6
# print(next(my_iterator)) # 抛出 StopIteration 异常

这个例子展示了一个最简单的迭代器。 MyIterator 类实现了 __next__() 方法，每次调用 next() 函数，它都会返回序列中的下一个元素。当没有更多元素时，它会抛出 StopIteration 异常。

设计意图：

Iterator Protocol 的设计意图是为了提供一个统一的方式来遍历序列中的元素。通过 __next__() 方法，我们可以一个一个地获取序列中的元素，而不需要一次性地把整个序列加载到内存中。这对于处理大型数据集非常有用，可以节省大量的内存空间。

三、Iterable和Iterator的关系

现在，我们来理清一下 Iterable 和 Iterator 之间的关系：

Iterable (可迭代对象): 可以被循环访问的对象。必须实现 __iter__() 方法，返回一个迭代器。
Iterator (迭代器): 负责一个一个地吐出元素的对象。必须实现 __next__() 方法和 __iter__() 方法。

Iterable 可以生成 Iterator，Iterator 可以迭代 Iterable 中的元素。

可以用一个比喻来理解它们的关系：

Iterable 就像一本书，它包含了所有的内容。
Iterator 就像一个书签，它记录了你当前读到的位置。你可以通过书签（Iterator）来一页一页地阅读这本书（Iterable）。

四、如何自定义可迭代对象？

现在，我们来学习如何自定义可迭代对象。掌握了这一点，你就可以创造出自己的数据结构，并让它们可以像列表、元组一样被循环访问。

要自定义可迭代对象，你需要做两件事情：

创建一个类，并实现 __iter__() 方法。 这个方法负责返回一个迭代器对象。
创建一个迭代器类，并实现 __next__() 方法和 __iter__() 方法。 __next__() 方法负责返回序列中的下一个元素， __iter__() 方法返回迭代器自身。

下面是一个更复杂的例子，我们创建一个可以生成斐波那契数列的可迭代对象：

class FibonacciIterator:
    def __init__(self, limit):
        self.limit = limit
        self.a = 0
        self.b = 1
        self.count = 0

    def __next__(self):
        if self.count < self.limit:
            result = self.a
            self.a, self.b = self.b, self.a + self.b
            self.count += 1
            return result
        else:
            raise StopIteration

    def __iter__(self):
        return self

class Fibonacci:
    def __init__(self, limit):
        self.limit = limit

    def __iter__(self):
        return FibonacciIterator(self.limit)

# 创建一个 Fibonacci 对象，生成前 10 个斐波那契数
fibonacci = Fibonacci(10)

# 用 for 循环来遍历 fibonacci 对象
for num in fibonacci:
    print(num)

在这个例子中，Fibonacci 类是一个可迭代对象，它实现了 __iter__() 方法，并返回一个 FibonacciIterator 对象。 FibonacciIterator 类是一个迭代器，它实现了 __next__() 方法，负责生成斐波那契数列中的下一个数。

五、使用yield简化代码

Python提供了一个更简洁的方式来创建迭代器，那就是使用yield关键字。 yield 关键字可以将一个函数变成一个生成器（Generator），而生成器本质上就是一个迭代器。

我们可以用 yield 关键字来简化上面的斐波那契数列的例子：

class Fibonacci:
    def __init__(self, limit):
        self.limit = limit

    def __iter__(self):
        a = 0
        b = 1
        count = 0
        while count < self.limit:
            yield a
            a, b = b, a + b
            count += 1

# 创建一个 Fibonacci 对象，生成前 10 个斐波那契数
fibonacci = Fibonacci(10)

# 用 for 循环来遍历 fibonacci 对象
for num in fibonacci:
    print(num)

在这个例子中，我们直接在 Fibonacci 类的 __iter__() 方法中使用 yield 关键字来生成斐波那契数列中的下一个数。这样，我们就不需要单独创建一个 FibonacciIterator 类了。

设计意图：

yield 关键字的设计意图是为了简化迭代器的创建过程。通过 yield 关键字，我们可以用更少的代码来实现迭代器的功能，从而提高代码的可读性和可维护性。

六、总结与表格对比

咱们今天学习了Python中的 Iterable Protocol 和 Iterator Protocol，以及如何自定义可迭代对象。下面用一个表格来总结一下它们的主要区别：

特性	Iterable (可迭代对象)	Iterator (迭代器)
必须实现的方法	`__iter__()`	`__next__()`, `__iter__()`
`__iter__()` 方法	返回一个迭代器	返回自身
功能	声明可以被迭代	实际执行迭代操作
内存占用	可能占用较多内存	内存占用通常较少
例子	列表、元组、字符串	文件对象、生成器

七、实际应用场景

掌握了 Iterable Protocol 和 Iterator Protocol，你可以在很多场景下应用它们：

处理大型数据集： 当你需要处理一个非常大的数据集时，一次性地将所有数据加载到内存中是不现实的。可以使用迭代器来逐个处理数据，从而节省内存空间。
创建自定义数据结构： 如果你需要创建一个自定义的数据结构，并且希望它可以像列表、元组一样被循环访问，那么你需要实现 Iterable Protocol 和 Iterator Protocol。
实现惰性计算： 惰性计算是指只有在需要的时候才计算结果。可以使用迭代器来实现惰性计算，从而提高程序的效率。

八、一些小技巧

使用 iter() 函数可以将一个可迭代对象转换成一个迭代器。
使用 next() 函数可以获取迭代器中的下一个元素。
可以使用 for 循环来遍历可迭代对象。
可以使用 in 运算符来判断一个元素是否在一个可迭代对象中。

九、进阶思考

Python的迭代器是单向的，也就是说，你只能从头到尾地遍历序列，而不能反向遍历。你可以尝试实现一个可以反向遍历的迭代器。
Python的迭代器是“一次性”的，也就是说，当你遍历完一个迭代器后，它就不能再被使用了。你可以尝试实现一个可以重复使用的迭代器。
你可以尝试将 Iterable Protocol 和 Iterator Protocol 应用到你自己的项目中，看看它们能带来哪些好处。

好了，今天的分享就到这里。希望大家通过今天的学习，能够对 Iterable Protocol 和 Iterator Protocol 有更深入的理解。记住，编程就像探险，只有不断地学习和实践，才能发现更多的乐趣！祝大家编程愉快！

发表回复 取消回复

发表回复取消回复