二、常用函数和迭代器

文章目录 二、常用函数和迭代器 2.迭代器 三、总结结束语

前言

有三大器：迭代器、生成器、装饰器。这里给大家先介绍迭代器相关的知识。

一、迭代器介绍及作用 1.可迭代对象

在介绍迭代器之前介绍一下迭代和可迭代对象的概念：

迭代：通常从一个对象中依次取出数据，这个过程叫做遍历，也称为**迭代(**重复执行某一段代码块，并将每一次迭代得到的结果作为下一次迭代的初始值)。

可迭代对象：是指该对象可以被用于for循环，例如：集合，列表，元组，字典，字符串，迭代器等。直接作用于for循环的对象统称为可迭代对象()

那么在代码层面如何定义一个可迭代对象呢？

在中如果一个对象实现了方法，则该对象可以称之为可迭代对象。例如，可以查看list,set等其内部均实现了方法，实现方式和对象的初始化方法一样。

class MyIterable:def __init__(self):passdef __iter__(self):return self

如果一个对象未实现方法，对其使用for则会抛出: ‘xxx’ is not 。

实现了方法，则就是一个可迭代对象。可以通过如下方式判断一个对象是不是可迭代对象？

# 导入collections.abc模块中的Iterable对象
import collections.abcclass MyIterable:def __init__(self):passdef __iter__(self):return selfobj = MyIterable()# 判断str是否可迭代
a = isinstance(obj, collections.abc.Iterable)
# 打印迭代结果
print(a)

2. 迭代器

迭代器：对可迭代对象进行迭代的方式或容器，并且需要记录当前迭代进行到的位置。

迭代器可以被定义为：

⋆ \star ⋆ 在中如果一个对象同时实现了和(获取下一个值)方法

⋆ \star ⋆ 可以通过内置函数next()或实例对象的()方法，来获取当前迭代的值

⋆ \star ⋆ 迭代器一定是可迭代对象，可迭代对象不一定是迭代器。

⋆ \star ⋆ 如果可迭代对象遍历完后继续调用next()，则会抛出：异常。

注意第三点，一个对象要同时实现和才 可以称为迭代器，只有实现方法的称为可迭代对象。可通过如下方式判断一个对象是不是迭代器？

# 导入collections.abc模块中的Iterable对象
import collections.abcclass MyIterable:def __init__(self):passdef __iter__(self):return selfobj = MyIterable()# 判断str是否可迭代
a = isinstance(obj, collections.abc.Iterable)  # True
b = isinstance(obj, collections.abc.Iterator)  # False
# 打印迭代结果
print(a)
print(b)

从这里可以看到obj是可迭代对象，但不是迭代器。常见数据类型和分类：

你可能会问，为什么list、dict、str等数据类型不是？

这是因为的对象表示的是一个数据流，对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以的计算是惰性的，只有在需要返回下一个数据时它才会计算。甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

下面是一个简单的迭代器示例：

# 导入collections.abc模块中的Iterable对象
import collections.abcclass MyIterable:def __init__(self, mylist):self.mylist = mylist  # 列表self.index = 0   # 索引def __iter__(self):return selfdef __next__(self):if self.index < len(self.mylist):value = self.mylist[self.index]self.index += 1return valueelse:raise StopIterationmylist = [1, 2, 3, 4, 5]
iterableobj = MyIterable(mylist)  # 迭代器(可迭代对象)# a = isinstance(iterableobj, collections.abc.Iterable)  # True
# b = isinstance(iterableobj, collections.abc.Iterator)  # False

在这个示例中，我们创建了一个称为""的类，它包含了一个列表和一个索引值。该类还实现了()和()方法。因此是一个迭代器(可迭代对象)。

()方法返回该对象本身，因此可以直接对该对象使用for…in…语句进行迭代。

()方法则根据当前索引值来获取列表中的下一个元素，如果已经到达列表末尾，则抛出异常。因此有两种方法打印输出。

(1)使用for循环打印输出

for item in iterableobj:print(item)

(2)使用next函数

while True:try:# 获得下一个值:x = next(iterableobj)print(x)except StopIteration:# 遇到StopIteration就退出循环break

注意不要两种方式一起用，一起使用的话，只会打印输出一次，可能是由于底层都是调用的迭代器吧，迭代器会记录当前迭代的位置，使用其中一种方式后，迭代器计数器已经到末尾了，当第二次使用的时，自然啥也不会输出。

