今天是週一Python專題，給大家帶來的是Python當中生成器和迭代器的使用。

我當初第一次學到迭代器和生成器的時候，並沒有太在意，只是覺得這是一種新的獲取資料的方法。對於獲取資料的方法而言，我們會一種就足夠了。但是在我後來Python的使用以及TensorFlow等學習使用當中，我發現很多地方都用到了迭代器和生成器，或者是直接使用，或者是借鑑了思路。所以我們不能掉以輕心，今天就讓我們仔細來看看，它們到底是怎麼回事。

迭代器

我們先從迭代器^[1]開始入手，迭代器並不是Python獨有的概念，在C++和Java當中都有iterator的概念，兩者的使用也都差不多。迭代器主要解決了一個問題，在一個複雜場景下，獲取資料怎麼儘可能簡便。

我們來假設一個場景，假設我們從某個資料來源獲取了一批資料。然後我們需要呼叫前一萬條生成一個結果，得到結果之後，我們要將剩下的資料交給另一個呼叫方去處理。這個過程看起來非常平常，但是隱藏了兩個問題，第一個問題是如果我們能保證第一次處理的時候，每次都是使用一萬條還好說，如果我們使用的條數是一個動態的值呢？顯然，我們需要一個變數來記錄我們究竟用了多少條資料，和這批資料的狀態。其次，如果這個資料量很大會存在一個數據傳輸的問題。我們每次都要將一大批資料傳來傳去，顯然會消耗很多資源。

還有一個場景是如果我們開發的是一個比較複雜的資料結構，比如一棵多叉樹，下游想要遍歷它的時候，必須要了解它的實現原理才行。這顯然也不太友好。

迭代器的出現正是針對以上這些問題，它的含義也很簡單，有點像是我們遍歷連結串列的時候用到的cur的指標。永遠指向當前的位置，永遠知道下一個位置在哪裡。

容器迭代器

我們先從簡單的元素迭代器開始瞭解它的用途，我們都知道Python當中經典的幾個容器：list, tuple和dict。它們都是一個可迭代物件，我們可以直接使用關鍵字iter獲取一個對應的迭代器。

我們來看一個例子：

arr = [1, 3, 4, 5, 9]

it = iter(arr)

print(next(it))
print(next(it))

這是一個非常經典的例子，我們首先定義了一個數組，然後通過iter關鍵字獲取了一個讀取它的迭代器。有了迭代器之後我們可以通過next關鍵字獲取迭代器當中的下一個元素，我們一共呼叫了兩次next，第一次輸出的結果是1，第二次的結果是3。和我們剛才說的一樣，我們每一次呼叫，它會自動往後移動一格，獲取後面一位的資料。

這裡有一點需要注意，因為我們建立的陣列當中一共只有5個元素，如果我們呼叫it的次數超過5次，那麼會引發超界，Python的直譯器會丟擲StopIteration的error。

除了使用next，我們也可以使用for迴圈來迭代它：

for i in it:
    print(i)

這種用法就和我們用for迴圈遍歷元素是一樣的。

自定義迭代器

官方的迭代器的用法就這麼多，這也不是它的主要用法，它最主要的用法是我們自己建立迭代器。和之前介紹Python自定義排序的時候的思路一樣，我們為類新增上__iter__方法和__next__方法即可。

其中__iter__方法用來初始化並返回迭代器，關於它的解釋比較複雜。在Python當中迭代有兩個概念一個是iterable，一個是iterator。協議規定iteratble的__iter__方法會返回一個iterator。而iterator本身也是一個iterable物件，自然也需要實現__iter__方法。

我知道這麼說可能聽不太明白，我舉個例子，比如說員工和老闆，員工沒有審批許可權，只能轉達給老闆。我們把員工比喻成iterable物件，老闆比喻成iterator。

員工面臨一個問題的時候沒有許可權處理，只能找來老闆決定。也就是最終決定的是老闆，但如果是老闆自己發現的問題，他完全可以自己就解決了，不需要再去找其他人。所以說我們用iter呼叫iterable物件的__iter__的時候，會得到一個iterator，也就是呼叫員工返回老闆，然後通過呼叫iterator的__next__來進行迭代。

到這裡也就清楚了，只有iterator有__next__方法，而iterable沒有，並且__iter__返回的是一個iterator。然而我們定義的已經是iterator了，它同時也是一個iterable物件，所以呼叫__iter__時只需要返回self就好了。__next__方法很簡單，對應迭代器的next方法，用來返回下一個迭代的元素。

