Python 3 之 生成器详解

------ 生成器 ------------------------------------------------------------------

如今Python对延迟提供更多的支持——它提供了工具在需要的时候才产生结果，而不是立即产生结果。特别地，有两种语言结构尽可能地延迟结果创建。

• 生成器函数：编写为常规的def语句，但是使用yield语句一次返回一个结果，在每个结果之间挂起和继续它们的状态。
• 生成器表达式：类似于列表解析，但是，它们返回按需产生结果的一个对象，而不是构建一个结果列表。

由于二者都不会一次性构建一个列表，它们节省了内存空间，并且允许计算时间分散到各个结果请求。我们将会看到，这二者最终都通过实现我们在前面介绍的迭代协议来执行它们延迟结果的魔术。

生成器函数： yield VS return

我们已经学习了编写接收输入参数并立即送回单个结果的常规函数。然而，也有可能来编写可以送回一个值并随后从其退出的地方继续的函数。这样的函数叫做生成器函数，因为它们随着时间产生值的一个序列。

一般来说，生成器函数和常规函数一样，并且，实际上也是用常规的def语句编写的，然而，当创建时，它们自动实现迭代协议，以便可以出现在迭代背景中。

状态挂起

和返回一个值并退出的常规函数不同，生成器函数自动在生成值的时刻挂起 并 继续函数的执行。因此，它们对于提前计算整个一系列值以及在雷总手动保存和恢复状态都很有用。由于生成器函数在挂起时保存的状态包含它们的整个本地作用域，当函数恢复时，它们的本地变量保持了信息并且使其可用。

生成器函数和常规函数之间的主要代码不同之处在于，生成器yields一个值，而不是返回一个值。yield语句挂起该函数并向调用者发送回一个值，但是，保留足够的状态以使得函数能够从它离开的地方继续。当继续时，函数在上一个yield返回后立即继续执行。从函数的角度来看，则允许其代码随着时间产生一系列的值，而不是一次计算他们并在诸如列表的内容中送回它们。

迭代协议整合

要真正地理解生成器函数，我们需要知道，它们与Python中的迭代协议的概念密切相关。正如我们看到的，可迭代的对象定义了一个__next__方法，它要么返回迭代中的下一项，或者引发一个特殊的StopIteration异常来终止迭代。一个对象的迭代器用iter内置函数接收。

如果支持该协议的话，Python的for循环以及其他的迭代背景，使用这种迭代协议来遍历一个序列或值生成器； 如果不支持，迭代返回去重复索引序列。

要支持这一协议，函数包含一条yield语句，该语句特别编译为生成器。当调用时，它们返回一个迭代器对象，该对象支持用一个名为__next__的自动创建的方法来继续执行的接口。生成器函数也可能有一条return语句，总是在def语句块的末尾，直接终止值的生成。 从技术上将，尅在任何常规函数退出执行之后，引发一个StopIteration异常来实现。 从调用者的角度来看，生成器的__next__方法继续函数并且运行到下一个yield结果返回或引发一个StopIteration异常。

直接效果就是生成器函数，编写为包含yield语句的def语句，自动地支持迭代协议，并且由此可能用在任何迭代环境中随着时间并根据需要产生结果。

生成器函数应用

为了讲清楚基础知识，请看如下代码，它定义了一个生成器函数，这个函数将会用来不断地生成一些列的数字的平方。

>>> def gensquares(N):
	for i in range(N):
		yield i ** 2

这个函数在每次循环时都会产生一个值，之后将其返还给它的调用者。当它被暂停后，它的上一个状态保存了下来，并且在yield语句之后控制器马上被回收。例如，当用在一个for循环中时，在循环中每一次完成函数的yield语句后，控制权都会返还给函数。

>>> for i in gensquares(5):
	print(i, end=" : ")

0 : 1 : 4 : 9 : 16 :

为了终止生成值，函数可以使用给一个无值的返回语句，或者在函数体最后简单的让控制器脱离。

如果想要看看在for里面发生了什么，直接调用一个生成器函数：

>>> x = gensquares(4)
>>> x
<generator object gensquares at 0x0000014EF59FEDB0>

得到的是一个生成器对象，它支持迭代器协议，也就是所生成器对象有一个__next__方法，它可以开始这个函数，或者从它上次yield值后的地方恢复，并且在得到一系列的值的最后一个时，产生StopIteration异常。为了方便起见，next(x)内置函数为我们调用一个对象的X.__next__()方法：

>>> next(x)        # 类似py3 的 x.__next__()
0
>>> next(x)        # 在py2 中类似的方法为 x.next() 或 next()
1
>>> next(x)
4
>>> next(x)
9
>>> next(x)
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    next(x)
StopIteration

正如前面学过的，for循环（以及其他的迭代环境）以同样的方式与生成器一起工作：通过重复的__next__方法，知道捕获一个异常。如果一个不支持这种协议的对象进行这样迭代，for循环会使用索引协议进行迭代。

