yield關鍵字使用

利用 iterable 咱們能夠把 fab 函數改寫爲一個支持 iterable 的 class,如下是三個版本的 Fab:html

清單 4. 第三個版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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() 不斷返回數列的下一個數,內存佔用始終爲常數:函數

1
2
3
4
5
6
7
8
>>> for n in Fab(5):
...     print n
...
1
1
2
3
5

然而,使用 class 改寫的這個版本,代碼遠遠沒有初版的 fab 函數來得簡潔。若是咱們想要保持初版 fab 函數的簡潔性,同時又要得到 iterable 的效果,yield 就派上用場了:spa

清單 5. 使用 yield 的第四版
1
2
3
4
5
6
7
8
9
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 徹底一致:code

1
2
3
4
5
6
7
8
>>> 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。htm

也能夠手動調用 fab(5) 的 next() 方法(由於 fab(5) 是一個 generator 對象,該對象具備 next() 方法),這樣咱們就能夠更清楚地看到 fab 的執行流程:對象

清單 6. 執行流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> 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 異常,循環會正常結束。ip

咱們能夠得出如下結論:內存

一個帶有 yield 的函數就是一個 generator,它和普通函數不一樣,生成一個 generator 看起來像函數調用,但不會執行任何函數代碼,直到對其調用 next()(在 for 循環中會自動調用 next())纔開始執行。雖然執行流程仍按函數的流程執行,但每執行到一個 yield 語句就會中斷,並返回一個迭代值,下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函數在正常執行的過程當中被 yield 中斷了數次,每次中斷都會經過 yield 返回當前的迭代值。ci

yield 的好處是顯而易見的,把一個函數改寫爲一個 generator 就得到了迭代能力,比起用類的實例保存狀態來計算下一個 next() 的值,不只代碼簡潔,並且執行流程異常清晰。

如何判斷一個函數是不是一個特殊的 generator 函數?能夠利用 isgeneratorfunction 判斷:

清單 7. 使用 isgeneratorfunction 判斷
1
2
3
>>> from inspect import isgeneratorfunction
>>> isgeneratorfunction(fab)
True

要注意區分 fab 和 fab(5),fab 是一個 generator function,而 fab(5) 是調用 fab 返回的一個 generator,比如類的定義和類的實例的區別:

清單 8. 類的定義和類的實例
1
2
3
4
5
>>> import types
>>> isinstance(fab, types.GeneratorType)
False
>>> isinstance(fab(5), types.GeneratorType)
True

fab 是沒法迭代的,而 fab(5) 是可迭代的:

1
2
3
4
5
>>> from collections import Iterable
>>> isinstance(fab, Iterable)
False
>>> isinstance(fab(5), Iterable)
True

每次調用 fab 函數都會生成一個新的 generator 實例,各實例互不影響:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> 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 的例子
1
2
3
4
5
6
7
8
9
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 中調試經過

相關文章
相關標籤/搜索