二、常用函数和迭代器 1.常用函数

在中，()是一个内置函数，用于过滤可迭代对象（如列表、元组、集合等）中的元素，并返回一个新的可迭代对象，其中仅包含符合指定条件的元素。()函数的一般语法如下：

filter(function, iterable)

其中，是一个用于过滤的函数，它接受一个参数并返回一个布尔值（True或False）。是要过滤的可迭代对象。

()函数会迭代中的每个元素，对每个元素调用，如果返回True，则该元素将被包含在结果中，否则将被过滤掉。最终，()返回一个新的迭代器，其中包含通过过滤条件的元素。

下面是一个简单的示例，演示如何使用()函数来筛选回文数字的例子:

def is_palindrome(n):return str(n) == str(n)[::-1]output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))

上述代码中，函数用于检查一个数是否为回文数，然后()函数将其应用于range(1,1000)中的每个元素，并返回一个新列表，其中都是回文数。

请注意，()函数返回一个迭代器，因此通常需要将其转换为列表或其他可迭代对象类型，以便查看结果或进行进一步操作。

map

map() 是中的一个内置函数，用于将一个函数应用于可迭代对象（如列表、元组等）的每个元素，并返回一个包含结果的新可迭代对象。map() 的一般语法如下：

map(function, iterable, ...)

⋆ \star ⋆ 是要应用于可迭代对象的函数。

⋆ \star ⋆ 是一个或多个可迭代对象，可以是列表、元组等，它们的元素将依次传递给 函数。

以下是一个示例，演示如何使用 map() 函数将一个函数应用于列表中的每个元素：

def square(x):return x * xnumbers = [1, 2, 3, 4, 5]squared_numbers = list(map(square, numbers))print(squared_numbers)

在上述示例中， 函数用于计算一个数字的平方，然后 map() 函数将 应用于 列表中的每个元素，生成一个新的列表 ，其中包含了每个数字的平方。最终，打印出结果为 [1, 4, 9, 16, 25]。

map() 函数是一种强大的工具，可用于对多个可迭代对象执行操作，甚至可以使用 函数来定义操作。它在处理数据转换和批量操作时非常有用。

() 函数是标准库中的一个函数，位于模块中。它用于将一个函数累积应用到一个可迭代对象的元素上，从左到右依次累积计算，并返回一个最终的累积结果。() 的一般语法如下：

functools.reduce(function, iterable[, initial])

⋆ \star ⋆ 是一个接受两个参数(必须)的函数，它定义了如何将累积值与可迭代对象的下一个元素相结合。

⋆ \star ⋆ 是要进行累积操作的可迭代对象。

⋆ \star ⋆ （可选参数）是累积的初始值。如果提供了初始值，() 将使用它作为初始累积值，否则，将使用可迭代对象的第一个元素作为初始值。

() 函数通过将应用于累积值和可迭代对象的每个元素来逐步累积计算。它将先用初始值（如果提供）和可迭代对象的第一个元素调用，然后将结果作为下一次调用的第一个参数，继续迭代直到处理完所有元素。

以下是一个示例，演示如何使用 () 函数来计算列表中所有元素的累积乘积：

from functools import reducedef multiply(x, y):return x * ynumbers = [1, 2, 3, 4, 5]product = reduce(multiply, numbers)print(product)

在上述示例中， 函数用于计算两个数字的乘积，然后 () 函数将 应用于 列表中的每个元素，从左到右逐步计算累积乘积。最终，打印出结果为 120，因为 1 * 2 * 3 * 4 * 5 = 120。

() 函数在处理需要累积计算的情况下非常有用，但需要注意，它在 3中已经不再是内置函数，而是移到模块，需要导入该模块才能使用。

() 是内置函数，用于反转可迭代对象（例如列表、元组、字符串）的元素顺序，并返回一个新的迭代器，以便您可以按相反的顺序遍历它们。() 的一般语法如下：

reversed(iterable)   # iterable 是要反转的可迭代对象。

() 函数不会修改原始可迭代对象，而是创建一个新的迭代器，该迭代器返回可迭代对象的元素以相反的顺序。通常，您可以将这个迭代器转换为列表或其他可迭代对象类型，以查看或进一步处理反转后的元素。

以下是一个示例，演示如何使用 () 函数来反转一个列表：

