Python - 迭代器

Python 迭代器

Python 中的迭代器（ Iterators ）是一个对象，它允许遍历集合（如列表或元组），一次遍历一个元素。它通过使用两个方法 __iter__（） 和 __next__（） 的实现来遵循迭代器协议。

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

迭代器提供了一种节省内存的方式来迭代数据，对于大型数据集尤其有用。它们可以使用 iter（） 函数从可迭代对象创建，也可以使用自定义类和生成器实现。

Iterables vs Iterators

在深入研究迭代器工作之前，我们应该了解 Iterables 和 Iterators 之间的区别。

• Iterable：能够一次返回一个其成员的对象（例如，列表、元组）。
• Iterator：表示数据流的对象，一次返回一个元素。

我们通常使用 for 循环来迭代可迭代对象，如下所示 -

for element in sequence:
	 	print (element)

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

Python 迭代器示例

以下代码从 list、string 和 tuple 等序列类型中获取迭代器对象。iter（） 函数还返回 dictionary 中的 keyiterator。

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

它将产生以下输出 -

但是，int id 不可迭代，因此会产生 TypeError。

iterator = iter(100)
print (iterator)

它将产生以下输出 -

迭代器中的错误处理

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

此方法在没有更多要返回的项目时引发 StopIteration 异常。

在下面的一个例子中，我们创建的迭代器对象只有 3 个元素，并且我们正在迭代它三次以上 -

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

它将产生以下输出 -

可以使用 try 和 except 块在使用迭代器的代码中捕获此异常，但更常见的方法是使用内部管理 StopIteration 异常的 for 循环等构造来隐式处理它。

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__（） 方法。这些方法由两个内置函数在内部调用。

与经典迭代器一样，异步迭代器提供对象流。当流耗尽时，将引发 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())

输出

它将产生以下输出 -