Python学习迭代器(Iterator)
一、可迭代的对象(Iterable)
1、定义:可以直接用在循环的数据类型,如list,tuple,dict,set,str,还有generator(生成器),
和带yield的函数,这些直接可以用在循环的对象统称为可迭代对象(Iterable)
from collections import Iterable print(isinstance([], Iterable)) print(isinstance((), Iterable)) print(isinstance({}, Iterable)) print(isinstance("abc", Iterable)) print(isinstance((x for x in range(10)), Iterable)) # 生成器也是可迭代对象 print(isinstance(10, Iterable)) # 数字不是可迭代对象
二、迭代器(Iterator)
1、定义:生成器不但可以用在循环中,还能用next()不断调用返回下一个值,直到爆出StopIteration异常,
2、可迭代对象和迭代器和区别:迭代器和可迭代对象不是同个概念,区别在于是否有next函数(可以用dir(object)来查看此对象的所有支持的函数)。
print(isinstance((), Iterator)) print(isinstance({}, Iterator)) print(isinstance("abc", Iterator)) print(isinstance((x for x in range(10)), Iterator)) # 生成器是迭代器 print(isinstance(10, Iterator)) # 数字不是迭代器对象
三、可迭代对象与迭代器之间的转换
1、使用iter()函数将可迭代对象转换成迭代器。
list1 = iter([1,2,3,4,5]) print(list1.__next__()) print(list1.__next__())
2、为什么像list,string,tuple这样的可迭代对象不是迭代器?
因为这些数据结构是将已经存在的数据赋值他们,而迭代器是惰性计算的程序流,他甚至没有数据,所以可迭代对象只能表示有限的元素个数,而迭代器甚至可以表示整个自然数集合。
四、python很多功能都有迭代器的影子,举一些内置迭代器的例子
1、循环用到的range(),其实就是一个迭代器,比如range(10000),不是生成一个10000个元素的集合,而内置了next函数,逐个生成。
2、文件调用的时候file.redelines(),是返回一个列表,而 for line in file: 则是迭代器中逐行前进,也是内置了next函数
五、小结:迭代器是一个概念,其实就是生成器的应用。
Python中的迭代器是一种对象,它可以迭代(遍历)一个可迭代对象(比如列表、元组或字符串)的元素。迭代器用于实现迭代器协议,即包含 __iter__() 方法和 __next__() 方法。
迭代器的工作原理是每次调用 __next__() 方法时返回可迭代对象的下一个元素,当没有元素可迭代时,抛出 StopIteration 异常。
class MyIterator:
def __init__(self, iterable):
self.iterable = iterable
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index < len(self.iterable):
result = self.iterable[self.index]
self.index +=1
return result
else:
raise StopIteration
# 创建一个可迭代对象
my_list = [1, 2, 3, 4, 5]
# 创建一个迭代器
my_iterator = MyIterator(my_list)
# 使用迭代器遍历元素
for item in my_iterator:
print(item)
值得注意的是,当迭代器耗尽后,如果再次使用迭代器来便利,将不会得到任何输出。
所以总的来说,迭代器是用于遍历可迭代对象的对象,它实现了迭代器协议,具有 __iter__() 和 __next__() 方法。
可迭代对象
我们看迭代器好像和平时我们使用的列表、字典等数据结构一样,都可以遍历,那么列表、字典等数据结构是迭代器吗?
不好意思,他们不是迭代器,而是可迭代对象(iterable)。
可迭代对象(iterable)是指具有迭代行为的对象。当我们希望能够按照一定方式遍历对象中的元素时,我们可以将该对象称为可迭代对象。换句话说,可迭代对象是一种提供迭代能力的容器。
可迭代对象的特点是实现了 __iter__() 方法,这个方法返回一个迭代器(iterator)。迭代器是能够按照一定顺序生成下一个元素的对象。
在 Python 中,许多数据结构都是可迭代对象,比如列表、元组、集合、字典等。我们可以使用for循环对这些对象进行遍历。
同时,也可以使用内置的 iter() 函数将可迭代对象转换为迭代器。迭代器是可迭代对象的一种特殊形式,实现了 __iter__() 和 __next__() 方法。迭代器可以使用 next() 函数来获取下一个元素,并且在没有元素可返回时引发 StopIteration 异常。
my_list = [1, 2, 3, 4, 5] # 列表是可迭代对象
for item in my_list:
print(item)
my_iterator = iter(my_list) # 使用iter()函数将列表这个可迭代对象转换为迭代器
print(next(my_iterator)) # 输出第一个元素
print(next(my_iterator)) # 输出第二个元素
在这个示例中,列表 my_list 是可迭代对象,它可以被 for 循环遍历。另外,我们还使用 iter() 函数将 my_list 转换为迭代器 my_iterator,并使用 next() 函数逐个访问其中的元素。
所以总的来说,可迭代对象是指具有迭行为的对象,它们实现了 __iter__() 方法。通过for循环或 iter() 函数,我们可以遍历这些对象的元素。
可迭代对象是指实现了 __iter__() 方法的对象,而迭代器是实现了 __iter__() 和 __next__() 方法的对象,这个可以说是它们比较明显的区别。
for循环机制
从上面我们指定,列表、元组、集合、字典等数据结构是可迭代对象,并不是迭代器。而可迭代对象只实现了__iter__()方法,并不具有迭代(也就是返回下一个元素)的功能。那么很多同学可能就比较奇怪了,我们平时使用for循环遍历这个数据结构的时候,内部是怎么遍历的呢?
实际上在 Python 中,for循环在内部自动会调用 __iter__() 函数将可迭代对象转换为迭代器。用for循环遍历可迭代对象的实现机制为:
for循环首先会调用 __iter__() 函数,该函数会将可迭代对象转换为一个迭代器对象(如果对象本身就是迭代器,则不作转换)。
接下来,for循环会调用迭代器对象的 __next__() 方法来获取下一个元素。如果迭代器对象没有下一个元素,会抛出 StopIteration 异常。
for循环会自动捕捉 StopIteration 异常,表示已经迭代完所有元素,循环将结束。
所以以下两个方法实际上是等价的。
my_string = "Hello"
for char in my_string:
print(char)
实际上完全等价于:
my_string = "Hello"
my_iterator = iter(my_string)
print(next(my_iterator)) # 输出:H
print(next(my_iterator)) # 输出:e
print(next(my_iterator)) # 输出:l
print(next(my_iterator)) # 输出:l
print(next(my_iterator)) # 输出:o
生成器
生成器(Generator)是一种特殊的迭代器,它可以在迭代过程中动态地生成值,而不是一次性地将所有元素放在内存中。生成器使用 yield 关键字来定义,当生成器的代码块执行到 yield 语句时,就会暂停执行并返回一个值,下次调用时会从上次暂停的位置继续执行。这样可以在需要的时候生成值,而不是一次性生成所有的值。
def my_generator():
yield 1
yield 2
yield 3
# 使用生成器
gen = my_generator()
print(next(gen)) # 输出:1
print(next(gen)) # 输出:2
print(next(gen)) # 输出:3
print(next(gen)) # 抛出 StopIteration 异常
在上面的示例中,我们定义了一个名为 my_generator 的生成器函数,它通过使用 yield 关键字来产生值。当我们调用生成器函数时,它返回一个生成器对象 gen。我们可以使用 next() 函数来逐个获取生成器的值。每次调用 next() 时,生成器函数会从上次暂停的位置继续执行,并返回 yield 语句的值。当生成器函数执行完毕或没有更多的值可生成时,调用 next() 会抛出 StopIteration 异常。
生成器的一个重要特点是它们可以节省内存,尤其在处理大量数据时非常有用。由于生成器是按需生成值,只有在需要时才会在迭代过程中生成值,不会一次性占用大量的内存。所在遍历大批量数据的时候,非常有用,因为如果将大批量的数据直接加载到内存中在遍历,肯定会消耗很多内存,而利用生成器就可以做到需要哪些遍历哪些。
如果用简单一句话来说就是,我既想大量的数据,又想让它占用空间少,实现鱼和熊掌的兼得,那么就用生成器!
def read_large_file(file_path):
with open(file_path, 'r') as file:
for line in file:
yield line.rstrip()
# 使用生成器遍历大文件
file_generator = read_large_file('large_file.txt')
print(file_generator) # 输出<generator object fibonacci_generator at 0x0000017362DCFED0>
print(type(file_generator)) # 输出<class 'generator'>
for line in file_generator:
# 处理每一行数据
print(line)
从上面可以看出,read_large_file() 函数是一个生成器函数,它按行从一个大文件中读取数据。通过使用 yield 关键字,在每次迭代时逐行生成文件的内容,并将其作为生成器的值返回。然后,我们可以使用 for 循环逐行处理大文件。可以看到,我们打印的file_generator类型是一个生成器。
当然,以上的例子并不一定需要采用生成器才能处理,我们直接在第4行进行处理也是可以的,生成器更多的只是提供一种思路,当你用常规方法不能解决问题的时候,可以试试用生成器。
生成器原理
生成器的原理基于迭代器(iterators)和生成器函数(generator functions)。
def even_numbers(n):
for i in range(1, n+1):
if i % 2 == 0:
yield i
# 创建生成器对象
even_generator = even_numbers(10)
# 打印生成的偶数
for number in even_generator:
print(number)
生成器函数
生成器通过生成器函数创建,生成器函数是一种特殊类型的函数,使用 yield 语句来生成值。像上面的例子even_numbers函数就是要给生成器函数,当调用生成器函数时,它返回一个生成器对象,而不是立即执行函数体内的代码,even_generator就是一个生成器对象。
而之前我们说过生成器是一种特殊类型的迭代器,它可以在迭代中生成值。迭代器是一个实现了 __iter__() 和 __next__() 方法的对象。__iter__() 方法返回迭代器本身,而for循环内部会自动调用 __next__() 方法用于获取下一个值。每次调用 __next__() 方法时,生成器会从上一次暂停的位置继续执行,直到遇到下一个 yield 语句,然后将 yield 后面的值返回给调用者。
逐个生成值
生成器在调用 __next__() 方法时逐个生成值,并且每次在生成一个值后会暂停执行。这种延迟生成的机制使得生成器能够处理大量数据或无限序列,而不需要一次性加载或计算所有值。
状态保存
生成器在暂停执行时会保存其状态,包括局部变量、指令指针等信息。下一次调用 __next__() 方法时,生成器会从上一次暂停的地方恢复执行,并继续执行剩余部分的代码。