“Python有什么好學(xué)的”這句話可不是反問句，而是問句哦。

主要是煎魚覺得太多的人覺得Python的語法較為簡單，寫出來的代碼只要符合邏輯，不需要太多的學(xué)習(xí)即可，即可從一門其他語言跳來用Python寫（當(dāng)然這樣是好事，誰都希望入門簡單）。

于是我便記錄一下，如果要學(xué)Python的話，到底有什么好學(xué)的。記錄一下Python有什么值得學(xué)的，對比其他語言有什么特別的地方，有什么樣的代碼寫出來更Pythonic。一路回味，一路學(xué)習(xí)。

為什么是斐波那契

談到生成器/迭代器，人們總是喜歡用斐波那契數(shù)列來舉例。

斐波那契數(shù)列，數(shù)學(xué)表示為a(1)=0, a(2)=1, a(i)=a(i-1)+a(i-2) (i>=3)：
0 1 1 2 3 5 8 13 21 ...
用一句話說，就是第三位數(shù)起，當(dāng)前這位數(shù)是前兩位的和。

當(dāng)然，使用斐波那契來舉例是一個很合適的選擇。

那么，為什么說到生成器/迭代器就喜歡斐波那契，而不是其他呢？

斐波那契數(shù)列有一個特征：當(dāng)前這位數(shù)的值，可以通過前兩位數(shù)的值推導(dǎo)出來。比如，我知道了第n位數(shù)是5，第n+1位數(shù)是8，那我就可以輕易地得出，第n+2位必然是5+8=13。

即，斐波那契數(shù)是可以通過推導(dǎo)式得出的。

就是這樣一種類似于冥冥注定的感覺：當(dāng)前的平行空間，是由你之前的選擇決定的。而且是欽定好的，你接下來的每一步，其實都已經(jīng)被決定了，由什么決定呢，由你以前走過的路決定的。

那么，換句話來說，即能由推導(dǎo)式得出的數(shù)列，其實都可以用來做生成器/迭代器的例子。例如，煎魚用一條式子y(n)=y(n-1)^2 + 1 (n>=1), y(1)=1，一樣能拿來當(dāng)例子。

既然這樣，那就用y(n)=y(n-1)^2 + 1 (n>=1), y(1)=1吧。

原始低效的循環(huán)

一開始，人們的思想很簡單，如果要求y(n)=y(n-1)^2 + 1 (n>=1), y(1)=1中y數(shù)列的第13位，即y(13)，那很簡單，就輪詢到13個就好了。

def y():
    y_current = 1
    n = 1
    while n < 13:
        y_current = y_current ** 2 + 1
        n += 1
        print(n, y_current)

輸出也挺長的，就截個圖算了：

image

這個時候，這個代碼是完全夠用的。接下來，煎魚加點需求（PM般的獰笑）：

1. 暴露n的值，n值可以作為參數(shù)輸入，即我需要控制數(shù)列計算到哪
2. 函數(shù)返回（輸出）整個數(shù)列

接下來，函數(shù)改成：

def y(n_max):
    y_current = 0
    n = 0
    ret_list = []
    while n < n_max:
        y_current = y_current ** 2 + 1
        n += 1
        ret_list.append(y_current)

    return ret_list


if __name__ == '__main__':
    for i in y(13):
        print(i)

看起來沒什么毛病，完全符合要求。但是，問題出現(xiàn)在當(dāng)函數(shù)的參數(shù)n_max較大的時候。要多大呢，煎魚嘗試輸出n_max=13000000，即：

if __name__ == '__main__':
    for i in y(13000000):
        print(i)

我們看得出來，這個函數(shù)的計算量十分大，以煎魚當(dāng)前的電腦配置（Macbook pro 2017 i5 8G RAM），等了一兩分鐘還沒結(jié)束，只好強(qiáng)行中斷了。

image

程序為什么卡那么久呢。因為在函數(shù)的邏輯中，程序試圖將13000000個值都計算出來再返回list以供外接輪詢，而且這13000000個一個比一個難算（越來越大，指數(shù)增長）。同時，該list也占了龐大的內(nèi)存空間。

到了這個時候，煎魚終于要引入生成器了。

生成器的小試牛刀

其實煎魚就加入了一個yield，并稍作修改：

def y_with_yield(n_max):
    y_current = 0
    n = 0
    while n < n_max:
        y_current = y_current ** 2 + 1
        n += 1
        yield y_current
        
if __name__ == '__main__':
    for i in y_with_yield(13000000):
        print(i)

image

雖然屏幕滾動得很慢，但是起碼是在實時地滾動的。

加入了yield變成這樣，其實就是搞成了一個簡單的生成器。在這里，生成器的作用有：

1. for i in y_with_yield(13000000)的循環(huán)中，每一次循環(huán)程序才會進(jìn)入函數(shù)去計算，而不會把全部結(jié)果都計算出來再返回
2. 由于不會把全部結(jié)果都計算出來再返回，程序運(yùn)行所需的內(nèi)存也大幅地減少

暫時給出初步結(jié)論：

1. 這個小生成器在較大數(shù)據(jù)的計算量時，有較大的優(yōu)勢
2. 程序把推導(dǎo)式的計算通過yield分散了，降低了cpu和內(nèi)存的壓力
3. 如果沒有煎魚的需求，這一切都白搭且多余