original_list = [1, 2, 3, 4, 5]reversed_iterator = reversed(original_list)reversed_list = list(reversed_iterator)print(reversed_list)

在上述示例中，() 函数将 反转，然后将结果存储在 中。最终，打印出结果为 [5, 4, 3, 2, 1]，即原始列表的元素以相反的顺序排列。

() 函数在需要对可迭代对象进行反向遍历时非常有用，特别是当您不想修改原始数据的情况下。

() 是的内置函数，用于对可迭代对象（如列表、元组、字符串等）进行排序，并返回一个新的已排序的列表（或其他可迭代对象）。() 的一般语法如下：

sorted(iterable, key=None, reverse=False)

⋆ \star ⋆ 是要排序的可迭代对象。

⋆ \star ⋆ key（可选参数）是一个函数，用于指定排序的标准。它接受可迭代对象的元素并返回一个用于排序的键值。默认情况下，key为None，表示直接比较元素的值。

⋆ \star ⋆ （可选参数）是一个布尔值，用于指定是否要进行降序排序。默认为False，表示升序排序。

() 函数不会修改原始可迭代对象，而是创建一个新的已排序的可迭代对象。通常，您可以将这个已排序的可迭代对象转换为列表或其他可迭代对象类型，以查看或进一步处理已排序的元素。

以下是一些示例，演示如何使用 () 函数来排序不同类型的可迭代对象：

numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # [1, 2, 5, 5, 6, 9]text = "python"
sorted_text = sorted(text)
print(''.join(sorted_text))   # hnoptypeople = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}, {'name': 'Charlie', 'age': 35}]
sorted_people = sorted(people, key=lambda x: x['age'])
print(sorted_people)  # [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

() 函数是一个强大的工具，可用于对各种可迭代对象进行排序，同时可以通过指定自定义的排序标准（使用key参数）和进行降序排序来满足不同的需求。

iter

iter() 是的内置函数，用于创建一个迭代器对象，它可以迭代访问一个可迭代对象（如列表、字符串、字典等）。iter() 的一般语法如下：

iter(iterable, sentinel)

⋆ \star ⋆ 是要创建迭代器的可迭代对象。

⋆ \star ⋆ （可选参数）是一个标记值，用于指定迭代的终止条件。如果未提供 ，则迭代器会一直迭代到可迭代对象的末尾。

使用 iter() 函数，可以将一个可迭代对象转换为一个迭代器，然后使用 next() 函数来逐个访问其元素。通常，for 循环内部也会自动使用 iter() 来创建迭代器，并使用 next() 来访问元素，但您可以手动控制迭代的过程。

以下是一个示例，演示如何使用 iter() 和 next() 来手动迭代一个列表：

my_list = [1, 2, 3, 4, 5]# 创建迭代器
my_iterator = iter(my_list)# 使用 next() 函数访问迭代器的元素
print(next(my_iterator))  # 输出 1
print(next(my_iterator))  # 输出 2
print(next(my_iterator))  # 输出 3# 也可以在 for 循环中自动迭代
for item in my_iterator:print(item)   # 4 5从上面迭代的位置继续输出

在上述示例中，首先使用 iter() 创建了一个名为 的迭代器，然后使用 next() 函数来逐个访问其元素。当所有元素都被访问后，再次调用 next() 会引发 异常，表明迭代已结束。

next

next() 是的内置函数，用于从可迭代对象中获取下一个元素。它的一般语法如下:

next(iterator, default)

⋆ \star ⋆ 是一个迭代器对象，通常由 iter() 函数创建。

⋆ \star ⋆ （可选参数）是一个在迭代结束时返回的默认值。如果没有提供 参数并且没有更多的元素可供迭代，next() 函数将引发 异常。

next() 函数允许您手动控制迭代，通过迭代器逐个获取元素。通常，它在 for 循环之外使用，以便您可以自行处理元素的获取和处理。

以下是一个示例，演示如何使用 next() 函数从一个迭代器中逐个获取元素：

my_list = [1, 2, 3, 4, 5]# 创建迭代器
my_iterator = iter(my_list)# 使用 next() 函数获取下一个元素
try:print(next(my_iterator))  # 输出 1print(next(my_iterator))  # 输出 2print(next(my_iterator))  # 输出 3print(next(my_iterator))  # 输出 4print(next(my_iterator))  # 输出 5print(next(my_iterator))  # 由于没有更多元素可供迭代，引发 StopIteration 异常
except StopIteration:print("迭代结束")# 使用默认值参数获取下一个元素，而不引发异常
next_element = next(my_iterator, "没有更多元素")
print(next_element)  # 输出 "没有更多元素"

