【Python】理解yield和generator(生成器)
Overview
本文整理自：
[1] Python yield 使用淺析 —— 廖雪峰
[2] 深入理解yield —— Python中文開發者社群
如何生成斐波那契數列
斐波那契（Fibonacci）數列是一個非常簡單的遞迴數列，除第一個和第二個數外，任意一個數都可由前兩個數相加得到。用計算機程式輸出斐波那契數列的前 N 個數是一個非常簡單的問題，許多初學者都可以輕易寫出如下函式：
清單 1. 簡單輸出斐波那契數列前 N 個數
def fab(max):
n, a, b = 0, 0, 1
while n < max:
print 執行 fab(5)，我們可以得到如下輸出：
>>> fab(5)
1
1
2
3
5結果沒有問題，但有經驗的開發者會指出，直接在 fab 函式中用 print 列印數字會導致該函式可複用性較差，因為 fab 函式返回 None，其他函式無法獲得該函式生成的數列。
要提高 fab 函式的可複用性，最好不要直接打印出數列，而是返回一個 List。以下是 fab 函式改寫後的第二個版本：
清單 2. 輸出斐波那契數列前 N 個數第二版
def fab(max) 可以使用如下方式打印出 fab 函式返回的 List：
>>> for n in fab(5):
... print n
...
1
1
2
3
5改寫後的 fab 函式通過返回 List 能滿足複用性的要求，但是更有經驗的開發者會指出，該函式在執行中佔用的記憶體會隨著引數 max 的增大而增大，如果要控制記憶體佔用，最好不要用 List
來儲存中間結果，而是通過 iterable 物件來迭代。例如，在 Python2.x 中，程式碼：
清單 3. 通過 iterable 物件來迭代
for i in range(1000): pass會導致生成一個 1000 個元素的 List，而程式碼：
for i in xrange(1000): pass則不會生成一個 1000 個元素的 List，而是在每次迭代中返回下一個數值，記憶體空間佔用很小。因為 xrange 不返回 List，而是返回一個 iterable 物件。
利用 iterable 我們可以把 fab 函式改寫為一個支援 iterable 的 class，以下是第三個版本的 Fab：
清單 4. 第三個版本
class Fab(object):
def __init__(self, max):
self.max = max
self.n, self.a, self.b = 0, 0, 1
def __iter__(self):
return self
def next(self):
if self.n < self.max:
r = self.b
self.a, self.b = self.b, self.a + self.b
self.n = self.n + 1
return r
raise StopIteration()Fab 類通過 next() 不斷返回數列的下一個數，記憶體佔用始終為常數：
>>> for n in Fab(5):
... print n
...
1
1
2
3
5然而，使用 class 改寫的這個版本，程式碼遠遠沒有第一版的 fab 函式來得簡潔。如果我們想要保持第一版 fab 函式的簡潔性，同時又要獲得 iterable 的效果，yield 就派上用場了：
清單 5. 使用 yield 的第四版
def fab(max):
n, a, b = 0, 0, 1
while n < max:
yield b
# print b
a, b = b, a + b
n = n + 1
'''第四個版本的 fab 和第一版相比，僅僅把 print b 改為了 yield b，就在保持簡潔性的同時獲得了 iterable 的效果。
呼叫第四版的 fab 和第二版的 fab 完全一致：
>>> for n in fab(5):
... print n
...
1
1
2
3
5簡單地講，yield 的作用就是把一個函式變成一個 generator，帶有 yield 的函式不再是一個普通函式，Python 直譯器會將其視為一個 generator，呼叫 fab(5) 不會執行 fab 函式，而是返回一個 iterable 物件！在 for 迴圈執行時，每次迴圈都會執行 fab 函式內部的程式碼，執行到 yield b 時，fab 函式就返回一個迭代值，下次迭代時，程式碼從 yield b 的下一條語句繼續執行，而函式的本地變數看起來和上次中斷執行前是完全一樣的，於是函式繼續執行，直到再次遇到 yield。
也可以手動呼叫 fab(5) 的 next() 方法（因為 fab(5) 是一個 generator 物件，該物件具有 next() 方法），這樣我們就可以更清楚地看到 fab 的執行流程：
清單 6. 執行流程
>>> f = fab(5)
>>> f.next()
1
>>> f.next()
1
>>> f.next()
2
>>> f.next()
3
>>> f.next()
5
>>> f.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration當函式執行結束時，generator 自動丟擲 StopIteration 異常，表示迭代完成。在 for 迴圈裡，無需處理 StopIteration 異常，迴圈會正常結束。
我們可以得出以下結論：
一個帶有 yield 的函式就是一個 generator，它和普通函式不同，生成一個 generator 看起來像函式呼叫，但不會執行任何函式程式碼，直到對其呼叫 next()（在 for 迴圈中會自動呼叫 next()）才開始執行。雖然執行流程仍按函式的流程執行，但每執行到一個 yield 語句就會中斷，並返回一個迭代值，下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函式在正常執行的過程中被 yield 中斷了數次，每次中斷都會通過 yield 返回當前的迭代值。
yield 的好處是顯而易見的，把一個函式改寫為一個 generator 就獲得了迭代能力，比起用類的例項儲存狀態來計算下一個 next() 的值，不僅程式碼簡潔，而且執行流程異常清晰。
如何判斷一個函式是否是一個特殊的 generator 函式？可以利用 isgeneratorfunction 判斷：
清單 7. 使用 isgeneratorfunction 判斷
>>> from inspect import isgeneratorfunction
>>> isgeneratorfunction(fab)
True要注意區分 fab 和 fab(5)，fab 是一個 generator function，而 fab(5) 是呼叫 fab 返回的一個 generator，好比類的定義和類的例項的區別：
清單 8. 類的定義和類的例項
>>> import types
>>> isinstance(fab, types.GeneratorType)
False
>>> isinstance(fab(5), types.GeneratorType)
Truefab 是無法迭代的，而 fab(5) 是可迭代的：
>>> from collections import Iterable
>>> isinstance(fab, Iterable)
False
>>> isinstance(fab(5), Iterable)
True每次呼叫 fab 函式都會生成一個新的 generator 例項，各例項互不影響：
>>> f1 = fab(3)
>>> f2 = fab(5)
>>> print 'f1:', f1.next()
f1: 1
>>> print 'f2:', f2.next()
f2: 1
>>> print 'f1:', f1.next()
f1: 1
>>> print 'f2:', f2.next()
f2: 1
>>> print 'f1:', f1.next()
f1: 2
>>> print 'f2:', f2.next()
f2: 2
>>> print 'f2:', f2.next()
f2: 3
>>> print 'f2:', f2.next()
f2: 5return 的作用
在一個 generator function 中，如果沒有 return，則預設執行至函式完畢，如果在執行過程中 return，則直接丟擲 StopIteration 終止迭代。
另一個例子
另一個 yield 的例子來源於檔案讀取。如果直接對檔案物件呼叫 read() 方法，會導致不可預測的記憶體佔用。好的方法是利用固定長度的緩衝區來不斷讀取檔案內容。通過 yield，我們不再需要編寫讀檔案的迭代類，就可以輕鬆實現檔案讀取：
清單 9. 另一個 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:
returnsend(msg) 與 next() 及返回值
瞭解了next()如何讓包含yield的函式執行後，我們再來看另外一個非常重要的函式send(msg)。其實next()和send()在一定意義上作用是相似的，區別是send()可以傳遞yield表示式的值進去，而next()不能傳遞特定的值，只能傳遞None進去。因此，我們可以看做c.next() 和 c.send(None) 作用是一樣的。
來看這個例子：
def h():
print 'Wen Chuan',
m = yield 5 # Fighting!
print m
d = yield 12
print 'We are together!'
c = h()
c.next() # 相當於c.send(None)
c.send('Fighting!') # (yield 5)表示式被賦予了'Fighting!'輸出的結果為：
Wen Chuan Fighting!需要提醒的是，第一次呼叫時，請使用next()語句或是send(None)，不能使用send傳送一個非None的值，否則會出錯的，因為沒有yield語句來接收這個值。
send(msg) 和 next()是有返回值的，它們的返回值很特殊，返回的是下一個yield表示式的引數。比如yield 5，則返回 5 。到這裡，是不是明白了一些什麼東西？本文第一個例子中，通過for i in alist 遍歷 Generator，其實是每次都呼叫了alist.Next()，而每次alist.Next()的返回值正是yield的引數，即我們開始認為被壓進去的東東。我們再延續上面的例子：
def h():
print 'Wen Chuan',
m = yield 5 # Fighting!
print m
d = yield 12
print 'We are together!'
c = h()
m = c.next() # m 獲取了yield 5 的引數值 5
d = c.send('Fighting!') # d 獲取了yield 12 的引數值12
print 'We will never forget the date', m, '.', d輸出結果：
Wen Chuan Fighting!
We will never forget the date 5 . 12throw() 與 close()中斷 Generator
中斷Generator是一個非常靈活的技巧，可以通過throw丟擲一個GeneratorExit異常來終止Generator。Close()方法作用是一樣的，其實內部它是呼叫了throw(GeneratorExit)的。我們看：
def close(self):
try:
self.throw(GeneratorExit)
except (GeneratorExit, StopIteration):
pass
else:
raise RuntimeError("generator ignored GeneratorExit")
# Other exceptions are not caught因此，當我們呼叫了close()方法後，再呼叫next()或是send(msg)的話會丟擲一個異常：
Traceback (most recent call last):
File "/home/evergreen/Codes/yield.py", line 14, in <module>
d = c.send('Fighting!') #d 獲取了yield 12 的引數值12
StopIteration希望能夠對大家有所幫助~