python-for迭代与生成 Jun 5, 2020 · python · 分享到: 转载：为什么for循环可以遍历list：Python中迭代器与生成器 作者：奥辰 原文链接：https://www.cnblogs.com/chenhuabin/p/11288797.html 本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。 1 引言 2 迭代器与可迭代对象 2.1 迭代器 2.2 迭代器 2.3 for循环的本质 3 生成器 3.1 迭代器与生成器 3.2 生成器解析式 4 总结 1 引言 只要你学了Python语言，就不会不知道for循环，也肯定用for循环来遍历一个列表（list)，那为什么for循环可以遍历list，而不能遍历int类型对象呢？怎么让一个自定义的对象可遍历？ 这篇博客中，我们来一起探索一下这个问题，在这个过程中，我们会介绍到迭代器、可迭代对象、生成器，更进一步的，我们会详细介绍他们的原理、异同。 2 迭代器与可迭代对象 在开始下面内容之前，我们先说说标题中的“迭代”一词。什么是迭代？我认为，迭代一个完整过程中的一个重复，或者说每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值，举一个类比来说：一个人类家族的发展是一个完整过程，需要经过数代人的努力，每一代都会以接着上一代的成果继续发展，所以每一代都是迭代。 2.1 迭代器 （1）怎么判断是否可迭代 作为一门设计语言，Python提供了许多必要的数据类型，例如基本数据类型int、bool、str，还有容器类型list、tuple、dict、set。这些类型当中，有些是可迭代的，有些不可迭代，怎么判断呢？ 在Python中，我们把所有可以迭代的对象统称为可迭代对象，有一个类专门与之对应：Iterable。所以，要判断一个类是否可迭代，只要判断是否是Iterable类的实例即可。 1>>> from collections import Iterable 2>>> isinstance(123, Iterable) 3False 4>>> isinstance(True, Iterable) 5False 6>>> isinstance('abc', Iterable) 7True 8>>> isinstance([], Iterable) 9True 10>>> isinstance({}, Iterable) 11True 12>>> isinstance((), Iterable) 13True 所以，整型、布尔不可迭代，字符串、列表、字典、元组可迭代。 怎么让一个对象可迭代呢？毕竟，很多时候，我们需要用到的对象不止Python内置的这些数据类型，还有自定义的数据类型。答案就是实现__iter__()方法，只要一个对象定义了__iter__()方法，那么它就是可迭代对象。 1from collections.abc import Iterable 2class A(): 3 def __iter__(self): 4 pass 5print('A()是可迭代对象吗：',isinstance(A(),Iterable)) 结果输出为： 1A()是可迭代对象吗： True 瞧，我们在__iter__()方法里面甚至没写任何东西，反正我们在类A中定义则__iter__()方法，那么，它就是一个可迭代对象。 重要的事情说3遍： 只要一个对象定义了__iter__()方法，那么它就是可迭代对象。 只要一个对象定义了__iter__()方法，那么它就是可迭代对象。 只要一个对象定义了__iter__()方法，那么它就是可迭代对象。 2.2 迭代器 迭代器是对可迭代对象的改造升级，上面说过，一个对象定义了__iter__()方法，那么它就是可迭代对象，进一步地，如果一个对象同时实现了__iter__()和__next__()方法，那么它就是迭代器。 来，跟我读三遍： 如果一个对象同时实现了__iter__()和__next__()方法，那么它就是迭代器。 如果一个对象同时实现了__iter__()和__next__()方法，那么它就是迭代器。 如果一个对象同时实现了__iter__()和__next__()方法，那么它就是迭代器。 在Python中，也有一个类与迭代器对应：Iterator。所以，要判断一个类是否是迭代器，只要判断是否是Iterator类的实例即可。 1from collections.abc import Iterable 2from collections.abc import Iterator 3class B(): 4 def __iter__(self): 5 pass 6 def __next__(self): 7 pass 8print('B()是可迭代对象吗：',isinstance(B(), Iterable)) 9print('B()是迭代器吗：',isinstance(B(), Iterator)) 结果输出如下： 1B()是可迭代对象吗： True 2B()是迭代器吗： True 可见，迭代器一定是可迭代对象，但可迭代对象不一定是迭代器。 所以整型、布尔一定不是迭代器，因为他们连可迭代对象都算不上。那么，字符串、列表、字典、元组是迭代器吗？猜猜！ 1>>> from collections.abc import Iterator 2>>> isinstance('abc', Iterator) 3False 4>>> isinstance([], Iterator) 5False 6>>> isinstance({}, Iterator) 7False 8>>> isinstance((), Iterator) 9False 惊不惊喜，意不意外，字符串、列表、字典、元组都不是迭代器。那为什么它们可以在for循环中遍历呢？而且，我想，看到这里，就算你已经可以在形式上区分可迭代对象和迭代器，但是你可能会问，这有什么卵用吗？确实，没多少卵用，因为我们还不知道__iter__()、__next__()到底是个什么鬼东西。 接下来，我们通过继续探究for循环的本质来解答这些问题。 2.3 for循环的本质 说到__iter__()和__next__()方法，就很有必要介绍一下iter()和next()方法了。 （1）iter()与__iter__() __iter__()的作用是返回一个迭代器，虽然上面说过，只要实现了__iter__()方法就是可迭代对象，但是，没有实现功能（返回迭代器）总归是有问题的，就像一个村长，当选之后，那就是村长了，但是如果尸位素餐不做事，那总是有问题的。 __iter__()方法毕竟是一个特殊方法，不适合直接调用，所以Python提供了iter()方法。iter()是Python提供的一个内置方法，可以不用导入，直接调用即可。 1from collections.abc import Iterator 2class A(): 3 def __iter__(self): 4 print('A类的__iter__()方法被调用') 5 return B() 6class B(): 7 def __iter__(self): 8 print('B类的__iter__()方法被调用') 9 return self 10 def __next__(self): 11 pass 12a = A() 13print('对A类对象调用iter()方法前，a是迭代器吗：', isinstance(a, Iterator)) 14a1 = iter(a) 15print('对A类对象调用iter()方法后，a1是迭代器吗：', isinstance(a1, Iterator)) 16 17b = B() 18print('对B类对象调用iter()方法前，b是迭代器吗：', isinstance(b, Iterator)) 19b1 = iter(b) 20print('对B类对象调用iter()方法后，b1是迭代器吗：', isinstance(b1, Iterator)) 运行结果如下： 1对A类对象调用iter()方法前，a是迭代器吗： False 2A类的__iter__()方法被调用 3对A类对象调用iter()方法后，a1是迭代器吗： True 4对B类对象调用iter()方法前，b是迭代器吗： True 5B类的__iter__()方法被调用 6对B类对象调用iter()方法后，b1是迭代器吗： True 对于B类，因为B类本身就是迭代器，所以可以直接返回B类的实例，也就是说self，当然，你要是返回其他迭代器也没毛病。对于类A，它只是一个可迭代对象，__iter__()方法需要返回一个迭代器，所以返回了B类的实例，如果返回的不是一个迭代器，调用iter()方法时就会报以下错误：TypeError: iter() returned non-iterator of type 'A' 。 （2）next()与__next__() __next__()的作用是返回遍历过程中的下一个元素，如果没有下一个元素则主动抛出StopIteration异常。而next()就是Python提供的一个用于调用__next__()方法的内置方法。 下面，我们通过next()方法来遍历一个list： 1>>> list_1 = [1, 2, 3] 2>>> next(list_1) 3Traceback (most recent call last): 4File "<pyshell#19>", line 1, in <module> 5next(list_1) 6TypeError: 'list' object is not an iterator 7>>> list_2 = iter(list_1) 8>>> next(list_2) 91 10>>> next(list_2) 112 12>>> next(list_2) 133 14>>> next(list_2) 15Traceback (most recent call last): 16File "<pyshell#24>", line 1, in <module> 17next(list_2) 18StopIteration 因为列表只是可迭代对象，不是迭代器，所以对list_1直接调用next()方法会产生异常。对list_1调用iter()后就可以获得是迭代器的list_2，对list_2每一次调用next()方法都会取出一个元素，当没有下一个元素时继续调用next()就抛出了StopIteration异常。 1>>> class A(): 2 def __init__(self, lst): 3 self.lst = lst 4 def __iter__(self): 5 print('A.__iter__()方法被调用') 6 return B(self.lst) 7>>> class B(): 8 def __init__(self, lst): 9 self.lst = lst 10 self.index = 0 11 def __iter__(self): 12 print('B.__iter__()方法被调用') 13 return self 14 def __next__(self): 15 try: 16 print('B.__next__()方法被调用') 17 value = self.lst[self.index] 18 self.index += 1 19 return value 20 except IndexError: 21 raise StopIteration() 22>>> a = A([1, 2, 3]) 23>>> a1 = iter(a) 24A.__iter__()方法被调用 25>>> next(a1) 26B.__next__()方法被调用 271 28>>> next(a1) 29B.__next__()方法被调用 302 31>>> next(a1) 32B.__next__()方法被调用 333 34>>> next(a1) 35B.__next__()方法被调用 36Traceback (most recent call last): 37 File "<pyshell#78>", line 11, in __next__ 38 value = self.lst[self.index] 39IndexError: list index out of range 40 41During handling of the above exception, another exception occurred: 42 43Traceback (most recent call last): 44 File "<pyshell#84>", line 1, in <module> 45 next(a1) 46 File "<pyshell#78>", line 15, in __next__ 47 raise StopIteration() 48StopIteration A类实例化出来的实例a只是可迭代对象，不是迭代器，调用iter()方法后，返回了一个B类的实例a1，每次对a1调用next()方法，都用调用B类的__next__()方法。 接下来，我们用for循环遍历一下A类实例： 1>>> for i in A([1, 2, 3]): 2 print('for循环中取出值:',i) 3 4A.__iter__()方法被调用 5B.__next__()方法被调用 6for循环中取出值: 1 7B.__next__()方法被调用 8for循环中取出值: 2 9B.__next__()方法被调用 10for循环中取出值: 3 11B.__next__()方法被调用 通过for循环对一个可迭代对象进行迭代时，for循环内部机制会自动通过调用iter()方法执行可迭代对象内部定义的__iter__()方法来获取一个迭代器，然后一次又一次得迭代过程中通过调用next()方法执行迭代器内部定义的__next__()方法获取下一个元素，当没有下一个元素时，for循环自动捕获并处理StopIteration异常。如果你还没明白，请看下面用while循环实现for循环功能，整个过程、原理都是一样的： 1>>> a = A([1, 2, 3]) 2>>> a1 = iter(a) 3A.__iter__()方法被调用 4>>> while True: 5 try: 6 i = next(a1) 7 print('for循环中取出值:', i) 8 except StopIteration: 9 break 10 11B.__next__()方法被调用 12for循环中取出值: 1 13B.__next__()方法被调用 14for循环中取出值: 2 15B.__next__()方法被调用 16for循环中取出值: 3 17B.__next__()方法被调用 18 19# 作为一个迭代器，B类对象也可以通过for循环来迭代： 20>>> for i in B([1, 2, 3]): 21 print('for循环中取出值:',i) 22 23B.__iter__()方法被调用 24B.__next__()方法被调用 25for循环中取出值: 1 26B.__next__()方法被调用 27for循环中取出值: 2 28B.__next__()方法被调用 29for循环中取出值: 3 30B.__next__()方法被调用 看出来了吗？这就是for循环的本质。 3 生成器 3.1 迭代器与生成器 如果一个函数体内部使用yield关键字，这个函数就称为生成器函数，生成器函数调用时产生的对象就是生成器。生成器是一个特殊的迭代器，在调用该生成器函数时，Python会自动在其内部添加__iter__()方法和__next__()方法。把生成器传给 next() 函数时， 生成器函数会向前继续执行， 执行到函数定义体中的下一个yield语句时， 返回产出的值， 并在函数定义体的当前位置暂停， 下一次通过next()方法执行生成器时，又从上一次暂停位置继续向下……，最终， 函数内的所有yield都执行完，如果继续通过yield调用生成器， 则会抛出StopIteration 异常——这一点与迭代器协议一致。 1>>> from collections.abc import Iterable 2>>> from collections.abc import Iterator 3>>> def gen(): 4 print('第1次执行') 5 yield 1 6 print('第2次执行') 7 yield 2 8 print('第3次执行') 9 yield 3 10 11 12>>> g = gen() 13>>> isinstance(g, Iterable) 14True 15>>> isinstance(g, Iterator) 16True 17>>> g 18<generator object gen at 0x0000021CE9A39A98> 19>>> next(g) 20第1次执行 211 22>>> next(g) 23第2次执行 242 25>>> next(g) 26第3次执行 273 28>>> next(g) 29Traceback (most recent call last): 30 File "<pyshell#120>", line 1, in <module> 31 next(g) 32StopIteration 可以看到，生成器的执行机制与迭代器是极其相似的，生成器本就是迭代器，只不过，有些特殊。那么，生成器特殊在哪呢？或者说，有了迭代器，为什么还要用生成器？ 从上面的介绍和代码中可以看出，生成器采用的是一种惰性计算机制，一次调用也只会产生一个值，它不会将所有的值一次性返回给你，你需要一个那就调用一次next()方法取一个值，这样做的好处是如果元素有很多（数以亿计甚至更多），如果用列表一次性返回所有元素，那么会消耗很大内存，如果我们只是想要对所有元素依次一个一个取出来处理，那么，使用生成器就正好，一次返回一个，并不会占用太大内存。 举个例子，假设我们现在要取1亿以内的所有偶数，如果用列表来实现，代码如下 1def fun_list(): 2 index = 1 3 temp_list = [] 4 while index < 100000000: 5 if index % 2 == 0: 6 temp_list.append(index) 7 print(index) 8 index += 1 9 return temp_list 上面程序会先获取所有符合要求的偶数，然后一次性返回。如果你运行了代码，你就会发现两个问题——运行时间很长、消耗很多内存。 有时候，我们并不一定需要一次性获得所有的对象，需要一个使用一个就可以，这样的话，可以用生成器来实现： 1>>> def fun_gen(): 2 index = 1 3 while index < 100000000: 4 if index % 2 == 0: 5 yield index 6 index += 1 7>>> fun_gen() 8<generator object fun_gen at 0x00000222DC2F4360> 9>>> g = fun_gen() 10>>> next(g) 112 12>>> next(g) 134 14>>> next(g) 156 看到了吗？对生成器没执行一次next()方法，就会返回一个元素，这样的话无论在速度上还是机器性能消耗上都会好很多。如果你还没感受到生成器的优势，我再说一个应用场景，假如需要取出远程数据库中的100万条记录进行处理，如果一次性获取所有记录，网络带宽、内存都会有很大消耗，但是如果使用生成器，就可以取一条，就在本地处理一条。 不过，生成器也有不足，正因为采用了惰性计算，你不会知道下一个元素是什么，更不会知道后面还有多少元素，所以，对于列表、元组等结构，我们能调用len()方法获知长度，但是对于生成器却不能。 总结一下迭代器与生成器的异同： 生成器是一种特殊的迭代器，拥有迭代器的所有特性； 迭代器使用return返回值而生成器使用yield返回值每一次对生成器执行next()都会在yield处暂停； 迭代器和生成器虽然都执行next()方法时返回下一个元素，迭代器在实例化前就已知所有元素，但是采用惰性计算机制，共有多少元素，下一个元素是什么都是未知的，每一次对生成器对象执行next()方法才会产生下一个元素。 3.2 生成器解析式 使用过列表解析式吗？语法格式为：[返回值 for 元素 in 可迭代对象 if 条件] 看下面代码: 1>>> li = [] 2>>> for i in range(5): 3 if i%2==0: 4 li.append(i**2) 5 6>>> li 7[0, 4, 16] 我们可以用列表解析式实现同样功能： 1>>> li = [i**2 for i in range(5) if i%2==0] 2>>> li 3[0, 4, 16] 4>>> type(li) 5<class 'list'> 很简单对不对？简洁了很多，返回的li就是一个列表。咳咳……偏题了，我们要说的是生成器解析式，而且我相信打开我这篇博文的同学大多都熟悉列表解析式，回归正题。 生成器解析式语法格式为：(返回值 for 元素 in 可迭代对象 if 条件) 你没看错，跟列表解析式相比，生成器解析式只是把方括号换成了原括号。来感受一下： 1>>> g = (i**2 for i in range(5) if i%2==0) 2>>> g 3<generator object <genexpr> at 0x00000222DC2F4468> 4>>> next(g) 50 6>>> next(g) 74 8>>> next(g) 916 10>>> next(g) 11Traceback (most recent call last): 12File "<pyshell#38>", line 1, in <module> 13next(g) 14StopIteration 可以看到，生成器解析式返回的就是一个生成器对象，换句话说生成器解析式是生成器的一种定义方式，这种方式简单快捷，当然实现的功能不能太复杂。 我的补充:{返回值 for 元素 in 可迭代对象 if 条件} 是集合解析式。用法和列表解析式是一样的，就是把中括号 [ ]换成大括号 { } 需要注意得是，集合解析式，最终生成的也是集合，集合里面的元素必须是hashable。 Hashable:一个对象能被称为 hashable ， 它必须有个 hash 值，这个值在整个生命周期都不会变化，而且必须可以进行相等比较，所以一个对象可哈希，它必须实现__hash__() 与 __eq__() 方法。 对于 Python 的内建类型来说，只要是创建之后无法修改的(immutable)类型都是 hashable 如字符串，可变动的都是 unhashable的比如：列表、字典、集合，他们在改变值的同时却没有改变id,无法由地址定位值的唯一性,因而无法哈希。我们自定义的类的实例对象默认也是可哈希的（hashable），而hash值也就是它们的id()。 4 总结 本文全面总结了Python中可迭代对象、迭代器、生成器知识，我相信，只要你认真消化我这篇博文，就能深刻领悟迭代器生成器。