在上述示例中，首先使用 iter() 创建了一个名为 的迭代器，然后使用 next() 函数来逐个获取迭代器中的元素。当没有更多的元素可供迭代时，next() 函数可以返回一个默认值（如果提供了参数），或者引发 异常。

通常情况下，for 循环会自动处理元素的获取和异常，因此 next() 主要用于需要手动控制迭代的情况。

() 是内置函数，用于将可迭代对象的元素与它们的索引（位置）一起返回。() 的一般语法如下：

enumerate(iterable, start=0)

⋆ \star ⋆ 是要枚举的可迭代对象。

⋆ \star ⋆ start（可选参数）是一个整数，用于指定起始索引值，即第一个元素的索引, 默认为0。

() 函数返回一个生成器，每次迭代都产生一个包含索引和元素的元组。这使得在迭代可迭代对象时能够访问元素的同时了解它们的位置。

以下是一个示例，演示如何使用 () 函数来枚举列表中的元素：

my_list = ["apple", "banana", "cherry", "date"]for index, value in enumerate(my_list):print(f"Index {index}: {value}")# Index 0: apple
# Index 1: banana
# Index 2: cherry
# Index 3: date

上述代码中，() 返回一个生成器，该生成器在每次迭代时产生一个包含索引和元素的元组。在循环中，我们使用两个变量 index 和 value 分别接收索引和元素的值，然后将它们打印出来。

通过 () 函数，可以轻松地获取元素的索引，并在迭代中对元素进行处理，这在需要同时了解元素位置的情况下非常有用。

2.迭代器 chain拼接迭代器

.chain 是 标准库中的 模块提供的函数，用于将多个可迭代对象（如列表、元组、迭代器等）连接成一个单一的迭代器。.chain 的一般语法如下：

itertools.chain(iterable1, iterable2, ...)    #  iterable1, iterable2, ... 是要连接的多个可迭代对象，可以是任意数量

.chain 函数返回一个迭代器，它按照提供的顺序依次迭代这些可迭代对象中的元素，使它们看起来像是一个大的、连续的可迭代对象。

以下是一个示例，演示如何使用 .chain 来连接多个可迭代对象：

import itertoolslist1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
tuple1 = (10, 20, 30)chained_iterator = itertools.chain(list1, list2, tuple1)for item in chained_iterator:print(item)  # 1 2 3 a b c 10 20 30

在上述示例中，.chain 函数连接了三个不同的可迭代对象：list1、list2 和 。然后，使用 for 循环迭代 ，它会依次访问这三个可迭代对象中的元素，使它们看起来像是一个连续的可迭代对象。

累积迭代器

. 是 标准库中的 模块提供的函数，用于创建一个累积计算的迭代器。. 的一般语法如下：

itertools.accumulate(iterable, func=operator.add)

⋆ \star ⋆ 是要进行累积计算的可迭代对象，通常包含数字或其他可以进行二元操作的元素。

⋆ \star ⋆ func（可选参数）是一个二元操作函数，用于定义如何进行累积计算。默认情况下，它使用 .add 函数进行加法操作。

. 函数返回一个迭代器，它按照提供的二元操作函数在可迭代对象中的元素上进行累积计算，并依次生成累积结果。

以下是一个示例，演示如何使用 . 来创建一个累积计算的迭代器:

import itertoolsnumbers = [1, 2, 3, 4, 5]# 使用默认的加法操作进行累积计算
cumulative_iterator = itertools.accumulate(numbers)for result in cumulative_iterator:print(result)  # 1 3 6 10 15

在上述示例中，. 函数创建了一个累积计算的迭代器，该迭代器将对 列表中的元素执行加法操作。在循环中，我们迭代访问并打印每一步的累积结果。

还可以使用自定义的二元操作函数来执行不同类型的累积计算，例如减法、乘法等。在这种情况下，您需要提供一个适当的函数作为 func 参数。

漏斗迭代器

press 是 标准库中的 模块提供的函数，用于根据一个布尔值可迭代对象，从另一个可迭代对象中选择对应位置为 True 的元素。press 的一般语法如下：

itertools.compress(data, selectors)

