python迭代器和生成器

发表于 | 更新于 | 分类于 | 阅读次数：

迭代器 Iterator

使用 isinstance() 判断一个对象是否是可迭代(Iterable)对象

1
2
3
4
In [50]: from collections import Iterable
In [51]: isinstance([], Iterable)
Out[51]: True

可迭代对象通过 __iter__ 方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器(通过 __iter__ 方法获取)，然后通过这个迭代器来依次获取对象中的每一个数据.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> class MyList(object):
...     def __init__(self):
...             self.container = []
...     def add(self, item):
...             self.container.append(item)
...     def __iter__(self):
...             """返回一个迭代器"""
...             # 我们暂时忽略如何构造一个迭代器对象
...             pass
...
>>> mylist = MyList()
>>> from collections import Iterable
>>> isinstance(mylist, Iterable)
True

iter()函数与next()函数

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的 __iter__ 方法；next()函数实际上就是调用了迭代器的 __next__ 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> li = [11, 22, 33, 44, 55]
>>> li_iter = iter(li)
>>> next(li_iter)
11
>>> next(li_iter)
22
>>> next(li_iter)
33
>>> next(li_iter)
44
>>> next(li_iter)
55
>>> next(li_iter)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出 StopIteration 的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。

迭代器Iterator 自己实现迭代器

通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__ 方法（Python3中是对象的 __next__ 方法）。所以，我们要想构造一个迭代器，就要实现它的 __next__ 方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现 __iter__ 方法，而 __iter__ 方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的 __iter__ 方法返回自身即可。

一个实现了 __iter__ 方法和 __next__ 方法的对象，就是迭代器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []
    def add(self, val):
        self.items.append(val)
    def __iter__(self):
        myiterator = MyIterator(self)
        return myiterator
class MyIterator(object):
    """自定义的供上面可迭代对象使用的一个迭代器"""
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问到的位置
        self.current = 0
    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration
    def __iter__(self):
        return self
if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)

for...in... 循环的本质

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

迭代器的应用场景

不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, … 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class FibIterator(object):
    """斐波那契数列迭代器"""
    def __init__(self, n):
        """
        :param n: int, 指明生成数列的前n个数
        """
        self.n = n
        # current用来保存当前生成到数列中的第几个数了
        self.current = 0
        # num1用来保存前前一个数，初始值为数列中的第一个数0
        self.num1 = 0
        # num2用来保存前一个数，初始值为数列中的第二个数1
        self.num2 = 1
    def __next__(self):
        """被next()函数调用来获取下一个数"""
        if self.current < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1+self.num2
            self.current += 1
            return num
        else:
            raise StopIteration
    def __iter__(self):
        """迭代器的__iter__返回自身即可"""
        return self
if __name__ == '__main__':
    fib = FibIterator(10)
    for num in fib:
        print(num, end=" ")

生成器 generator

简单来说：只要在函数中有yield关键字的 就称为 生成器
生成器(generator)：生成器是一类特殊的迭代器。所以也可以通过 next() 方法和 for in 遍历

通过生成器表达式创建

只要把一个列表生成式的 [ ] 改成 ( )

1
2
3
4
5
6
7
8
9
In [15]: L = [ x*2 for x in range(5)]
In [16]: L
Out[16]: [0, 2, 4, 6, 8]
In [17]: G = ( x*2 for x in range(5))
In [18]: G
Out[18]: <generator object <genexpr> at 0x7f626c132db0>

通过 yield 创建

方法中只要含有 yield 就是一个生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
In [30]: def fib(n):
   ....:     current = 0
   ....:     num1, num2 = 0, 1
   ....:     while current < n:
   ....:         num = num1
   ....:         num1, num2 = num2, num1+num2
   ....:         current += 1
                 # 关键点
   ....:         yield num
   ....:     return 'edone'
   ....:
