Python yield 使用淺析

您可能據說過，帶有 yield 的函數在 Python 中被稱之爲 generator（生成器），何謂 generator ？

咱們先拋開 generator，以一個常見的編程題目來展現 yield 的概念。

如何生成斐波那契數列

斐波那契（Fibonacci）數列是一個很是簡單的遞歸數列，除第一個和第二個數外，任意一個數均可由前兩個數相加獲得。用計算機程序輸出斐波那契數列的前 N 個數是一個很是簡單的問題，許多初學者均可以輕易寫出以下函數：

清單 1. 簡單輸出斐波那契數列前 N 個數

 def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        print b 
        a, b = b, a + b 
        n = n + 1

執行 fab(5)，咱們能夠獲得以下輸出：

 >>> fab(5) 
 1 
 1 
 2 
 3 
 5

結果沒有問題，但有經驗的開發者會指出，直接在 fab 函數中用 print 打印數字會致使該函數可複用性較差，由於 fab 函數返回 None，其餘函數沒法得到該函數生成的數列。

要提升 fab 函數的可複用性，最好不要直接打印出數列，而是返回一個 List。如下是 fab 函數改寫後的第二個版本：

清單 2. 輸出斐波那契數列前 N 個數第二版

 def fab(max): 
    n, a, b = 0, 0, 1 
    L = [] 
    while n < max: 
        L.append(b) 
        a, b = b, a + b 
        n = n + 1 
    return L

可使用以下方式打印出 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 異常，循環會正常結束。