⋆ \star ⋆ data 是要筛选元素的可迭代对象。

⋆ \star ⋆ 是一个布尔值可迭代对象，用于指示哪些元素应该被选择。 中的 True 表示选择对应位置的 data 中的元素，而 False 表示不选择。

press 返回一个迭代器，它依照 中的布尔值筛选 data 中的元素，生成一个新的迭代器。

以下是一个示例，演示如何使用 press 来选择满足条件的元素：

import itertoolsdata = [1, 2, 3, 4, 5]
selectors = [True, False, True, False, True]filtered_iterator = itertools.compress(data, selectors)for item in filtered_iterator:print(item)  # 1 3  5

在上述示例中，press 函数使用 布尔值可迭代对象，选择了 data 中对应位置为 True 的元素。然后，在循环中，迭代并打印筛选出的元素。

tee克隆迭代器

.tee 是 标准库中的 模块提供的函数，用于创建多个独立的迭代器，以便同时迭代相同的可迭代对象，而不会相互影响。.tee 的一般语法如下：

itertools.tee(iterable, n=2)

⋆ \star ⋆ 是要分割的可迭代对象。

⋆ \star ⋆ n（可选参数）是要创建的迭代器的数量。默认值为 2。

.tee 函数返回一个元组，包含 n 个迭代器，这些迭代器都可以独立地迭代相同的可迭代对象。这对于需要多次遍历相同数据的情况非常有用，而不必重新生成可迭代对象。

以下是一个示例，演示如何使用 .tee 来创建多个迭代器，同时迭代相同的可迭代对象：

import itertoolsdata = [1, 2, 3, 4, 5]# 创建两个独立的迭代器
iter1, iter2 = itertools.tee(data, 2)# 使用第一个迭代器
for item in iter1:print(f'Iter1: {item}')# 使用第二个迭代器
for item in iter2:print(f'Iter2: {item}')

在上述示例中，.tee 函数创建了两个独立的迭代器 iter1 和 iter2，它们都可以独立地迭代 data 列表。在两个循环中，我们分别使用了这两个迭代器来迭代相同的数据。

复制元素

. 是 标准库中的 模块提供的函数，用于创建一个迭代器，它会重复生成指定的元素，无限次或特定次数。. 的一般语法如下：

itertools.repeat(element, times=None)

⋆ \star ⋆ 是要重复生成的元素。

⋆ \star ⋆ times（可选参数）是一个整数，表示要重复生成的次数。如果未提供 times 参数，则 . 会无限重复生成元素。

. 函数返回一个迭代器，该迭代器会生成指定的元素，重复指定的次数或无限次。

以下是一些示例，演示如何使用 . 创建重复生成元素的迭代器：

import itertools# 创建一个无限重复 "Hello" 的迭代器
repeat_iterator = itertools.repeat("Hello")# 使用迭代器
for _ in range(5):print(next(repeat_iterator))

在上述示例中，. 创建了一个无限重复生成 “Hello” 的迭代器。我们使用 next() 函数从迭代器中获取元素，从而生成 “Hello” 五次。

. 对于需要重复相同元素的情况非常有用，可以是无限重复，也可以是指定次数的重复。这在生成测试数据、创建特定大小的数据集等情况下很有用。

. 是 标准库中的 模块提供的函数，用于计算多个可迭代对象的笛卡尔积。笛卡尔积是一种组合方式，它将多个可迭代对象的所有元素排列组合在一起，生成一个包含所有可能组合的迭代器。. 的一般语法如下：

itertools.product(iterable1, iterable2, ..., repeat=1)

⋆ \star ⋆ , , … 是要计算笛卡尔积的可迭代对象，可以是多个可迭代对象。

⋆ \star ⋆ （可选参数）是一个整数，表示每个可迭代对象要重复多少次。默认值为 1。

. 函数返回一个迭代器，该迭代器生成笛卡尔积中的每个组合。

以下是一个示例，演示如何使用 . 来计算多个可迭代对象的笛卡尔积：

import itertoolscolors = ['red', 'green', 'blue']
sizes = ['small', 'medium', 'large']# 计算颜色和尺寸的笛卡尔积
product_iterator = itertools.product(colors, sizes)for item in product_iterator:print(item)

在上述示例中，. 函数计算了 和 sizes 两个可迭代对象的笛卡尔积，生成了所有可能的颜色和尺寸组合。在循环中，我们迭代并打印了这些组合。

