python中怎么实现一个迭代器？-Python教程-PHP中文网

在Python中实现迭代器需定义__iter__和__next__方法，前者返回self，后者返回下一个元素并在结束时抛出StopIteration异常。

python中怎么实现一个迭代器？

在Python中实现一个迭代器，核心在于创建一个类，并为它定义两个特殊方法：

__iter__

登录后复制

和

__next__

登录后复制

。

__iter__

登录后复制

方法需要返回迭代器对象本身（通常是

self

登录后复制

），而

__next__

登录后复制

方法则负责返回序列中的下一个元素。当没有更多元素可供返回时，

__next__

登录后复制

必须抛出

StopIteration

登录后复制

异常，以此来通知循环机制迭代已经结束。

解决方案

要实现一个迭代器，你通常会创建一个类，然后在这个类里把迭代逻辑封装起来。这听起来可能有点抽象，但实际上，它给予了你极大的灵活性去定义数据如何被“遍历”。我个人觉得，这种模式最棒的地方在于，它把“如何获取下一个数据”的细节完全隐藏在了

__next__

登录后复制

里面，外部调用者根本不需要关心。

我们来设想一个简单的场景：我想创建一个能够迭代指定范围内的偶数的迭代器。普通的

range()

登录后复制

函数可做不到只给偶数，而且我也不想每次都写一个列表推导式。

class EvenNumbersIterator:
    def __init__(self, start, end):
        # 确保起始值是偶数，如果不是，就从下一个偶数开始
        self._current = start if start % 2 == 0 else start + 1
        self._end = end

    def __iter__(self):
        # 迭代器协议要求__iter__返回迭代器自身
        return self

    def __next__(self):
        # 如果当前值超出了结束范围，就停止迭代
        if self._current > self._end:
            raise StopIteration

        # 保存当前值，然后准备下一个偶数
        value = self._current
        self._current += 2
        return value

# 怎么用呢？
# for num in EvenNumbersIterator(0, 10):
#     print(num)
# 输出：0, 2, 4, 6, 8, 10

# 也可以手动调用next()
# evens = EvenNumbersIterator(1, 7)
# print(next(evens)) # 2
# print(next(evens)) # 4
# print(next(evens)) # 6
# print(next(evens)) # StopIteration

登录后复制

你看，这个

EvenNumbersIterator

登录后复制

类就是我们自定义的迭代器。

__init__

登录后复制

初始化了起始和结束状态，

__iter__

登录后复制

遵循协议返回

self

登录后复制

，而

__next__

登录后复制

则负责计算并返回下一个偶数，并在达到边界时优雅地抛出

StopIteration

登录后复制

。这种模式让我觉得，就像在给Python的

for

登录后复制

循环机制“喂食”，每次都只给它它需要的那一份，不多不少。

立即学习“Python免费学习笔记（深入）”；

为什么我们需要自定义迭代器，而不是直接使用列表或生成器？

这个问题问得好，因为它触及了迭代器存在的根本价值。我们确实可以把所有数据都塞进一个列表，然后遍历它。或者用生成器表达式写一个简单的

(x for x in range(10) if x % 2 == 0)

登录后复制

。那么，自定义迭代器的优势到底在哪？

首先，内存效率是自定义迭代器的一个显著优点，尤其是在处理大规模数据集或无限序列时。列表会一次性将所有元素加载到内存中，如果数据量巨大，这可能导致内存溢出。而迭代器，正如其名，是“按需”生成数据的，每次只在

__next__

登录后复制

被调用时才计算并返回一个元素。这意味着它只需要存储当前的状态信息，而不是整个数据集。想象一下，如果你要处理一个从文件流中读取的、可能无限大的数据序列，或者一个数学上无限的数列（比如所有质数），列表就完全无能为力了，但迭代器却能轻松应对。

其次，控制力。自定义迭代器允许你对迭代逻辑拥有完全的控制权。你可以定义复杂的逻辑来决定下一个元素是什么，或者在迭代过程中执行一些副作用（虽然通常不推荐在

__next__

登录后复制

中做太多有副作用的事情）。当你的迭代规则不那么直观，或者需要维护一些复杂的内部状态时，一个自定义的迭代器类就比简单的生成器函数或列表推导式更具表现力。比如，你想实现一个二叉树的深度优先遍历迭代器，或者一个自定义的数据结构（如链表）的遍历，这些场景下，自定义迭代器能让你更好地封装其内部结构和遍历算法。

最后，代码组织与重用。当迭代逻辑变得复杂，或者需要在多个地方复用时，将其封装在一个独立的类中，可以提高代码的可读性和可维护性。一个清晰定义的迭代器类，可以像其他任何对象一样被实例化和使用，这符合面向对象的设计原则，使得代码结构更清晰。

迭代器与生成器有何不同，何时选择使用它们？

这是一个很常见的疑问，也常常让人感到困惑。简单来说，生成器（Generator）是迭代器（Iterator）的一种特殊且更简洁的实现方式。所有的生成器都是迭代器，但不是所有的迭代器都是生成器。