我們來看一個例子：

class PowTwo:
    """Class to implement an iterator
    of powers of two"""

    def __init__(self, max = 0):
        self.max = max

    def __iter__(self):
        self.n = 0
        return self

    def __next__(self):
        if self.n <= self.max:
            result = 2 ** self.n
            self.n += 1
            return result
        else:
            raise StopIteration

這是一個簡單的生成2的冪的迭代器，我們在__iter__裡為self.n初始化為0，然後返回自身。在__next__裡判斷有沒有迭代結束，如果結束的話丟擲一個異常。

我們來看使用它的例子：

>>> a = PowTwo(4)
>>> i = iter(a)
>>> next(i)
1
>>> next(i)
2
>>> next(i)
4
>>> next(i)
8
>>> next(i)
16
>>> next(i)
Traceback (most recent call last):
...
StopIteration

我們也可以用for迴圈來迭代它：

>>> for i in PowTwo(5):
...     print(i)
...     
1
2
4
8
16
32

迭代器除了可以迭代一個容器或者是像上面這樣自定義迭代方法之外，還可以用來迭代生成器。下面就讓我們一起來看下生成器的概念。

生成器

生成器的概念和迭代器相輔相成，迭代器是生成一個遍歷資料的迭代工具，而生成器則是資料生成工具。

舉個很簡單的例子，比如說斐波那契數列我們都知道，從第三個數開始等於前面兩個數的和。比如我們想獲取100萬個斐波那契數列，按照傳統的方法我們需要開闢一個長度是一百萬的陣列，然後按照斐波那契數列的定義一個一個地計算。顯然這樣會消耗大量的空間，有沒有辦法我們和迭代器那樣構建一個生成資料的方法，我們每次呼叫獲取下一個結果呢？這樣我們要多少資料就呼叫多少次就可以了，從根本上解決了儲存的問題。

下面我們來看怎麼定義一個生成器。

括號建立法

最簡單的方法真的很簡單，和我們建立list基本上一模一樣。

在Python當中，我們經常這樣初始化一個數組：

arr = [i * 3 for i in range(10)]

也就是說我們把迴圈放在list的定義當中，這樣Python會自動執行裡面的迴圈，然後將所有迴圈的結果進行二次計算後寫入到list當中去。我們稍微變形一下，就得到了一個最簡單的生成器。

g = (i * 3 for i in range(10))

print(next(g))

看清楚了嗎，其實和list沒什麼差別，只是我們將最外層的括號從[]換成了()。

這種方法大家應該都能看懂，但是可能會有一個疑惑。我們這樣做的意義是什麼呢？這樣和上面用[]定義有什麼區別呢？

其實是有區別的，如果沒有區別，那麼我們用生成器也就沒有意義了。它的區別也就是生成器的意義，簡單來說，我們前文中已經說過了當定義一個list的時候，Python會自動將for迴圈執行一遍，然後將結果寫入進list當中。但是生成器不會，雖然我們也用到了for迴圈，但是它只是起到了限制個數的作用，在執行完這一步之後，Python並不會將for迴圈執行結束。只有我們每次呼叫next，才會觸發它進行一次迴圈。

不相信的同學可以試試，看看執行一下下面兩個語句的區別：

g = (i for i in range(1000000000))
g = [i for i in range(1000000000)]

如果奇怪的事情發生了，不妨再回到文章來思考一下。

函式建立法

上面介紹的方法雖然簡單，但是不太實用，因為很多時候我們想要的資料構造方法會比較複雜，很難用這種形式展現出來。

所以Python當中還為我們提供了一種構造生成器的方法，相比起來要稍微複雜一點點，但是也很好用。我們來看一個例子：

def gtr(n):
    for i in range(n):
        yield i

從程式碼上來看，我們好像定義了一個函式，某種程度上可以這麼理解，但是它返回的結果並不是一個值，而是一個生成器^[2]。

如果你真的去試了，你會得到一個generator型別的例項，這也是Python自帶的生成器的例項。

再仔細觀察一下，你會發現這個函式當中的關鍵字和一般的不太一樣，它沒有使用return，而是使用了yield。yield和return在很大程度上很接近，但是又有些不同。

