我們以簡單的斐波那契數(shù)列為例，來測試一下它們執(zhí)行效率的差異。

Python 代碼：

def fib(n):
    a, b = 0.0, 1.0
    for i in range(n):
        a, b = a + b, a
    return a

C 代碼：

double cfib(int n) {
    int i;
    double a=0.0, b=1.0, tmp;
    for (i=0; i<n; ++i) {
        tmp = a; a = a + b; b = tmp;
    }
    return a;
}

上面便是 C 實現(xiàn)的一個斐波那契數(shù)列，可能有人好奇為什么我們使用浮點型，而不是整型呢？答案是 C 的整型是有范圍的，所以我們使用 double，而且 Python 的 float 在底層對應(yīng)的是 PyFloatObject、其內(nèi)部也是通過 double 來存儲的。

C 擴展：

然后是 C 擴展，注意：C 擴展不是我們的重點，寫 C 擴展和寫 Cython 本質(zhì)是一樣的，都是為 Python 編寫擴展模塊，但是寫 Cython 絕對要比寫 C 擴展簡單的多。

#include "Python.h"

double cfib(int n) {
    int i;
    double a=0.0, b=1.0, tmp;
    for (i=0; i<n; ++i) {
        tmp = a; a = a + b; b = tmp;
    }
    return a;
}

static PyObject *fib(PyObject *self, PyObject *n) {
    if (!PyLong_CheckExact(n)) {
        wchar_t *error = L"函數(shù) fib 需要接收一個整數(shù)";
        PyErr_SetObject(PyExc_ValueError,
                        PyUnicode_FromWideChar(error, wcslen(error)));
        return NULL;
    }
    double result = cfib(PyLong_AsLong(n));
    return PyFloat_FromDouble(result);
}

static PyMethodDef methods[] = {
    {"fib",
     (PyCFunction) fib,
     METH_O,
     "這是 fib 函數(shù)"},
     {NULL, NULL, 0, NULL}
};

static PyModuleDef module = {
    PyModuleDef_HEAD_INIT,
    "c_extension",
    "這是模塊 c_extension",
    -1,
    methods,
    NULL, NULL, NULL, NULL
};

PyMODINIT_FUNC PyInit_c_extension(void) {
    return PyModule_Create(&module);
}

可以看到，如果是寫 C 擴展，即便一個簡單的斐波那契，都是非常復(fù)雜的事情。

Cython 代碼：

最后看看如何使用 Cython 來編寫斐波那契，你覺得使用 Cython 編寫的代碼應(yīng)該是一個什么樣子的呢？

def fib(int n):
    cdef int i
    cdef double a = 0.0, b = 1.0
    for i in range(n):
        a, b = a + b, a
    return a

怎么樣，Cython 代碼和 Python 代碼是不是很相似呢？雖然我們現(xiàn)在還沒有正式學習 Cython 的語法，但你也應(yīng)該能夠猜到上面代碼的含義是什么。我們使用 cdef 關(guān)鍵字定義了一個 C 級別的變量，并聲明了它們的類型。

Cython 代碼也是要編譯成擴展模塊之后，才能被解釋器識別，所以它需要先被翻譯成 C 的代碼，然后再編譯成擴展模塊。再次說明，寫 C 擴展和寫 Cython 本質(zhì)上沒有什么區(qū)別，Cython 代碼也是要被翻譯成 C 代碼的。

但很明顯，寫 Cython 比寫 C 擴展要簡單很多，如果編寫的 Cython 代碼質(zhì)量很高，那么翻譯出來的 C 代碼的質(zhì)量同樣很高，而且在翻譯的過程中還會自動進行最大程度的優(yōu)化。但如果是手寫 C 擴展，那么一切優(yōu)化都要開發(fā)者手動去處理，更何況在功能復(fù)雜的時候，寫 C 擴展本身就是一件讓人頭疼的事情。

Cython 為什么能夠加速？

觀察一下 Cython 代碼，和純 Python 的斐波那契相比，我們看到區(qū)別貌似只是事先規(guī)定好了變量 i、a、b 的類型而已，關(guān)鍵是為什么這樣就可以起到加速的效果呢（雖然還沒有測試，但速度肯定會提升的，否則就沒必要學 Cython 了）。

但是原因就在這里，因為 Python 中所有的變量都是一個泛型指針 PyObject *。PyObject（C 的一個結(jié)構(gòu)體）內(nèi)部有兩個成員，分別是 ob_refcnt：保存對象的引用計數(shù)、ob_type *：保存對象類型的指針。