生成器通常通过两种方式创建：

生成器函数 (Generator Function)：包含
```
yield
```
登录后复制
关键字的函数。每当
```
yield
```
登录后复制
语句被执行时，函数就会“暂停”并返回一个值，同时保存其内部状态。当下次调用
```
next()
```
登录后复制
时，函数会从上次暂停的地方继续执行。
生成器表达式 (Generator Expression)：类似于列表推导式，但使用圆括号而非方括号，它不会立即构建整个列表，而是返回一个生成器对象。

# 生成器函数示例
def even_numbers_generator(start, end):
    current = start if start % 2 == 0 else start + 1
    while current <= end:
        yield current
        current += 2

# 使用生成器
# for num in even_numbers_generator(0, 10):
#     print(num)

# 生成器表达式示例
# evens_gen_exp = (x for x in range(11) if x % 2 == 0)
# for num in evens_gen_exp:
#     print(num)

登录后复制

那么，何时选择哪一个呢？

一键职达

AI全自动批量代投简历软件，自动浏览招聘网站从海量职位中用AI匹配职位并完成投递的全自动操作，真正实现'一键职达'的便捷体验。

查看详情

选择生成器：

简单、一次性的迭代逻辑：当你的迭代逻辑比较直接，不需要复杂的内部状态管理，或者只是为了节省内存而延迟计算时，生成器函数或生成器表达式是首选。它们写起来更简洁，代码量少，易于理解。
快速实现：如果你需要一个迭代器，但又不想写一个完整的类，生成器提供了一种“即用即走”的便利。
函数式编程风格：生成器函数在某种程度上更符合函数式编程的理念，通过
```
yield
```
登录后复制
实现数据的流式处理。

选择自定义迭代器类：

复杂的内部状态管理：当你的迭代器需要维护多个变量来跟踪其内部状态，或者这些状态需要在迭代过程中以复杂的方式更新时，一个类可以更好地封装这些状态变量。
继承与多态：如果你的迭代器需要与其他类进行交互，或者你需要通过继承来扩展或修改迭代行为，那么自定义迭代器类提供了面向对象的灵活性。
实现特定协议或接口：某些情况下，你可能需要实现除了
```
__iter__
```
登录后复制
和
```
__next__
```
登录后复制
之外的其他特殊方法，或者你的迭代器是某个更大对象的一部分，并且需要更紧密的集成。
性能敏感的场景：虽然生成器通常已经足够高效，但在极少数情况下，为了极致的性能优化，直接控制迭代器的实现细节可能更有优势（尽管这通常不是主要原因）。

总而言之，生成器是实现迭代器的一种“语法糖”，它让简单的迭代器实现变得非常方便。而自定义迭代器类则提供了更强大的封装能力和更细粒度的控制，适用于更复杂、更结构化的场景。我个人在使用时，会先考虑生成器，如果发现逻辑变得有点绕，或者需要维护的上下文多了，才会退回到自定义类。

在实现迭代器时，可能遇到哪些常见的陷阱或性能考量？

在构建自己的迭代器时，有些地方确实容易踩坑，或者需要注意性能问题。我自己在写的时候就遇到过一些，总结下来，主要有这么几点：

首先，

StopIteration

登录后复制

异常的处理。这是迭代器协议的核心，但有时候会忘记在适当的时候抛出它，或者抛出的时机不对。如果你的

__next__

登录后复制

方法在没有更多元素时没有抛出

StopIteration

登录后复制

，那么使用

for

登录后复制

循环遍历它时就会进入无限循环，这显然不是我们想要的。反之，如果过早地抛出，又会导致数据不完整。所以，精确地判断迭代结束条件至关重要。

其次，状态管理混乱。自定义迭代器的一个主要优势就是能管理内部状态。但如果这些状态变量没有被妥善地初始化、更新，或者被意外地修改，那么迭代器的行为就会变得不可预测。比如，如果你在

__iter__

登录后复制

中没有返回

self

登录后复制

，而是创建了一个新的迭代器实例，那么每次

iter()

登录后复制

调用都会得到一个新的迭代器，而不是从上次停止的地方继续。这在某些场景下可能会导致意想不到的行为，比如在一个循环中尝试对同一个迭代器对象多次调用

iter()

登录后复制

。

# 错误的__iter__实现示例
class BadIterator:
    def __init__(self, limit):
        self._count = 0
        self._limit = limit

    def __iter__(self):
        # 错误：每次都返回一个新的迭代器，而不是self
        return BadIterator(self._limit) 

    def __next__(self):
        if self._count >= self._limit:
            raise StopIteration
        self._count += 1
        return self._count - 1

# 使用时会出问题：
# it = BadIterator(3)
# for x in it:
#     print(x) # 0, 1, 2
# for y in it: # 再次遍历时，会从头开始，而不是接着上次的
#     print(y) # 0, 1, 2
# 期望的是第二次遍历什么都不输出或者抛出异常，因为迭代器已经耗尽

登录后复制

正确的