zip

zip() 是 的内置函数，用于将多个可迭代对象的元素按索引配对组合，返回一个元组构成的迭代器或列表，以便您可以同时访问这些可迭代对象的对应元素。zip() 的一般语法如下：

zip(iterable1, iterable2, ...)   # iterable1, iterable2, ... 是要组合的可迭代对象，可以是多个可迭代对象。

zip() 函数将从每个可迭代对象中获取相同索引位置的元素，并将它们组合成元组。这意味着第一个元组包含了每个可迭代对象的第一个元素，第二个元组包含了每个可迭代对象的第二个元素，依此类推。

以下是一个示例，演示如何使用 zip() 函数来组合多个可迭代对象的元素：

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]# 使用 zip() 将名字和分数配对
zipped_data = zip(names, scores)# 将配对后的数据转换为列表
zipped_list = list(zipped_data)# 打印配对后的数据
for item in zipped_list:print(item)

在上述示例中，zip() 函数将 names 和 两个可迭代对象的元素按索引位置进行配对。然后，我们将配对后的数据转换为一个列表，并打印它们。

. 是 标准库中的 模块提供的函数，用于将多个可迭代对象的元素按索引配对组合，与 zip() 不同的是，. 会使用一个填充值来填充不等长的可迭代对象，以确保所有可迭代对象都能配对。. 的一般语法如下：

itertools.zip_longest(iterable1, iterable2, ..., fillvalue=None)

⋆ \star ⋆ , , … 是要组合的可迭代对象，可以是多个可迭代对象。

⋆ \star ⋆ （可选参数）是用于填充不等长可迭代对象的值。默认为 None。

. 函数返回一个迭代器，该迭代器将多个可迭代对象的元素按索引位置进行配对，并使用 来填充不等长的可迭代对象，以确保所有可迭代对象都能配对。

以下是一个示例，演示如何使用 . 来组合多个可迭代对象的元素，使用填充值填充不等长的可迭代对象：

import itertoolsnames = ['Alice', 'Bob', 'Charlie']
scores = [85, 92]# 使用 itertools.zip_longest 将名字和分数配对，并使用 0 填充不等长的可迭代对象
zipped_data = itertools.zip_longest(names, scores, fillvalue=0)# 打印配对后的数据
for item in zipped_data:print(item)

在上述示例中，. 函数将 names 和 两个可迭代对象的元素按索引位置进行配对，并使用 0 填充了不等长的可迭代对象。然后，我们迭代并打印了配对后的数据。

三、总结

优点：迭代器对象表示的是一个数据流，可以在需要时才去调用next来获取一个值；因而本身在内存中始终只保留一个值，对于内存占用小可以存放无限数据流。由于其他容器需要一次将所有元素都存放进内存，如：列表、集合、字典…等

缺点：无法获取存放的元素长度，除非取完计数。同时取值不灵活，只能向后取值，next()永远返回的是下一个值；无法取出指定值(如字典的key,或列表的下标)，而且迭代器对象的生命周期是一次性的，元素被迭代完则生命周期结束。

​

的迭代器提供稳定和灵活的代码。迭代器和可迭代对象的区别：

⋆ \star ⋆ ​​ 是一个可以迭代的对象。它在传递给​​iter()​​方法时生成一个迭代器。

⋆ \star ⋆ ​​​ 是一个对象，用于使用 ​​()​​​ 方法对可迭代对象进行迭代。迭代器有 ​​() ​​方法，它返回对象的下一项。

请注意，每个迭代器也是一个可迭代的，但不是每个可迭代的都是一个迭代器。

例如，列表是可迭代的，但列表不是迭代器。可以使用函数 ​​iter() ​​从可迭代对象创建迭代器。

为了实现这一点，对象的类需要一个方法 ​​​​​，它返回一个迭代器，或者一个具有从 0 开始的顺序索引的 ​​​​​ 方法。但其本质也是实现了 ​​​​ 方法。

结束语

感谢阅读吾之文章，今已至此次旅程之终站 。

吾望斯文献能供尔以宝贵之信息与知识也 。

学习者之途，若藏于天际之星辰，吾等皆当努力熠熠生辉，持续前行。

然而，如若斯文献有益于尔，何不以三连为礼？点赞、留言、收藏 - 此等皆以证尔对作者之支持与鼓励也 。