相同點是當我們執行到yield時，和return一樣會將yield之後的內容返回給呼叫方。比如上面程式碼當中寫到yield i，那麼我們執行next的時候就會獲取到這個i。

不同的地方是，當我們下一次再次執行的時候，會繼續從yield處開始往下執行。有些類似於遞迴的時候，底層的遞迴執行結束回到上層的情況。因此如果我們要獲取多個值，需要在生成器當中使用迴圈。舉個例子：

def test():
    n = 0
    while True:
        if n < 3:
            yield n
            n += 1
        else:
            yield 10
            
            
if __name__ == '__main__':
    t = test()
    for i in range(10):
        print(next(t))

我們如果執行上面這段程式碼，前三個數是0，1和2，從第四個數開始一直是10。如果你能看懂這個例子，一定能明白yield的含義。

yield from

接下來要介紹的yield from和yield用法差不多，也是從生成器返回一個結果，並且下次執行的時候從返回的位置開始繼續執行。

但是它有一點和yield不同，我們來看一個經典的例子。

def g1():     
     yield  range(5)
def g2():
     yield  from range(5)

it1 = g1()
it2 = g2()
for x in it1:
    print(x)

for x in it2:
    print(x)

這兩者打印出來的結果是一樣的，但是邏輯完全不同。在第一個生成器g1當中，直接通過yield返回了一個迭代器。也就是說我們for迴圈執行的其實是range(5)，而第二個生成器g2則通過yield from獲取了range(5)這個迭代器當中的值進行的返回。

也就是說yield from可以返回一個迭代器或者是生成器執行next之後的結果。

最後，我們來看一個yield from使用的一個經典場景：二叉樹的遍歷：

class Node:

    def __init__(self, key):
        self.key = key
        self.lchild = None
        self.rchild = None
        self.iterated = False
        self.father = None

    def iterate(self):
        if self.lchild is not None:
            yield from self.lchild.iterate()
        yield self.key
        if self.rchild is not None:
            yield from self.rchild.iterate()

在這個程式碼當中我們定義了二叉樹當中的一個節點，以及它對應的迭代方法。由於我們用到了yield來返回結果，所以iterate方法本質是一個生成器。再來看iterate方法內部，我們通過yield from呼叫了iterate，所以我們在執行的時候，它會自動繼續解析node.lchild的iterate，也就是說我們通過yield from實現了遞迴。

當我們建好樹之後，可以直接使用root.iterate來遍歷整棵樹。

class Tree:

    def __init__(self):
        #建樹過程
        self.root = Node(4)
        self.root.lchild = Node(3)
        self.root.lchild.father = self.root
        self.root.rchild = Node(5)
        self.root.rchild.father = self.root
        self.root.lchild.lchild = Node(1)
        self.root.lchild.lchild.father = self.root.lchild
        self.root.rchild.rchild = Node(7)
        self.root.rchild.rchild.father = self.root.rchild

    def iterate(self):
        yield from self.root.iterate()

通過yield from，我們可以很輕鬆地利用遞迴的思路來實現樹上的生成器。從而可以很方便地以生成器的思路來遍歷樹上所有的元素。

到這裡，關於Python當中迭代器和生成器的知識就算是講完了，這兩者的概念有些接近，但是又不完全一樣，很多初學者容易搞混淆。

其實可以這麼理解，迭代器和生成器遍歷元素的方式是一樣的，都是通過呼叫next來獲取下一個元素。我們通過yield建立函式，返回的結果其實就是生成器生成的資料的迭代器。也就是說迭代器只是迭代和獲取資料的，但是並不能無中生有地創造資料。而生成器的主要作用是創造資料，它生成出來的資料是以迭代器的形式返回的。

舉個例子，你開了一個奶茶店，通過奶茶店每個月可以在銀行賬戶裡獲得一筆收入。迭代器就是這個賬戶，通過它你可以獲得一筆一筆的收入。而奶茶店則是一個生成器，它產出資料，但是是以迭代器的形式返回給你的，也就是以銀行賬戶的方式給你收入。我們拿到銀行卡並不知道它裡面的錢是怎麼賺來的，只能看到錢，也就是說我們並不知道迭代器背後資料的邏輯。但是生成器我們是清楚的，因為錢（生產邏輯）是我們親自賺來的。

今天的文章就是這些，如果覺得有所收穫，請順手點個關注或者轉發吧，你們的舉手之勞對我來說很重要。

參考資料