不管是整數(shù)、浮點數(shù)、字符串、元組、字典，亦或是其它的什么，所有指向它們的變量都是一個 PyObject *。當進行操作的時候，首先要通過 -> ob_type 來獲取對應(yīng)類型的指針，再進行轉(zhuǎn)化。

比如 Python 代碼中的 a 和 b，我們知道無論進行哪一層循環(huán)，結(jié)果指向的都是浮點數(shù)，但是解釋器不會做這種推斷。每一次相加都要進行檢測，判斷到底是什么類型并進行轉(zhuǎn)化；然后執(zhí)行加法的時候，再去找內(nèi)部的 __add__ 方法，將兩個對象相加，創(chuàng)建一個新的對象；執(zhí)行結(jié)束后再將這個新對象的指針轉(zhuǎn)成 PyObject *，然后返回。

并且 Python 的對象都是在堆上分配空間，再加上 a 和 b 不可變，所以每一次循環(huán)都會創(chuàng)建新的對象，并將之前的對象給回收掉。

以上種種都導(dǎo)致了 Python 代碼的執(zhí)行效率不可能高，雖然 Python 也提供了內(nèi)存池以及相應(yīng)的緩存機制，但顯然還是架不住效率低。

至于 Cython 為什么能加速，我們后面會慢慢聊。

效率差異

那么它們之間的效率差異是什么樣的呢？我們用一個表格來對比一下：

提升的倍數(shù)，指的是相對于純 Python 來說在效率上提升了多少倍。

第二列是 fib(0)，顯然它沒有真正進入循環(huán)，fib(0) 測量的是調(diào)用一個函數(shù)所需要花費的開銷。而倒數(shù)第二列 "循環(huán)體耗時" 指的是執(zhí)行 fib(90) 的時候，排除函數(shù)調(diào)用本身的開銷，也就是執(zhí)行內(nèi)部循環(huán)體所花費的時間。

整體來看，純 C 語言編寫的斐波那契，毫無疑問是最快的，但是這里面有很多值得思考的地方，我們來分析一下。

純 Python?

眾望所歸，各方面都是表現(xiàn)最差的那一個。從 fib(0) 來看，調(diào)用一個函數(shù)要花 590 納秒，和 C 相比慢了這么多，原因就在于 Python 調(diào)用一個函數(shù)的時候需要創(chuàng)建一個棧幀，而這個棧幀是分配在堆上的，而且結(jié)束之后還要涉及棧幀的銷毀等等。至于 fib(90)，顯然無需分析了。

純 C

顯然此時沒有和 Python 運行時的交互，因此消耗的性能最小。fib(0) 表明了，C 調(diào)用一個函數(shù)，開銷只需要 2 納秒；fib(90) 則說明執(zhí)行一個循環(huán)，C 比 Python 快了將近80倍。

C 擴展

C 擴展是干什么的上面已經(jīng)說了，就是使用 C 來為 Python 編寫擴展模塊。我們看一下循環(huán)體耗時，發(fā)現(xiàn) C 擴展和純 C 是差不多的，區(qū)別就是函數(shù)調(diào)用上花的時間比較多。原因就在于當我們調(diào)用擴展模塊的函數(shù)時，需要先將 Python 的數(shù)據(jù)轉(zhuǎn)成 C 的數(shù)據(jù)，然后用 C 函數(shù)計算斐波那契數(shù)列，計算完了再將 C 的數(shù)據(jù)轉(zhuǎn)成 Python 的數(shù)據(jù)。

所以 C 擴展本質(zhì)也是 C 語言，只不過在編寫的時候還需要遵循 CPython 提供的 API 規(guī)范，這樣就可以將 C 代碼編譯成 pyd 文件，直接讓 Python 來調(diào)用。從結(jié)果上看，和 Cython 做的事情是一樣的。但是還是那句話，用 C 寫擴展，本質(zhì)上還是寫 C，而且還要熟悉底層的 Python/C API，難度是比較大的。

Cython

單獨看循環(huán)體耗時的話，純 C 、C 擴展、Cython 都是差不多的，但是編寫 Cython 顯然是最方便的。而我們說 Cython 做的事情和 C 擴展本質(zhì)是類似的，都是為 Python 提供擴展模塊，區(qū)別就在于：一個是手動寫 C 代碼，另一個是編寫 Cython 代碼、然后再自動翻譯成 C 代碼。所以對于 Cython 來說，將 Python 的數(shù)據(jù)轉(zhuǎn)成 C 的數(shù)據(jù)、進行計算，然后再轉(zhuǎn)成 Python 的數(shù)據(jù)返回，這一過程也是無可避免的。

