在我看來，python社群分為了三個流派，分別是python 2.x組織，3.x組織和PyPy組織。這個分類基本上可以歸根於類庫的相容性和速度。這篇文章將聚焦於一些通用程式碼的優化技巧以及編譯成C後效能的顯著提升，當然我也會給出三大主要python流派執行時間。我的目的不是為了證明一個比另一個強，只是為了讓你知道如何在不同的環境下使用這些具體例子作比較。
使用生成器
一個普遍被忽略的記憶體優化是生成器的使用。生成器讓我們建立一個函式一次只返回一條記錄，而不是一次返回所有的記錄，如果你正在使用python2.x，這就是你為啥使用xrange替代range或者使用ifilter替代filter的原因。一個很好地例子就是建立一個很大的列表並將它們拼合在一起。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import timeit import random def generate(num): while num: yield random.randrange(10) num -= 1 def create_list(num): numbers = [] while num: numbers.append(random.randrange(10)) num -= 1 return numbers print(timeit.timeit("sum(generate(999))", setup="from __main__ import generate", number=1000)) >>> 0.88098192215 #Python 2.7 >>> 1.416813850402832 #Python 3.2 print(timeit.timeit("sum(create_list(999))", setup="from __main__ import create_list", number=1000)) >>> 0.924163103104 #Python 2.7 >>> 1.5026731491088867 #Python 3.2 |
這不僅是快了一點，也避免了你在記憶體中儲存全部的列表!
Ctypes的介紹
對於關鍵性的效能程式碼python本身也提供給我們一個API來呼叫C方法，主要通過 ctypes來實現，你可以不寫任何C程式碼來利用ctypes。預設情況下python提供了預編譯的標準c庫，我們再回到生成器的例子，看看使用ctypes實現花費多少時間。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import timeit from ctypes import cdll def generate_c(num): #Load standard C library libc = cdll.LoadLibrary("libc.so.6") #Linux #libc = cdll.msvcrt #Windows while num: yield libc.rand() % 10 num -= 1 print(timeit.timeit("sum(generate_c(999))", setup="from __main__ import generate_c", number=1000)) >>> 0.434374809265 #Python 2.7 >>> 0.7084300518035889 #Python 3.2 |
僅僅換成了c的隨機函式，執行時間減了大半！現在如果我告訴你我們還能做得更好，你信嗎?
Cython的介紹
Cython 是python的一個超集，允許我們呼叫C函式以及宣告變數來提高效能。嘗試使用之前我們需要先安裝Cython.
|
1 |
sudo pip install cython |
Cython 本質上是另一個不再開發的類似類庫Pyrex的分支，它將我們的類Python程式碼編譯成C庫，我們可以在一個python檔案中呼叫。對於你的python檔案使用.pyx字尾替代.py字尾，讓我們看一下使用Cython如何來執行我們的生成器程式碼。
|
1 2 3 4 5 6 7 |
#cython_generator.pyx import random def generate(num): while num: yield random.randrange(10) num -= 1 |
我們需要建立個setup.py以便我們能獲取到Cython來編譯我們的函式。
|
1 2 3 4 5 6 7 8 |
from distutils.core import setup from distutils.extension import Extension from Cython.Distutils import build_ext setup( cmdclass = {'build_ext': build_ext}, ext_modules = [Extension("generator", ["cython_generator.pyx"])] ) |
編譯使用:
|
1 |
python setup.py build_ext --inplace |
你應該可以看到兩個檔案cython_generator.c 檔案 和 generator.so檔案，我們使用下面方法測試我們的程式:
|
1 2 3 |
import timeit print(timeit.timeit("sum(generator.generate(999))", setup="import generator", number=1000)) >>> 0.835658073425 |
還不賴，讓我們看看是否還有可以改進的地方。我們可以先宣告“num”為整形，接著我們可以匯入標準的C庫來負責我們的隨機函式。
|
1 2 3 4 5 6 7 8 |
#cython_generator.pyx cdef extern from "stdlib.h": int c_libc_rand "rand"() def generate(int num): while num: yield c_libc_rand() % 10 num -= 1 |
如果我們再次編譯執行我們會看到這一串驚人的數字。
|
1 |
>>> 0.033586025238 |
僅僅的幾個改變帶來了不賴的結果。然而，有時這個改變很乏味，因此讓我們來看看如何使用規則的python來實現吧。
PyPy的介紹
PyPy 是一個Python2.7.3的即時編譯器，通俗地說這意味著讓你的程式碼執行的更快。Quora在生產環境中使用了PyPy。PyPy在它們的下載頁面有一些安裝說明，但是如果你使用的Ubuntu系統，你可以通過apt-get來安裝。它的執行方式是立即可用的，因此沒有瘋狂的bash或者執行指令碼，只需下載然後執行即可。讓我們看看我們原始的生成器程式碼在PyPy下的效能如何。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import timeit import random def generate(num): while num: yield random.randrange(10) num -= 1 def create_list(num): numbers = [] while num: numbers.append(random.randrange(10)) num -= 1 return numbers print(timeit.timeit("sum(generate(999))", setup="from __main__ import generate", number=1000)) >>> 0.115154981613 #PyPy 1.9 >>> 0.118431091309 #PyPy 2.0b1 print(timeit.timeit("sum(create_list(999))", setup="from __main__ import create_list", number=1000)) >>> 0.140175104141 #PyPy 1.9 >>> 0.140514850616 #PyPy 2.0b1 |
哇！沒有修改一行程式碼執行速度是純python實現的8倍。
進一步測試
為什麼還要進一步研究？PyPy是冠軍！並不全對。雖然大多數程式可以執行在PyPy上，但是還是有一些庫沒有被完全支援。而且，為你的專案寫C的擴充套件相比換一個編譯器更加容易。讓我們更加深入一些，看看ctypes如何讓我們使用C來寫庫。我們來測試一下歸併排序和計算斐波那契數列的速度。下面是我們要用到的C程式碼（functions.c）：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
/* functions.c */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* http://rosettacode.org/wiki/Sorting_algorithms/Merge_sort#C */ inline void merge (int *left, int l_len, int *right, int r_len, int *out) { int i, j, k; for (i = j = k = 0; i < l_len && j < r_len;) out[k++] = left[i] < right[j] ? left[i++] : right[j++]; while (i < l_len) out[k++] = left[i++]; while (j < r_len) out[k++] = right[j++]; } /* inner recursion of merge sort */ void recur (int *buf, int *tmp, int len) { int l = len / 2; if (len <= 1) return; /* note that buf and tmp are swapped */ recur (tmp, buf, l); recur (tmp + l, buf + l, len - l); merge (tmp, l, tmp + l, len - l, buf); } /* preparation work before recursion */ void merge_sort (int *buf, int len) { /* call alloc, copy and free only once */ int *tmp = malloc (sizeof (int) * len); memcpy (tmp, buf, sizeof (int) * len); recur (buf, tmp, len); free (tmp); }http://python.jobbole.com/wp-admin/post-new.php# int fibRec (int n) { if (n < 2) return n; else return fibRec (n - 1) + fibRec (n - 2); } |
在Linux平臺，我們可以用下面的方法把它編譯成一個共享庫：
|
1 2 |
gcc -Wall -fPIC -c functions.c gcc -shared -o libfunctions.so functions.o |
使用ctypes， 通過載入”libfunctions.so”這個共享庫，就像我們前邊對標準C庫所作的那樣，就可以使用這個庫了。這裡我們將要比較Python實現和C實現。現在我們開始計算斐波那契數列：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
# functions.py from ctypes import * import time libfunctions = cdll.LoadLibrary("./libfunctions.so") def fibRec(n): if n < 2: return n else: return fibRec(n-1) + fibRec(n-2) start = time.time() fibRec(32) finish = time.time() print("Python: " + str(finish - start)) # C Fibonacci start = time.time() x = libfunctions.fibRec(32) finish = time.time() print("C: " + str(finish - start)) |
|
1 2 3 4 5 6 7 8 |
Python: 1.18783187866 #Python 2.7 Python: 1.272292137145996 #Python 3.2 Python: 0.563600063324 #PyPy 1.9 Python: 0.567229032516 #PyPy 2.0b1 C: 0.043830871582 #Python 2.7 + ctypes C: 0.04574108123779297 #Python 3.2 + ctypes C: 0.0481240749359 #PyPy 1.9 + ctypes C: 0.046403169632 #PyPy 2.0b1 + ctypes |
正如我們預料的那樣，C比Python和PyPy更快。我們也可以用同樣的方式比較歸併排序。
我們還沒有深挖Cypes庫，所以這些例子並沒有反映python強大的一面，Cypes庫只有少量的標準型別限制，比如int型，char陣列，float型，位元組（bytes）等等。預設情況下，沒有整形陣列，然而通過與c_int相乘（ctype為int型別）我們可以間接獲得這樣的陣列。這也是程式碼第7行所要呈現的。我們建立了一個c_int陣列，有關我們數字的陣列並分解打包到c_int陣列中
主要的是c語言不能這樣做，而且你也不想。我們用指標來修改函式體。為了通過我們的c_numbers的數列，我們必須通過引用傳遞merge_sort功能。執行merge_sort後，我們利用c_numbers陣列進行排序，我已經把下面的程式碼加到我的functions.py檔案中了。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
#Python Merge Sort from random import shuffle, sample #Generate 9999 random numbers between 0 and 100000 numbers = sample(range(100000), 9999) shuffle(numbers) c_numbers = (c_int * len(numbers))(*numbers) from heapq import merge def merge_sort(m): if len(m) <= 1: return m middle = len(m) // 2 left = m[:middle] right = m[middle:] left = merge_sort(left) right = merge_sort(right) return list(merge(left, right)) start = time.time() numbers = merge_sort(numbers) finish = time.time() print("Python: " + str(finish - start)) #C Merge Sort start = time.time() libfunctions.merge_sort(byref(c_numbers), len(numbers)) finish = time.time() print("C: " + str(finish - start)) |
|
1 2 3 4 5 6 7 8 |
Python: 0.190635919571 #Python 2.7 Python: 0.11785483360290527 #Python 3.2 Python: 0.266992092133 #PyPy 1.9 Python: 0.265724897385 #PyPy 2.0b1 C: 0.00201296806335 #Python 2.7 + ctypes C: 0.0019741058349609375 #Python 3.2 + ctypes C: 0.0029308795929 #PyPy 1.9 + ctypes C: 0.00287103652954 #PyPy 2.0b1 + ctypes |
這兒通過表格和圖示來比較不同的結果。
希望你利用C和PyPy優化你的python程式碼並以此為敲門磚找到一個好職位。像往常一樣如果你有任何意見或問題，請隨時把評論下載下面或者在我的網頁上與我取得聯絡。感謝您的閱讀！
附：如果您的公司正在尋求聘請即將畢業的優秀大學生（2013年5月），讓我知道！