Python generator和yield介紹

Python生成器(generator)並不是一個晦澀難懂的概念。相比於MetaClass和Closure等概念，其較為容易理解和掌握。但相對於程序結構：順序、循環和分支而言其又不是特別的直觀。無論學習任何的東西，概念都是非常重要的。正確樹立並掌握一些基礎的概念是靈活和合理運用的前提，本文將以一種通俗易懂的方式介紹一下generator和yield表達式。

1. Iterator與Iterable

首先明白兩點：

1. Iterator(迭代器)是可迭代對象;
2. 可迭代對象並不一定是Iterator;

比較常見的數據類型list、tuple、dict等都是可迭代的，屬於collections.Iterable類型；

迭代器不僅可迭代還可以被內置函數next調用，屬於collections.Iterator類型；

迭代器是特殊的可迭代對象，是可迭代對象的一個子集。

將要介紹的gererator(生成器)是types.GeneratorType類型，也是collections.Iterator類型。

也就是說生成器是迭代器，可被next調用，也可迭代。

三者的包含關系：（可迭代（迭代器（生成器）））

迭代器：可用next()函數訪問的對象；

生成器：生成器表達式和生成器函數；

2. Python生成器

python有兩種類型的生成器：生成器表達式和生成器函數。

由於生成器可迭代並且是iterator，因此可以通過for和next進行遍歷。

2.1 生成器表達式

把列表生成式的[]改成()便得到生成器表達式。

>>> gen = (i + i for i in xrange(10))
>>> gen
<generator object <genexpr> at 0x0000000003A2DAB0>
>>> type(gen)
<type 'generator'>
>>> isinstance(gen, types.GeneratorType) and isinstance(gen, collections.Iterator) and isinstance(gen, collections.Iterable)
True
>>> 

2.2 生成器函數

python函數定義中有關鍵字yield，該函數便是一個生成器函數，函數調用返回的是一個generator.

def yield_func():
    for i in xrange(3):
        yield i
gen_func = yield_func()
for yield_val in gen_func:
    print yield_val

生成器函數每次執行到yield便會返回，但與普通函數不同的是yield返回時會保留當前函數的執行狀態，再次被調用時可以從中斷的地方繼續執行。

2.3 next與send

通過for和next可以遍歷生成器，而send則可以用於向生成器函數發送消息。

def yield_func():
    for i in xrange(1, 3):
        x = yield i
        print 'yield_func',x
gen_func = yield_func()
print 'iter result: %d' % next(gen_func)
print 'iter result: %d' % gen_func.send(100)

結果：

iter result: 1
yield_func 100
iter result: 2

簡單分析一下執行過程：

• line_no 5 調用生成器函數yield_func得到函數生成器gen_func；
• line_no 6 使用next調用gen_func，此時才真正的開始執行yield_func定義的代碼；
• line_no 3 執行到yield i，函數yield_func暫停執行並返回當前i的值1.
• line_no 6 next(gen_func)得到函數yield_func執行到yield i返回的值1，輸出結果iter result: 1；
• line_no 7 執行gen_func.send(100);
• line_no 3 函數yield_func繼續執行，並將調用者send的值100賦值給x;
• line_no 4 輸出調用者send接收到的值；
• line_no 3 執行到yield i，函數yield_func暫停執行並返回當前i的值2.
• line_no 7 執行gen_func.send(100)得到函數yield_func運行到yield i返回的值2，輸出結果iter result: 2；

如果在上面代碼后面再加一行：

print 'iter result: %d' % next(gen_func)

結果：

iter result: 1
yield_func 100
iter result: 2
yield_func None
File "G:\Cnblogs\Alpha Panda\Main.py", line 22, in <module>
    print 'iter result: %d' % next(gen_func)
StopIteration

 yield_func只會產生2個yield，但是我們迭代調用了3次，會拋出異常StopIteration。

next和send均會觸發生成器函數的執行，使用for遍歷生成器函數時不要用send。原因后面解釋。

2.4 生成器返回值

使用了yield的函數嚴格來講已經不是一個函數，而是一個生成器。因此函數中yield和return是不能同時出現的。

SyntaxError: 'return' with argument inside generator

生成器只能通過yield將每次調用的結果返回給調用者。

