python-for迭代与生成

转载:为什么for循环可以遍历list:Python中迭代器与生成器

作者:奥辰 原文链接:https://www.cnblogs.com/chenhuabin/p/11288797.html

本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接,否则保留追究法律责任的权利。

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()方法获知长度,但是对于生成器却不能。

总结一下迭代器与生成器的异同:

  1. 生成器是一种特殊的迭代器,拥有迭代器的所有特性;
  2. 迭代器使用return返回值而生成器使用yield返回值每一次对生成器执行next()都会在yield处暂停;
  3. 迭代器和生成器虽然都执行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中可迭代对象、迭代器、生成器知识,我相信,只要你认真消化我这篇博文,就能深刻领悟迭代器生成器。