我們再來看下生成器的其他用途吧。

通過緩存機(jī)制讀取文件

在讀文件或處理文件時使用緩存是很有必要的，因為我們總是不知道文件會有多大，文件的大小會不會把程序給拖垮。

煎魚新建一個文件（假設(shè)叫test.txt），并往其中寫入文本，運(yùn)行以下代碼：

def read_file(file_path):

    BLOCK_SIZE = 100
    with open(file_path, 'rb') as f:
        while True:
            block = f.read(BLOCK_SIZE)
            if block:
                yield block
            else:
                return


if __name__ == '__main__':
    for i in read_file('./test.txt'):
        print(i)
        print('--------------block-split--------------')

我們把100個長度分為一個block，這個block就相當(dāng)于我們的緩存：先從文件中讀100個，然后讓程序處理這100個字符（此處處理為print），再讀下一個100。其中block-split的輸出是為了讓我們更好地辯識出block的頭尾。

image

生成器類和生成器對象

通過yield瞎搞出來的簡易生成器有一個很大的限制，就是必須要在循環(huán)內(nèi)。

雖然“迭代”和“循環(huán)”有關(guān)聯(lián)，但是當(dāng)生成器的生成邏輯無比復(fù)雜時，比如“推導(dǎo)”的方法已經(jīng)無法用數(shù)學(xué)推導(dǎo)式表達(dá)時，或者某種場景下的業(yè)務(wù)邏輯比較復(fù)雜以至于無法直接通過循環(huán)表達(dá)時，生成器類來了。

生成器類看起來很簡單，其實就是將煎魚在上面寫的簡單生成器寫成一個類。

重點就是，我們得找到“推導(dǎo)”，推導(dǎo)在這里是指next函數(shù) —— 我們實現(xiàn)的生成器類最重要的就是next()。

我們來實現(xiàn)上面的y函數(shù)的生成器類：

class Y(object):

    def __init__(self, n_max):
        self.n_max = n_max
        self.n = 0
        self.y = 0

    def __iter__(self):
        return self

    def next(self):
        if self.n < self.n_max:
            self.y = self.y ** 2 + 1
            self.n += 1
            return self.y
        raise StopIteration()


if __name__ == '__main__':
    y = Y(13)
    for i in y:
        print(i)

有幾點是需要注意的：

1. 類需要包含__iter__()函數(shù)，而返回的不一定是self，但是需要生成器
2. 實現(xiàn)next方法，“迭代”的邏輯請放到該函數(shù)里面
3. 如果需要引入別的庫或者寫別的函數(shù)，可以在類中隨便加

接下來，煎魚帶來一段很無聊的表演，來表示__iter__()函數(shù)而返回的不一定是self：

class SuperY(object):

    def __init__(self, n_max):
        self.n_max = n_max

    def __iter__(self):
        return Y(self.n_max)

if __name__ == '__main__':
    sy = SuperY(13)
    for i in sy:
        print(i)

這段代碼的輸出和上一段一模一樣。

生成器的照妖鏡

這里照妖鏡的意思，指一個能鑒別某對象（甚至不是對象）是否一個生成器的東西。

說起來，可能會有點多余而且零碎。

其中有三個函數(shù)：

1. isgeneratorfunction()，字面意思，是否生成器函數(shù)
2. isgenerator()，還是字面意思，是否生成器
3. isinstance()，這個指某對象是否為某個類的實例

我們把前面寫過的y（帶yield的函數(shù)），和Y（生成器類）導(dǎo)入后，進(jìn)行實驗觀察：

from use_yield import y_with_yield as y
from iter_obj import Y
from inspect import isgeneratorfunction, isgenerator
from types import GeneratorType
from collections import Iterator

if __name__ == '__main__':
    print(isgeneratorfunction(y))  # True
    print(isgeneratorfunction(Y))  # False
    print(isgeneratorfunction(y(5)))  # False
    print(isgeneratorfunction(Y(5)))  # False
    print(isgenerator(y))  # False
    print(isgenerator(Y))  # False
    print(isgenerator(y(5)))  # True
    print(isgenerator(Y(5)))  # False

    print("")

    print(isinstance(y, GeneratorType))  # False
    print(isinstance(y(5), GeneratorType))  # True
    print(isinstance(Y, GeneratorType))  # False
    print(isinstance(Y(5), GeneratorType))  # False

    print("")

    print(isinstance(y, Iterator))  # False
    print(isinstance(y(5), Iterator))  # True
    print(isinstance(Y, Iterator))  # False
    print(isinstance(Y(5), Iterator))  # True

實驗的結(jié)論為：

1. 帶yield的y函數(shù)是一個生成器函數(shù)，帶yield的y函數(shù)帶上參數(shù)5后，稱為了生成器。因為y是函數(shù)的引用，而帶上了參數(shù)5后，y(5)就不再是函數(shù)了，而是通過yield進(jìn)化成了生成器。
2. 生成器是類GeneratorType的實例，但很遺憾的是，生成器類的實例不是生成器（黑人問號）。
3. 然而，生成器y(5)和生成器類的實例都屬于迭代器。

其他亂七八糟的

Python里面，range和xrange有什么不同，用哪個更好，為什么？

對的，就是和生成器有關(guān)系，嘿嘿。

先這樣吧

若有錯誤之處請指出，更多地請關(guān)注造殼。