2.5 可迭代對象轉成迭代器

list、tuple、dict等可迭代但不是迭代器的對象可通過內置函數iter轉化為iterator，便可以通過next進行遍歷；

這樣的好處是可以統一使用next遍歷所有的可迭代對象；

tup = (1,2,3)
for ele in tup:
    print ele + ele

上面的代碼等價於：

tup_iterator = iter(tup)
while True:
    try:
        ele = next(tup_iterator)
    except StopIteration:
        break
    print ele + ele

for循環使用next遍歷一個迭代器，混合使用send可能會導致混亂的遍歷流程。

其實到這里生成器相關的概念基本已經介紹完成了，自己動手過一遍應該能弄明白了。為了更加深刻的體會生成器，下面我們在往前走一步。

3. range與xrange

在Python 2中這兩個比較常用，看一下兩者的區別：

• range為一個內置函數，xrange是一個類；
• 前者返回一個list，后者返回一個可迭代對象；
• 后者遍歷操作快於前者，且占用更少內存；

 這里xrange有點類似於上面介紹的生成器表達式，雖然xrange返回的並不是生成器，但兩者均返回並不包含全部結果可迭代對象。

3.1 自定義xrange的Iterator版本

作為一個iterator:

The iterator objects themselves are required to support the following two methods, which together form the iterator protocol:

iterator. __iter__ ()

Return the iterator object itself. This is required to allow both containers and iterators to be used with the for and in statements. This method corresponds to the tp_iter slot of the type structure for Python objects in the Python/C API.

iterator. next ()

Return the next item from the container. If there are no further items, raise the StopIteration exception. This method corresponds to the tp_iternext slot of the type structure for Python objects in the Python/C API.

下面我們自定義class my_xrange:

class my_xrange(object):
    def __init__(self, start, stop = None, step = 1):
        """ 僅僅為了演示，假設start, stop 和 step 均為正整數 """
        self._start = 0 if stop is None else start
        self._stop = start if stop is None else stop
        self._step = step
        self._cur_val = self._start

    def __iter__(self):
        return self

    def next(self):
        if self._start <= self._cur_val < self._stop:
            cur_val = self._cur_val
            self._cur_val += self._step
            return cur_val
        raise StopIteration

測試結果：

import collections
myxrange = my_xrange(0, 10, 3)
res = []
for val in myxrange:
    res.append(val)
print res == range(0, 10, 3)　　　# True print isinstance(myxrange, collections.Iterator)　　# True
print isinstance(myxrange, types.GeneratorType)　　# False

3.2 使用函數生成器

下面使用函數生成器定義一個generator版的xrange。

def xrange_func(start, stop, step = 1):
    """ 僅僅為了演示，假設start, stop 和 step 均為正整數 """
    cur_val = start
    while start <= cur_val and cur_val < stop:
        yield cur_val
        cur_val += step

isinstance(myxrange, collections.Iterator) and isinstance(myxrange, types.GeneratorType) is True

上面兩個自定義xrange版本的例子，均說明生成器以及迭代器保留數列生成過程的狀態，每次只計算一個值並返回。這樣只要占用很少的內存即可表示一個很大的序列。

4. 應用

不管是迭代器還是生成器，對於有大量有規律的數據產生並需要遍歷訪問的情景均適用，占用內存少而且遍歷的速度快。其中一個較為經典的應用為斐波那契數列(Fibonacci sequence)。

這里以os.walk遍歷目錄為例來說明yield的應用。如果我們需要遍歷一個根目錄下的所有文件並根據需要進行增刪改查。可能會遇到下列的問題：

預先遍歷且緩存結果，但是目錄下文件可能很多，而且會動態改變；如果不緩存，多個地方可能會頻繁的需要訪問這一結果導致效率低下。

 這時候可以使用yield定義一個生成器函數。

def get_all_dir_files(target_dir):
    for root, dirs, files in os.walk(target_dir):
        for file in files:
            file_path = os.path.join(root, file)
            yield os.path.realpath(file_path)

def file_factory(file):
    """ do something """

target_dir = './'
all_files = get_all_dir_files(target_dir)
for file in all_files:
    file_factory(file)

  限於篇幅，就先介紹到這里，希望本文能讓你對生成器有一個新的認識。