Python yield 使用淺析（轉）

add by zhj: 說到yield，就要說說迭代器、生成器、生成器函數。

迭代器：其實就是一個可迭代對象，書上說迭代器，我我的不喜歡這個說法，有點晦澀。可迭代對象基本上能夠認爲是有__iter__()和next()方法的對象，儘管這個定義並不嚴謹。

生成器：其實也是一個可迭代對象，但它是一種特殊的可迭代對象（即特殊的迭代器）。它的特殊性在於它是經過中斷的形式實現next()，無需對象自己保存狀態，另外生成器還有

           send(),throw()等方法，這是迭代器沒有的。迭代器是調用next()方法後就直接return了，狀態需程序員保存在迭代器對象中，下次再調用時知道從哪裏開始。而生成器

           調用next()方法時，遇到yield返回，併產生中斷，保存狀態，這樣程序員就不須要對象本身保存狀態。爲何Python要有生成器呢？當函數返回的是一個特別大的序列

           時，這個序列是很是佔內存的，yield和生成器也所以而生，生成器在迭代時每次生成一個數據，這樣內存的消耗就很小。不過，生成器遍歷完後就不能再遍歷了，沒法恢復

           到初始狀態。這也算是生成器的一個缺點吧，不知道之後能不能改進。在itertools模塊中有不少方法用於迭代器，其中tee能夠複製一個迭代器，但複製後原始的迭代器貌

           似不能用了。另外，對生成器的索引貌似也沒有太好的辦法，切片索引後對原生成器是有影響的。

           所以，生成器的應用場合爲：生成的序列比較大，且不須要經過索引訪問該序列時，用生成器比較方便。

生成器函數：首先，它是一個函數，它跟其它函數惟一不一樣的是，它裏面有yield語句，當調用該函數時，返回的是一個生成器。咱們能夠經過將yield用print

           替換來理解yield。

>>> def fab(max):
             n,a,b=0,0,1
             while n<max:
                 yield b
                 a,b=b,a+b
                 n=n+1
      
>>> a = fab(5)
>>> type(fab)
<type 'function'>
>>> type(a)
<type 'generator'>

 

原文:https://www.ibm.com/developerworks/cn/opensource/os-cn-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 異常，循環會正常結束。

咱們能夠得出如下結論：

一 個帶有 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) 
 True

fab 是沒法迭代的，而 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: 5

回頁首

return 的做用

在一個 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: 
                return

以上僅僅簡單介紹了 yield 的基本概念和用法，yield 在 Python 3 中還有更強大的用法，咱們會在後續文章中討論。

注：本文的代碼均在 Python 2.7 中調試經過