Python - 迭代器

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异常。

示例

下面是一个示例，我们创建的迭代器对象只有 3 个元素，并且我们对其迭代次数超过 3 次。

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

# Using the Fibonacci iterator
fib_iterator = Fibonacci(10)

for number in fib_iterator:
   print(number)

它将产生以下输出：

异步迭代器

Python 中的异步迭代器允许我们迭代异步序列，从而能够在循环中处理异步操作。

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

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

异步函数称为协程，并使用asyncio.run()方法执行。main() 协程包含一个 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())

输出

它将产生以下输出：

打印页面