python yield用法總結

本文是在總結了這四篇文章之后的結果：

http://blog.csdn.net/preterhuman_peak/article/details/40615201

http://blog.csdn.net/buaa_shang/article/details/8281559

http://www.jb51.net/article/15717.htm

http://blog.csdn.net/mingc0758/article/details/53783001

 

從最常見的裴波那切數列說起

斐波那契（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

 

清單 3. 通過 iterable 對象來迭代

 

會導致生成一個 1000 個元素的 List，而代碼：

 

則不會生成一個 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是生成的意思，但是在python中則是作為生成器理解，生成器的用處主要可以迭代，這樣簡化了很多運算模型。

 

yield是一個表達式,是有返回值的.

 

當一個函數中含有yield時,它不再是一個普通的函數,而是一個生成器.當該函數被調用時不會自動執行,而是暫停,見第一個例子:

例1：

>>> def mygenerator():
...     print 'start...'
...     yield 5
... 
>>> mygenerator()            //在此處調用,並沒有打印出start...說明存在yield的函數沒有被運行,即暫停
<generator object mygenerator at 0xb762502c>
>>> mygenerator().next()     //調用next()即可讓函數運行.
start...
5
>>> 

如一個函數中出現多個yield則next()會停止在下一個yield前,見例2:

例2:

>>> def fun2():
...     print 'first'
...     yield 5
...     print 'second'
...     yield 23
...     print 'end...'
... 
>>> g1 = fun2()
>>> g1.next()             //第一次運行,暫停在yield 5             
first
5
>>> g1.next()             //第二次運行,暫停在yield 23
second
23
>>> g1.next()             //第三次運行,由於之后沒有yield,再次next()就會拋出錯誤
end...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 

為什么yield 5會輸出5,yield 23會輸出23?

我們猜測可能是因為yield是表達式,存在返回值.

那么這是否可以認為yield 5的返回值一定是5嗎？實際上並不是這樣，這個與send函數存在一定的關系，這個函數實質上與next()是相似的，區別是send是傳遞yield表 達式的值進去，而next不能傳遞特定的值，只能傳遞None進去，因此可以認為g.next()和g.send(None)是相同的。見例3:

例3:

>>> def fun():
...     print 'start...'
...     m = yield 5
...     print m
...     print 'middle...'
...     d = yield 12
...     print d
...     print 'end...'
... 
>>> m = fun()              //創建一個對象
>>> m.next()               //會使函數執行到下一個yield前
start...
5
>>> m.send('message')      //利用send()傳遞值
message                    //send()傳遞進來的 
middle...
12
>>> m.next()
None                       //可見next()返回值為空
end...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

 

 

至此還沒有說yield在這種語句“m = yield 5”的用法，下面詳細描述

 

1. 包含yield的函數

假如你看到某個函數包含了yield，這意味着這個函數已經是一個Generator，它的執行會和其他普通的函數有很多不同。比如下面的簡單的函數：

def h():
    print 'To be brave'
    yield 5

h()

可以看到，調用h()之后，print 語句並沒有執行！這就是yield，那么，如何讓print 語句執行呢？這就是后面要討論的問題，通過后面的討論和學習，就會明白yield的工作原理了。

2. yield是一個表達式

Python2.5以前，yield是一個語句，但現在2.5中，yield是一個表達式(Expression)，比如：

m = yield 5

表達式(yield 5)的返回值將賦值給m，所以，認為 m = 5 是錯誤的。那么如何獲取(yield 5)的返回值呢？需要用到后面要介紹的send(msg)方法。

3. 透過next()語句看原理

現在，我們來揭曉yield的工作原理。我們知道，我們上面的h()被調用后並沒有執行，因為它有yield表達式，因此，我們通過next()語句讓它執行。next()語句將恢復Generator執行，並直到下一個yield表達式處。比如：

def h():
    print 'Wen Chuan'
    yield 5
    print 'Fighting!'

c = h()
c.next()

c.next()調用后，h()開始執行，直到遇到yield 5，因此輸出結果：

Wen Chuan
5 #在交互式環境中才會出現5，在文件中運行則沒有。 原因：在交互式環境中，會顯示表達式的值；在文件中運行代碼只會輸出打印的值

當我們再次調用c.next()時，會繼續執行，直到找到下一個yield表達式。由於后面沒有yield了，因此會拋出異常（以下結果也是在交互式環境中運行的）：

>>> c.next()
Fighting!
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

4. send(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語句來接收這個值。

5. send(msg) 與 next()的返回值

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 . 12

執行邏輯：

第8行：產生生成器c

第9行：調用c.next()，函數停留在第三行，把5作為c.next()的返回值，然后生成器暫停；

第10行：調用c.send('Fighting!')，從第三行繼續執行，send函數的參數'Fighting!'作為yield的返回值，並賦值給左側變量m，然后繼續執行到第四行，遇到yield，停止執行，12作為c.send('Fighting!')的返回值。

最終，輸出第二行的print，第四行的m。Wen Chuan Fighting!；然后，

第11行：由於第九行的m為5，第10行的d為12，在第十一行輸出：We will never forget the date 5 . 12

驗證例子（為了更好的理解，請手動驗證輸出）：

import time  
def func(n):  
    for i in range(0, n):  
        arg = yield i  
        print('func:', arg)  
  
f = func(10)  
while True:  
    print('main:', next(f))  
    print('main:', f.send(100))  
    time.sleep(1)  

 

6. throw() 與 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)的話會拋出一個異常：

執行的代碼：

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
c.close()
d = c.send('Fighting!')  #d 獲取了yield 12 的參數值12
print 'We will never forget the date', m, '.', d

報錯結果：

Traceback (most recent call last):
Wen Chuan
  File "C:/Users/alan/workspace/demo/yield_test.py", line 62, in <module>
    d = c.send('Fighting!')  #d 獲取了yield 12 的參數值12
StopIteration

 

關於yield和協程的關系，請參考：http://python.jobbole.com/86069/

 

如有不對的地方，歡迎批評指正！