In [31]: F = fib(5)
In [32]: next(F)
Out[32]: 0
In [33]: next(F)
Out[33]: 1
In [34]: next(F)
Out[34]: 1
In [35]: next(F)
Out[35]: 2
In [36]: next(F)
Out[36]: 3
In [37]: next(F)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-37-8c2b02b4361a> in <module>()

其实就是将原本在迭代器 __next__ 方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的 return 换成了 yield

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [39]: g = fib(5)
In [40]: while True:
   ....:     try:
   ....:         x = next(g)
   ....:         print("value:%d"%x)      
   ....:     except StopIteration as e:
   ....:         print("生成器返回值:%s"%e.value)
   ....:         break
   ....:     
value:1
value:1
value:2
value:3
value:5
生成器返回值:edone

yield关键字有两点作用：

  1. 保存当前运行状态（当前环境），然后暂停执行，即将生成器（函数）挂起
  2. 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用
    可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

使用send唤醒

我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。generator.send(None) == next(generator) 。

例子：执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send(“python”)，send发送过来的值，c.next()等价c.send(None)又等价于 c.__next__()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
In [10]: def gen():
   ....:     i = 0
   ....:     while i<5:
   ....:         temp = yield i
   ....:         print(temp)
   ....:         i+=1
   ....:
使用send
In [43]: f = gen()
In [44]: next(f)
Out[44]: 0
In [45]: f.send('haha')
haha
Out[45]: 1
In [46]: next(f)
None
Out[46]: 2

再举个例子我们看一下 send 数据是如何生效的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python3
# -*-coding:utf-8-*-
def test():
    i = 1
    print('one line')
    temp = yield i
    i += 1
    print('two line', temp)
    yield i
# 获取生成器
gen = test()
# one line
next(gen)
# 这个send的数据是发送给上一个yield点上进行接收的
# two line haha
gen.send('haha')

其实 send数据时数据给的是上一个yield断点进行接收的

yield from generator

yield from generator 基本可以理解成把生成器 generator 的代码替换了 yield from 所在位置， 可以先看代码示例好理解

  1. 为了让生成器（带yield函数），能简易的在其他函数中直接调用，就产生了yield from。
  2. 以下代码，htest为生成器，itest通过 yield from 直接调用htest。这样itest也变成了一个生成器。创建itest实例不断的去获取数据，当生成器执行结束时，会抛出 StopIteration 异常。那这个异常是htest抛出的，还是itest抛出的。通过捕获异常，会发现其实是itest抛出异常，htest并不会抛出 StopIteration 异常。
  3. yield from 也可以返回值，通过变量接收。变量接收的值，即htest使用return返回的值。示例代码中，当i==3时，会直接使用return返回，这时val的值就是100；因为htest函数中不是使用yield返回值，所以itest会继续执行print(val)语句。itest代码执行完，然而并没有使用yield返回数据（htest中没有，itest中也没有），所以马上会抛出StopIteration异常)(如果在itest函数最后使用yield返回一个数据，就不会抛出异常)。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    def htest():
        i = 1
        while i < 4:
            print('i的值', i)
            n = yield i
            print('n的值', n)
            if i == 3:
                return 100
            i += 1
    def itest():
        val = yield from htest()
        print('val的值', val)
    t = itest()
    # i的值 1
    t.send(None)
    # n的值 haha
    # i的值 2
    t.send('haha')
    # n的值 here
    # i的值 3
    t.send('here')
    try:
        # n的值 hehe
        # val的值 100
        t.send('hehe')
    except StopIteration as e:
        # 异常了 None
        print('异常了', e.value)

yield from参考

迭代器和生成器的关系

看过上面我们应该可以看出相似点和不同点了

  1. 迭代对象，遍历的时候需要先通过 __iter__ 来获取到迭代器，然后通过 __next__ 来一步一步往下执行
  2. 生成器相当于直接就等于迭代对象通过 __iter__ 所返回的对象，直接可以通过 __next__ 来一步一步来进行执行
echo-ding wechat
欢迎您扫一扫上面的微信公众号，订阅我的博客！
坚持原创技术分享，您的支持将鼓励我继续创作！