但是我們看到 Cython 在函數(shù)調(diào)用時的耗時相比 C 擴展卻要少很多，主要是 Cython 生成的 C 代碼是經(jīng)過高度優(yōu)化的。不過說實話，函數(shù)調(diào)用花的時間不需要太關(guān)心，內(nèi)部代碼塊執(zhí)行所花的時間才是我們需要注意的。當然啦，如何減少函數(shù)調(diào)用本身的開銷，我們后面也會說。

Python 的 for 循環(huán)為什么這么慢？

通過循環(huán)體耗時我們看到，Python 的 for 循環(huán)真的是出了名的慢，那么原因是什么呢？來分析一下。

1. Python 的 for 循環(huán)機制

Python 在遍歷一個可迭代對象的時候，會先調(diào)用可迭代對象內(nèi)部的 __iter__ 方法返回其對應(yīng)的迭代器；然后再不斷地調(diào)用迭代器的 __next__ 方法，將值一個一個的迭代出來，直到迭代器拋出 StopIteration 異常，for 循環(huán)捕捉，終止循環(huán)。

而迭代器是有狀態(tài)的，Python 解釋器需要時刻記錄迭代器的迭代狀態(tài)。

2. Python 的算數(shù)操作

這一點我們上面其實已經(jīng)提到過了，Python 由于自身的動態(tài)特性，使得其無法做任何基于類型的優(yōu)化。

比如：循環(huán)體中的 a + b，這個 a、b 指向的可以是整數(shù)、浮點數(shù)、字符串、元組、列表，甚至是我們實現(xiàn)了魔法方法 __add__ 的類的實例對象，等等等等。

盡管我們知道是浮點數(shù)，但是 Python 不會做這種假設(shè)，所以每一次執(zhí)行 a + b 的時候，都會檢測其類型到底是什么？然后判斷內(nèi)部是否有 __add__ 方法，有的話則以 a 和 b 為參數(shù)進行調(diào)用，將 a 和 b 指向的對象相加。計算出結(jié)果之后，再將其指針轉(zhuǎn)成 PyObject * 返回。

而對于 C 和 Cython 來說，在創(chuàng)建變量的時候就事先規(guī)定了類型為 double，不是其它的，因此編譯之后的 a + b 只是一條簡單的機器指令。這對比下來，Python 尼瑪能不慢嗎。

3. Python 對象的內(nèi)存分配

Python 的對象是分配在堆上面的，因為 Python 對象本質(zhì)上就是 C 的 malloc 函數(shù)為結(jié)構(gòu)體在堆區(qū)申請的一塊內(nèi)存。在堆區(qū)進行內(nèi)存的分配和釋放需要付出很大的代價，而棧則要小很多，并且它是由操作系統(tǒng)維護的，會自動回收，效率極高，棧上內(nèi)存的分配和釋放只是動一動寄存器而已。

但堆顯然沒有此待遇，而恰恰 Python 的對象都分配在堆上，盡管 Python 引入了內(nèi)存池機制使得其在一定程度上避免了和操作系統(tǒng)的頻繁交互，并且還引入了小整數(shù)對象池、字符串的intern機制，以及緩存池等。

但事實上，當涉及到對象（任意對象、包括標量）的創(chuàng)建和銷毀時，都會增加動態(tài)分配內(nèi)存、以及 Python 內(nèi)存子系統(tǒng)的開銷。而 float 對象又是不可變的，因此每循環(huán)一次都會創(chuàng)建和銷毀一次，所以效率依舊是不高的。

而 Cython 分配的變量（當類型是 C 里面的類型時），它們就不再是指針了（Python 的變量都是指針），對于當前的 a 和 b 而言就是分配在棧上的雙精度浮點數(shù)。而棧上分配的效率遠遠高于堆，因此非常適合 for 循環(huán)，所以效率要比 Python 高很多。另外不光是分配，在尋址的時候，棧也要比堆更高效。

所以在 for 循環(huán)方面，C 和 Cython 要比純 Python 快了幾個數(shù)量級，這并不是奇怪的事情，因為 Python 每次迭代都要做很多的工作。

什么時候使用 Cython？

我們看到在 Cython 代碼中，只是添加了幾個 cdef 就能獲得如此大的性能改進，顯然這是非常讓人振奮的。但是，并非所有的 Python 代碼在使用 Cython 編寫時，都能獲得巨大的性能改進。