注意在这个例子中，我们能够简单地一次就构建一个所获得的值的列表。

>>> def buildsquares(n):
	res = []
	for i in range(n): res.append(i ** 2)
	return res

>>> for x in buildsquares(5): print(x, end = " : ")

0 : 1 : 4 : 9 : 16 :

对于这样的例子，我们还能够使用for循环、map或者列表解析的技术来实现。

>>> for x in [n ** 2 for n in range(5)]:
	print(x, end=" : ")

0 : 1 : 4 : 9 : 16 : 

>>> for  x in map((lambda n: n ** 2), range(5)):
	print(x, end=" : ")

0 : 1 : 4 : 9 : 16 :

尽管如此，生成器在内存使用和性能方面都更好。它们允许函数避免临时再做所有的工作，当结果的列表很大或者在处理每一个结果都需要很多时间时，这一点尤其有用。生成器将在loop迭代中处理一系列值的时间分布开来。

尽管如此，对于更多高级的应用，它们提供了一个更简单的替代方案来手动将类的对象保存到迭代中的状态。 有了生成器，函数变量就能进行自动的保存和恢复。

扩展生成器函数协议：send 和 next

在Python2.5中，生成器函数协议中增加了一个send方法。send方法生成一系列结果的下一个元素，这一点就像__next__方法一样，但是它也提供了一种调用者与生成器之间进行通信的方法，从而能够影响它的操作。

从技术上来说，yield现在是一个表达式的形式，可以返回传入的元素来发送，而不是一个语句[尽管无论哪种叫法都可以：作为yield X 或者 A = (yield X)]。表达式必须包括在括号中，除非它是赋值语句右边的唯一一项。 例如，X = yield Y没问题，就如同 X = (yield Y) + 42。

当使用这一额外的协议时，值可以通过调用G.send(value)发送给一个生成器G。之后恢复生成器的代码，并且生成器中的yield表达式返回了为了发送而传入的值。如果提前调用了正常的G.__next__()方法(或者其对等的next(G))，yield返回None。例如：

>>> def gen():
	for i in range(10):
		X = yield i
		print(X)

>>> G = gen()
>>> next(G)        # next() 开始生成器
0
>>> G.send(77)     # 高级的的send方法 发送参数给生成器表达式
77
1
>>> G.send(88)
88
2
>>> next(G)        # 返回None
None
3

例如，用send方法，编写一个能够被它的调用者终止的生成器。此外，在2.5版中，生成器还支持throw(type)的方法，它将生成器内部最后一个yield时产生一个异常以及一个close方法，它会在生成器内部产生一个终止迭代的新的GeneratorExit异常。这些都是我们这里不会深入学习的一些高级特性； 需要了解的请查看Python的标准库以获得更多的细节。

注意，尽管Python 3提供了一个next(X)方便的内置函数，它会调用一个对象的X.__next__方法，但是，其他的生成器方法，例如send，必须直接作为生成器对象的方法来调用（例如，G.send(X)）。这么做是有意义的，你要知道，这些额外的方法只是在内置的生成器对象上实现，而__next__方法应用于所有的可迭代对象（包括内置类型和用户定义的类）。

生成器表达式：迭代器遇到列表解析

在最新版本的Python中，迭代器和列表解析的概念形成了这种语言的一个新的特性，生成器表达式。 从语法上来讲，生成器表达式就像一般的列表解析一样，但是它们是括在圆括号中而不是方括号中的。

>>> [x ** 2 for x in range(4)]
[0, 1, 4, 9]

>>> (x ** 2 for x in range(4))        # 生成器表达式
<generator object <genexpr> at 0x0000014EF59FEDB0>

实际上，至少在一个函数的基础上，编写一个列表解析基本上等同于：在一个list内置调用中包含一个生成器表达式以迫使其一次生成列表中所有的结果。

>>> list(x ** 2 for x in range(4))
[0, 1, 4, 9]

尽管如此，从执行过程上来讲，生成器表达式很不相同：不是在内存中构建结果，而是返回一个生成器对象，这个对象将会支持迭代协议并在任意的迭代语境的操作中。

>>> G = (x ** 2 for x in range(4))
>>> next(G)
0
>>> next(G)
1
>>> next(G)
4
>>> next(G)
9
>>> next(G)
Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    next(G)
StopIteration

我们一般不会机械地使用next迭代器来操作生成器表达式，因为for循环会自动触发。

>>> for num in (x ** 2 for x in range(4)):
	print("%s, %s" % (num, num / 2.0))

0, 0.0
1, 0.5
4, 2.0
9, 4.5

实际上，每一个迭代的语境都会这样，包括sum、map 和 sorted等内置函数，以及在前面涉及的其他迭代语境，例如 any、all 和 list内置函数等。

