目录
一、绪论
在《【Python】详解 可迭代对象 (iterable) 与 迭代器 (iterator) —— 迭代器完全解读(上) 》一文中，详细解读了相关概念及其原理，并文末提到了另一种迭代器 —— 生成器 (generator)。事实上，在诸如 C、C++、JAVA 等主流语言中，并无生成器的概念。而在 Python 中，生成器则与迭代器相辅相成 —— 迭代器 是 生成一个遍历数据的迭代工具，而 生成器 则是 一个数据生成工具。
举个典例：已知，斐波那契数列从第三个数开始等于前两数之和。假设想获取 1024 万个斐波那契数列，按传统方法需开辟一个长度为 1024 万的数组，再按照斐波那契数列定义逐个计算 —— 显然内存限制下，不可能同时创建如此多元素。即便可以创建，也会占用大量存储空间。而且倘若仅需访问其中几个元素，那么大部分元素的空间都浪费了。
那么，可否像迭代器那样构建一个生成数据的方法，每次调用才获取下一个结果，而不是将所有结果都存在内存中呢？这就是 生成器 —— 一种 惰性序列，需要多少就调用多少次 —— 按需生成，以从根本上解决存储问题。
二、生成器 (generator)
2.1 说明
生成器 (generator) 用于 返回 生成器迭代器 (generator iterator)。已知：
- 可迭代对象 (iterable)：支持 迭代协议 (实现了 __iter__() 方法)
- 迭代器 (iterator)：支持 迭代器协议 (实现了 __iter__() 和 __next__() 方法)
生成器 无需显式定义 __iter__() 和__next__() 方法，因为实例化生成器对象后将 自动支持迭代器协议，故 生成器也是一种迭代器，是实现迭代器协议的便捷方式，写法更为紧凑。
通常，使用两种方式创建生成器：生成器函数 及 生成 (器) 表达式。(生成器通常默认指前者)
2.2 生成器函数
2.2.1 原理概述
生成器函数 用于创建 生成器迭代器 (generator iterator)。
与普通函数的 区别 在于：普通函数 使用 return 返回结果，而 生成器函数 使用 yield 返回结果。
使用了 yield 表达式 的生成器函数 返回一个迭代器对象，以便于通过 for 循环或 next() 函数等逐项获取元素/数据/值/成员 (以下统称 元素)。换言之，使用了 yield 表达式的函数就是生成器函数。
更具体地，在调用生成器函数时，每次遇到 yield 表达式，生成器函数就会 暂停并保存当前位置的执行状态 (包括局部变量和挂起的 try 语句)，然后 返回 yield 表达式的值，并在 下一次对生成器函数执行 next() 方法 时，从上次离开的位置继续执行 (有别于每次调用普通函数都重新从头开始)。
例如，生成斐波那契数列前 max 个数，使用 普通函数 ：
>>> def fib_common(max):
a, b, counter = 0, 1, 0
while counter < max:
print(a)
a, b = b, a + b
counter += 1
return
>>> fib_common(8) # max=8
0
1
1
2
3
5
8
13 此时，将 print(a) 改成 yield a 即得 生成器函数：
>>> def fib_gen(max):
a, b, counter = 0, 1, 0
while counter < max:
yield a # fib_gen() 因此变为生成器函数
a, b = b, a + b
counter += 1
return定义一个 生成器对象 fg，检验其性质：
>>> fg = fib_gen(8) # max=8
>>> fg
<generator object fib_gen at 0x0000020E3F704780>
>>> from collections import Iterable, Iterator, Generator # 导入抽象基类检验
>>> isinstance(fg, Iterable), isinstance(fg, Iterator), isinstance(fg, Generator) # 可见生成器对象也是一种可迭代对象
(True, True, True)可见，含有 yield 表达式 的 生成器函数，其实例 是生成器 (generator)，也是迭代器 (iterator)，更为可迭代对象 (iterable)。这时，要想迭代生成器的各项元素，就必须 显式或隐式地调用 next() 函数，一个一个地计算结果：
>>> import sys
>>> while True:
try:
print(next(fg)) # 显式调用 next() 获取生成器对象的元素
except StopIteration:
sys.exit()
0
1
1
2
3
5
8
132.2.2 yield 表达式
上节并未直观地展现 yield 表达式 的原理，因而由本节举例说明。自定义一个生成器函数：
>>> def num_gen(): # 因为包含 yield 表达式, 所以该函数是生成器函数
index = 0
print('index=', index)
yield 0
index += 1
print('index=', index)
yield 1
index += 1
print('index=', index)
yield 2
>>> hasattr(num_gen, '__next__') # 生成器函数 num_gen() 并未显式支持迭代器协议
False调用该生成器函数时，需要先实例化一个 生成器 (迭代器) 对象：
>>> ng = num_gen()
>>> hasattr(ng, '__iter__'), hasattr(ng, '__next__') # 实例化后的对象自动支持迭代器协议, 而无需显式定义
(True, True) # 可见生成器也是迭代器 (自然也是可迭代对象)
可见，生成器函数的实例对象 自动支持迭代器协议 (自动创建 __iter__() 和 __next__() 方法)。再使用 next() 函数或调用 __next__() 方法依次获取下一项：
>>> next(ng)
index=0
0
>>> ng.__next__() # 可见每次重新调用, 都会从上一次执行中断的位置状态继续
index=1
1
>>> next(ng) # index 的变化就证明了上述结论
index=2
2
>>> next(ng) # 生成器作为迭代器, 同样会因为迭代元素的耗尽而引发 StopIteration 异常
Traceback (most recent call last):
File "<pyshell#126>", line 1, in <module>
next(ng)
StopIteration根据 print() 函数的打印结果可知，函数每次遇到 yield 就返回 yield 表达值中的值 (和 return 一样会将 yield 后的内容返回给调用方)，然后中断执行退出函数，保存当前位置状态，并在下一次调用 next() 时恢复所保存的位置状态，继续往下执行。可以说，每次调用 next() 都相当于执行一个 代码块，而代码块之间的是由 yield 表达式分隔的。生成器作为迭代器，同样会因为迭代元素的耗尽而引发 StopIteration 异常，以避免无限迭代。
注意，上述解读提到了 每次 yield 中断执行都会保存当前位置状态，而 num_gen() 函数的局部变量 index 状态变化就证明了这一点。而若以 return 取代 yield 则会变回普通函数，那么每次调用函数都不会保存前向调用的状态，而是重新从头初始化状态。
此外，还有一种 yield from 表达式 可以返回一个迭代器或生成器执行 next 后的结果，暂不赘述。
2.3 生成器表达式
事实上，除了用生成器函数来创建生成器，还可以通过另一种简洁的方式 —— 生成器表达式。
形式上，生成器表达式类似于列表推导式，但使用的是 圆括号 () 而非方括号 []；结果上，生成器表达式不会像列表推导式一样一次性返回所有计算结果，而是通过 延迟计算，按需生成。可以说，生成器表达式结合了迭代功能和解析功能。
>>> [i for i in range(4)] # 列表推导式 / 列表解析式
[0, 1, 2, 3] # 返回完整列表对象
>>> (j for j in range(4)) # 生成器表达式
<generator object <genexpr> at 0x0000020E3F704888> # 返回一个生成器对象生成器表达式可认为是一种特殊的生成器函数，类似于 lambda 表达式之于普通函数的关系。虽然形式上更简洁、紧凑，但生成器表达式同样能够返回一个生成器(迭代器)。
因为生成器也是迭代器、可迭代对象，所以适用于后者的函数同样适用于前者并常配合使用，例如：
>>> sum(j for j in range(4)) # sum(iterable, start=0, /)
6
>>> min(j for j in range(4)) # min(iterable, *[, default=obj, key=func])
0
>>> max(j for j in range(4)) # max(iterable, *[, default=obj, key=func])
3
# -----------------------------------------------------------------------------------
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(i+j for i, j in zip(x, y)) # zip(iter1 [,iter2 [...]])
[5, 7, 9]事实上，生成器表达器比列表推导式更高效，例如：
>>> sum((j for j in range(4))) # 为方便, 也可省略生成器表达式的内层圆括号
6
>>> sum([j for j in range(4)]) # 列表推导式写法
6上述两个例子中，生成器表达式一边生成元素一边求和，而 列表推导式却先计算出一个完整列表再求和，从而后者多出的操作引起了时间效率的 落后。
此外，要逐个输出元素，需要先实例化生成器对象(使用变量保存生成器对象的引用/指向生成器对象)，再使用 __next__() 方法 或 next() 函数获取下一项元素，例如：
>>> str_gen = (s for s in 'abc')
>>> str_gen
<generator object <genexpr> at 0x0000020E3F704888>
>>> str_gen.__next__()
'a'
>>> next(str_gen)
'b'
>>> str_gen.__next__()
'c'
>>> next(str_gen)
Traceback (most recent call last):
File "<pyshell#167>", line 1, in <module>
next(str_gen)
StopIteration总而言之，生成器不会将所有的元素一次性加载到内存中，而是 延迟计算，一次计算一个结果。
生成器的 优点 是：代码简洁紧凑、可读性好、时效较高等；缺点 在于：只能依次往下迭代一轮，而不能回退和重复迭代。
参考文献：
扫一扫
153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