我們這里的斐波那契數(shù)列示例是刻意的，因為里面的數(shù)據(jù)是綁定在 CPU 上的，運行時都花費在處理 CPU 寄存器的一些變量上，而不需要進行數(shù)據(jù)的移動。如果此函數(shù)做的是如下工作：

• 內(nèi)存密集，比如給大數(shù)組添加元素；
• I/O 密集，比如從磁盤讀取大文件；
• 網(wǎng)絡(luò)密集，比如從 FTP 服務(wù)器下載文件；?

那么 Python，C，Cython 之間的差異可能會顯著減少（對于存儲密集操作），甚至完全消失（對于 I/O 密集或網(wǎng)絡(luò)密集操作）。

當提升 Python 程序性能是我們的目標時，Pareto 原則對我們幫助很大，即：程序百分之 80 的運行耗時是由百分之 20 的代碼引起的。但如果不進行仔細的分析，那么是很難找到這百分之 20 的代碼的。因此我們在使用 Cython 提升性能之前，分析整體業(yè)務(wù)邏輯是第一步。

如果我們通過分析之后，確定程序的瓶頸是由網(wǎng)絡(luò) IO 所導(dǎo)致的，那么我們就不能期望 Cython 可以帶來顯著的性能提升。因此在你使用 Cython 之前，有必要先確定到底是哪種原因?qū)е鲁绦虺霈F(xiàn)了瓶頸。所以盡管 Cython 是一個強大的工具，但前提是它必須應(yīng)用在正確的道路上。

另外 Cython 將 C 的類型系統(tǒng)引入進了 Python，所以 C 的數(shù)據(jù)類型的限制是我們需要關(guān)注的。我們知道，Python 的整數(shù)不受長度的限制，但是 C 的整數(shù)是受到限制的，這意味著它們不能正確地表示無限精度的整數(shù)。

不過 Cython 的一些特性可以幫助我們捕獲這些溢出，總之最重要的是：C 數(shù)據(jù)類型的速度比 Python 數(shù)據(jù)類型快，但是會受到限制導(dǎo)致其不夠靈活和通用。從這里我們也能看出，在速度以及靈活性、通用性上面，Python 選擇了后者。

此外，思考一下 Cython 的另一個特性：連接外部代碼。假設(shè)我們的起點不是 Python，而是 C 或者 C++，我們希望使用 Python 將多個 C 或者 C++ 模塊進行連接。而 Cython 理解 C 和 C++ 的聲明，并且它能生成高度優(yōu)化的代碼，因此更適合作為連接的橋梁。

由于我本人是主 Python 的，如果涉及到 C、C++，都是介紹如何在 Cython 中引入 C、C++，直接調(diào)用已經(jīng)寫好的 C 庫。而不會介紹如何在 C、C++ 中引入 Cython，來作為連接多個 C、C++ 模塊的橋梁。這一點望理解，因為本人不用 C、C++ 編寫服務(wù)，只會用它們來輔助 Python 提高效率。

小結(jié)

到目前為止，只是介紹了一下 Cython，并且主要討論了它的定位，以及和 Python、C 之間的差異。至于如何使用 Cython 加速 Python，如何編寫 Cython 代碼、以及它的詳細語法，我們將會后續(xù)介紹。

總之，Cython 是一門成熟的語言，它是為 Python 而服務(wù)的。Cython 代碼不能夠直接拿來執(zhí)行，因為它不符合 Python 的語法規(guī)則。

我們使用 Cython 的方式是：先將 Cython 代碼翻譯成 C 代碼，再將 C 代碼編譯成擴展模塊（pyd 文件），然后在 Python 代碼中導(dǎo)入它、調(diào)用里面的功能方法，這是我們使用 Cython 的正確途徑、當然也是唯一的途徑。

比如我們上面用 Cython 編寫的斐波那契，如果直接執(zhí)行的話是會報錯的，因為 cdef 明顯不符合 Python 的語法規(guī)則。所以 Cython 代碼需要編譯成擴展模塊，然后在普通的 py 文件中被導(dǎo)入，而這么做的意義就在于可以提升運行速度。因此 Cython 代碼應(yīng)該都是一些 CPU 密集型的代碼，不然效率很難得到大幅度提升。

所以在使用 Cython 之前，最好先仔細分析一下業(yè)務(wù)邏輯，或者暫時先不用 Cython，直接完全使用 Python 編寫。編寫完成之后開始測試、分析程序的性能，看看有哪些地方耗時比較嚴重，但同時又是可以通過靜態(tài)類型的方式進行優(yōu)化的。找出它們，使用 Cython 進行重寫，編譯成擴展模塊，然后調(diào)用擴展模塊里面的功能。