注意，如果生成器表达式是在其他的括号之内，就像在那些函数调用之中，这种情况下，生成器自身的括号就不是必须的了。 尽管这样，在下面第二个sorted调用中，还是需要额外的括号。

>>> sum(x ** 2 for x in range(4))
14
>>> sorted(x ** 2 for x in range(4))
[0, 1, 4, 9]
>>> sorted((x ** 2 for x in range(4)), reverse=True)
[9, 4, 1, 0]

>>> import math
>>> list( map(math.sqrt, (x ** 2 for x in range(4))) )
[0.0, 1.0, 2.0, 3.0]

生成器表达式大体上可以认为是内存空间的优化，它们不需要像方括号的列表解析一样，一次构造出整个列表。它们在实际中运行起来可能稍慢一些，所以它们可能对于非常大的结果集合的运算来说是最优的选择。关于性能的更权威的评价，必须等到最后编写计时脚本的时候给出。

生成器函数 VS 生成器表达式

有趣的是，同样的迭代旺旺可以用一个生成器函数或一个生成器表达式编写。例如，如下的生成式表达式，把一个字符串中的每个字母重复4次。

>>> G = (c * 4 for c in "SPAM")
>>> list(G)
[‘SSSS‘, ‘PPPP‘, ‘AAAA‘, ‘MMMM‘]

等价的生成器函数需要略微多一些的代码，但是，作为一个多语句的函数，如果需要的话，它将能够编写更多的逻辑并使用更多的状态信息。

>>> def timesfour(S):
	for c in S:
		yield c * 4

>>> G = timesfour("spam")
>>> list(G)
[‘ssss‘, ‘pppp‘, ‘aaaa‘, ‘mmmm‘]

表达式和函数支持自动迭代和手动迭代……前面的列表自动调用迭代，如下的迭代手动进行。

>>> G = (c * 4 for c in "SPAM")
>>> i = iter(G)
>>> next(i)
‘SSSS‘
>>> next(i)
‘PPPP‘

>>> G = timesfour(‘spam‘)
>>> I = iter(G)
>>> next(I)
‘ssss‘
>>> next(I)
‘pppp‘

注意，我们使得这里的新的生成器再次迭代，正如下一小节所介绍的，生成器是单次迭代器。

生成器是单迭代器对象

生成器函数和生成器表达式自身都是迭代器，并由此只支持一次活跃迭代……不像一些内置类型，我们无法有在结果集中位于不同位置的多个迭代器。例如，使用前面小节的生成器表达式，一个生成器的迭代器是生成器之神（实际上，在一个生成器上调用iter没有任何效果）。

>>> G = (c * 4 for c in "SPAM")
>>> iter(G) is G
True

如果你手动地使用多个迭代器来迭代结果流，它们将会指向相同的位置。

>>> G = (c * 4 for c in "SPAM")        # 新生成器表达式
>>> I1 = iter(G)
>>> next(I1)
‘SSSS‘
>>> next(I1)
‘PPPP‘
>>> I2 = iter(G)                        # ----
>>> next(I2)
‘AAAA‘

此外，一旦任何迭代器运行到完成，所偶的迭代器都将用尽，我们必须产生一个新的生成器以再次开始。

>>> list(I1)                            # 自动迭代
[‘MMMM‘]
>>> next(I2)                            # I2的手动迭代
Traceback (most recent call last):
  File "<pyshell#156>", line 1, in <module>
    next(I2)
StopIteration                           # 异常
>>> I3 = iter(G)                        # 生成新的迭代器（其实不会生成新的）
>>> next(I3)
Traceback (most recent call last):
  File "<pyshell#158>", line 1, in <module>
    next(I3)
StopIteration                            # 仍旧迭代异常
>>> I3 = iter(c * 4 for c in "SPAM")     # 新的迭代器
>>> next(I3)                             # 开始迭代
‘SSSS‘

对于生成器函数来说，也是如此，如下的基于语句的def等价形式只支持一个活跃的生成器并且在一次迭代之后用尽。

>>> def timesfour(S):
	for c in S:
		yield c * 4

>>> G = timesfour("spam")
>>> iter(G) is G
True
>>> I1, I2 = iter(G), iter(G)
>>> next(I1)
‘ssss‘
>>> next(I1)
‘pppp‘
>>> next(I2)
‘aaaa‘

这与某些内置类型的行为不同，它们支持多个迭代器并且在一个活动迭代器中传递并反映它们的原处修改。

>>> L = [1, 2, 3, 4]
>>> I1, I2 = iter(L), iter(L)
>>> next(I1)
1
>>> next(I1)
2
>>> next(I2)
1
>>> del L[2:]
>>> next(I1)
Traceback (most recent call last):
  File "<pyshell#180>", line 1, in <module>
    next(I1)
StopIteration

当我们开始别写基于类的迭代器时，我们将看到，由我们来决定想要为自己的对象支持多个迭代器。