生成器 yield

由于生成器的其中一种创建方式与列表推导式很相似，这里先说一下列表推导式。

列表推导式

列表推导式又叫列表生成式，官方叫做 list comprehension。顾名思义，这个是用来生成列表的。

用法：

[x for x in iterable]

一般情况下，可以用list()函数将序列转换成列表，比如：

>>> list(range(1, 11))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

上面的情况比较单一，如果复杂一点，比如要生成[1x1, 2x2, 3x3, ..., 10x10]，这个时候就只能循环了，列表推导式就是用来简化这种情况的。

>>> [x * x for x in range(1, 11)]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

把要生成的元素x * x放在前面，后面跟for循环，就可以把列表创建出来。运用列表推导式，可以写出非常简洁的代码。

>>> L = ['Hello', 'World', 'IBM', 'Apple']

>>> [s.lower() for s in L]

['hello', 'world', 'ibm', 'apple']

生成器表达式

通过列表推导式，可以直接生成一个列表，但是内存是有限的，如果一个列表太大，或者只需要访问列表中的部分元素，那其余大部分元素占用的空间就浪费了，生成器就是用来解决这个问题的。

生成器在访问序列中的元素时，不是一下加载整个序列到内存，而是一边循环一边计算，也就是读取一个元素计算一次，这样如果序列很大就节省了大量空间。说白了，生成器就是一种特殊的迭代器。

生成器有两种创建方法，第一种与列表推导式类似，只需要把列表推导式中的方括号[]改成圆括号()即可创建一个生成器（generator）。

>>> L = [x * x for x in range(10)]

>>> L

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> g = (x * x for x in range(10))

>>> g

<generator object <genexpr> at 0x0000000001E74CA8>

>>> for i in g:

... 	print(i)

...

0

1

4

9

16

25

36

49

64

81

创建生成器的第二种方法，是通过生成器函数。所谓生成器函数，就是在一个函数中包含yield语句。

比如斐波那契函数：

>>> def fib(max):

        n, a, b = 0, 0, 1

        while n < max:

            yield b

            a, b = b, a + b

            n = n + 1

        return 'done'

... ... ... ... ... ... ...

带有 yield 的函数不再是一个普通函数，而是一个generator。

>>> fib(10)

<generator object fib at 0x0000000001DE6A40>

>>> list(fib(10))

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

需要注意的是，生成器函数和普通函数执行的流程是不一样的。普通函数是遇到 return 语句或者执行结束就返回。而生成器函数是遇到 yield 就返回一个迭代值，再次执行时从上次返回的 yield 语句处继续执行，看起来就像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前迭代值。

好像说的有点绕，简单来说，yield就是中断函数并返回迭代值，而且中断不会对函数变量造成影响即状态不变，返回迭代值之后继续执行函数。

再看看下面这个示例：

>>> def odd():

        print('step 1')

        yield 1

        print('step 2')

        yield(3)

        print('step 3')

        yield(5)

>>> odd()

<generator object odd at 0x0000000001DE6A98>

>>> for i in odd():

... 	print(i)

...

step 1

1

step 2

3

step 3

5

遇到yield就返回迭代值，这个返回类似return但不会退出函数（可以理解为挂起），然后继续执行函数，直到再次遇到yield。

另外，上面生成器函数fib()最后的retrun的值没有返回（在普通函数中是可以返回的）。因为，调用生成器函数并没有执行函数代码，而是返回了一个generator object，然后再从generator object中迭代取值的时候才会真正执行函数代码，所以调用生成器函数的时候并没有报异常并退出，return的值也没有返回。

在生成器中，无论迭代有没有完成，遇到return语句都会直接终止迭代并抛出StopIteration异常。。

这里顺便说一下迭代器，迭代器可以通过内置函数next()获取迭代器中的下一个元素，迭代完成时会报StopIteration异常。

>>> g = (x * x for x in range(5))

>>> next(g)

0

>>> next(g)

1

>>> next(g)

4

>>> next(g)

9

>>> next(g)

16

>>> next(g)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

在 for 循环里，无需处理 StopIteration 异常，循环会正常结束。但是在while循环中会抛出异常，这时，需要捕获异常才会继续执行return语句，return的返回值包含在StopIteration的value中。

>>> g=fib(6)

>>> while True:

        x = next(g)

        print('g:', x)

... ... ...

g: 1

g: 1

g: 2

g: 3

g: 5

g: 8

Traceback (most recent call last):

  File "<stdin>", line 2, in <module>

StopIteration: done

再来看上面的fib()函数的StopIteration异常捕获：

>>> g = fib(6)

>>> while True:

        try:

            x = next(g)

            print('g:', x)

        except StopIteration as e:

            print('Generator return value:', e.value)

            break

... ... ... ... ... ... ...

g: 1

g: 1

g: 2

g: 3

g: 5

g: 8

Generator return value: done

另一个示例，文件读取：

如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。

如果读取的文件很大，yield会分批返回，有效地避免了内存占用问题，轻松实现文件读取。

>>> def read_file(fpath):

        BLOCK_SIZE = 1024

        with open(fpath, 'rb') as f:

            while True:

                block = f.read(BLOCK_SIZE)

                if block:

                    yield block

                else:

                    return

>>> g = read_file('users.txt')

>>> for i in g:

... 	print(i)

...

b'keith1:18:110\r\nkeith2:19:111\r\nkeith3:20:112\r\nkeith4:21:113'

参考：

https://docs.python.org/3/library/stdtypes.html#lists

https://docs.python.org/3/reference/simple_stmts.html#the-yield-statement

https://docs.python.org/3/reference/expressions.html#yieldexpr

巴特西

生成器 yield

列表推导式

生成器表达式

最新文章

热门文章