Python 迭代器

Python 中的迭代器是一个对象，它允许逐个遍历诸如列表或元组这样的集合。迭代器遵循迭代协议，实现了两个方法 __iter__() 和 __next__()。

__iter__() 方法返回迭代器对象本身，而 __next__() 方法返回序列中的下一个元素，并在没有更多元素可用时引发 StopIteration 异常。

迭代器提供了一种内存高效的方式来迭代数据，特别适合处理大数据集。它们可以通过使用 iter() 函数从可迭代对象创建，或者使用自定义类和生成器实现。

可迭代对象 vs 迭代器

在深入了解迭代器的工作原理之前，我们应该了解可迭代对象和迭代器之间的区别。

可迭代对象：能够一次返回其成员的对象（例如，列表，元组）。
迭代器：表示一个数据流的对象，一次返回一个元素。

我们通常使用 for 循环来遍历一个可迭代对象，如下所示：

for element in sequence:
   print(element)

Python 的内置方法 iter() 实现了 __iter__() 方法。它接收一个可迭代对象并返回一个迭代器对象。

Python 迭代器示例

以下代码从诸如列表、字符串和元组等序列类型中获取迭代器对象。iter() 函数也可以从字典返回键迭代器。

print(iter("aa"))
print(iter([1,2,3]))
print(iter((1,2,3)))
print(iter({}))

这将产生如下输出：

<str_iterator object at 0x7fd0416b42e0>
<list_iterator object at 0x7fd0416b42e0>
<tuple_iterator object at 0x7fd0416b42e0>
<dict_keyiterator object at 0x7fd041707560>

然而，整数不是可迭代的，因此会产生 TypeError。

iterator = iter(100)
print(iterator)

这将产生如下输出：

Traceback (most recent call last):
   File "C:\Users\user\example.py", line 5, in <module>
      print(iter(100))
            ^^^^^^^^^
TypeError: 'int' object is not iterable

迭代器中的错误处理

迭代器对象有一个名为 __next__() 的方法。每次调用它时，它都会返回迭代流中的下一个元素。调用 next() 函数等同于调用迭代器对象的 __next__() 方法。

当没有更多的项要返回时，这个方法会引发 StopIteration 异常。

示例

以下示例中创建的迭代器对象只有三个元素，但我们尝试多次迭代它。

it = iter([1,2,3])
print(next(it))
print(it.__next__())
print(it.__next__())
print(next(it))

这将产生如下输出：

1
2
3
Traceback (most recent call last):
   File "C:\Users\user\example.py", line 5, in <module>
      print(next(it))
            ^^^^^^^^
StopIteration

这个异常可以在消费迭代器的代码中被捕获，使用 try 和 except 块，尽管更常见的是通过使用如 for 循环这样的结构来隐式处理它，这些结构内部管理 StopIteration 异常。

it = iter([1,2,3, 4, 5])
print(next(it))
while True:
   try:
      no = next(it)
      print(no)
   except StopIteration:
      break

这将产生如下输出：

自定义迭代器

Python 中的自定义迭代器是一个用户定义的类，实现了迭代协议，包括 __iter__() 和 __next__() 两个方法。这使得类表现得像一个迭代器，能够逐个遍历它的元素。

为了在 Python 中定义一个自定义迭代器类，该类必须定义这些方法。

示例

在以下示例中，Oddnumbers 是一个实现了 __iter__() 和 __next__() 方法的类。每次调用 __next__() 时，数字增加 2，从而在 1 到 10 的范围内生成奇数。

class Oddnumbers:

   def __init__(self, end_range):
      self.start = -1
      self.end = end_range

   def __iter__(self):
      return self

   def __next__(self):
      if self.start < self.end-1:
         self.start += 2
         return self.start
      else:
         raise StopIteration

countiter = Oddnumbers(10)
while True:
   try:
      no = next(countiter)
      print(no)
   except StopIteration:
      break

这将产生如下输出：

示例

让我们创建另一个生成前 n 个斐波那契数列的迭代器，代码如下：

class Fibonacci:
   def __init__(self, max_count):
      self.max_count = max_count
      self.count = 0
      self.a, self.b = 0, 1

   def __iter__(self):
      return self

   def __next__(self):
      if self.count >= self.max_count:
         raise StopIteration
        
      fib_value = self.a
      self.a, self.b = self.b, self.a + self.b
      self.count += 1
      return fib_value

# 使用斐波那契迭代器
fib_iterator = Fibonacci(10)

for number in fib_iterator:
   print(number)

这将产生如下输出：

异步迭代器

Python 中的异步迭代器允许我们遍历异步序列，使循环内处理异步操作成为可能。

它们遵循异步迭代器协议，包括方法 __aiter__() 和 __anext__()（从 Python 3.10 版本开始添加）。这些方法与 async for 循环一起使用来迭代异步数据源。

aiter() 函数返回一个异步迭代器对象。它是经典迭代器的异步对应物。任何异步迭代器都必须支持 __aiter__() 和 __anext__() 方法。这两个内置函数在内部调用这些方法。

异步函数被称为协同程序，并使用 asyncio.run() 方法执行。主协同程序包含一个 while 循环，依次获取奇数并在数字超过 9 时引发 StopAsyncIteration。

像经典的迭代器一样，异步迭代器也提供了一个对象流。当流耗尽时，将引发 StopAsyncIteration 异常。

示例

在以下示例中，声明了一个异步迭代器类 Oddnumbers。它实现了 __aiter__() 和 __anext__() 方法。在每次迭代时，返回下一个奇数，程序等待一秒，以便它可以异步执行其他过程。

import asyncio

class Oddnumbers():
   def __init__(self):
      self.start = -1

   def __aiter__(self):
      return self
      
   async def __anext__(self):
      if self.start >= 9:
         raise StopAsyncIteration
      self.start += 2
      await asyncio.sleep(1)
      return self.start
      
async def main():
   it = Oddnumbers()
   while True:
      try:
         awaitable = anext(it)
         result = await awaitable
         print(result)
      except StopAsyncIteration:
         break
         
asyncio.run(main())

输出

这将产生如下输出：