133      技術社區[雲棲]

加速你的Python代碼

在我看來，python社區分為了三個流派，分別是python 2.x組織，3.x組織和PyPy組織。這個分類基本上可以歸根於類庫的兼容性和速度。這篇文章將聚焦於一些通用代碼的優化技巧以及編譯成C後性能的顯著提升，當然我也會給出三大主要python流派運行時間。我的目的不是為了證明一個比另一個強，隻是為了讓你知道如何在不同的環境下使用這些具體例子作比較。

使用生成器

一個普遍被忽略的內存優化是生成器的使用。生成器讓我們創建一個函數一次隻返回一條記錄，而不是一次返回所有的記錄，如果你正在使用python2.x，這就是你為啥使用xrange替代range或者使用ifilter替代filter的原因。一個很好地例子就是創建一個很大的列表並將它們拚合在一起。

1. import timeit  
2. import random  
3.    
4. def generate(num):  
5. while num:  
6. yield random.randrange(10)  
7. num -= 1 
8.    
9. def create_list(num):  
10. numbers = []  
11. while num:  
12. numbers.append(random.randrange(10))  
13. num -= 1 
14. return numbers  
15. print(timeit.timeit("sum(generate(999))", setup="from __main__ import generate", number=1000))  
16. >>> 0.88098192215 #Python 2.7  
17. >>> 1.416813850402832 #Python 3.2  
18. print(timeit.timeit("sum(create_list(999))", setup="from __main__ import create_list", number=1000))  
19. >>> 0.924163103104 #Python 2.7  
20. >>> 1.5026731491088867 #Python 3.2 

這不僅是快了一點，也避免了你在內存中存儲全部的列表!

Ctypes的介紹

對於關鍵性的性能代碼python本身也提供給我們一個API來調用C方法，主要通過 ctypes來實現，你可以不寫任何C代碼來利用ctypes。默認情況下python提供了預編譯的標準c庫，我們再回到生成器的例子，看看使用ctypes實現花費多少時間。

1. import timeit  
2. from ctypes import cdll  
3.    
4. def generate_c(num):  
5. #Load standard C library  
6. libc = cdll.LoadLibrary("libc.so.6") #Linux  
7. #libc = cdll.msvcrt #Windows  
8. while num:  
9. yield libc.rand() % 10 
10. num -= 1 
11.    
12. print(timeit.timeit("sum(generate_c(999))", setup="from __main__ import generate_c", number=1000))  
13. >>> 0.434374809265 #Python 2.7  
14. >>> 0.7084300518035889 #Python 3.2 

僅僅換成了c的隨機函數，運行時間減了大半！現在如果我告訴你我們還能做得更好，你信嗎?

Cython的介紹

Cython 是python的一個超集，允許我們調用C函數以及聲明變量來提高性能。嚐試使用之前我們需要先安裝Cython.

sudo pip install cythonCython 本質上是另一個不再開發的類似類庫Pyrex的分支，它將我們的類Python代碼編譯成C庫，我們可以在一個python文件中調用。對於你的python文件使用.pyx後綴替代.py後綴，讓我們看一下使用Cython如何來運行我們的生成器代碼。

1. #cython_generator.pyx  
2. import random  
3.    
4. def generate(num):  
5. while num:  
6. yield random.randrange(10)  
7. num -= 1 

我們需要創建個setup.py以便我們能獲取到Cython來編譯我們的函數。

1. from distutils.core import setup  
2. from distutils.extension import Extension  
3. from Cython.Distutils import build_ext  
4.    
5. setup(  
6. cmdclass = {'build_ext': build_ext},  
7. ext_modules = [Extension("generator", ["cython_generator.pyx"])]  
8. )  

編譯使用:

1. python setup.py build_ext --inplace 

你應該可以看到兩個文件cython_generator.c 文件 和 generator.so文件，我們使用下麵方法測試我們的程序:

1. import timeit  
2. print(timeit.timeit("sum(generator.generate(999))", setup="import generator", number=1000))  
3. >>> 0.835658073425 

還不賴，讓我們看看是否還有可以改進的地方。我們可以先聲明“num”為整形，接著我們可以導入標準的C庫來負責我們的隨機函數。

1. #cython_generator.pyx  
2. cdef extern from "stdlib.h":  
3. int c_libc_rand "rand"()  
4.    
5. def generate(int num):  
6. while num:  
7. yield c_libc_rand() % 10 
8. num -= 1 

如果我們再次編譯運行我們會看到這一串驚人的數字。

1. >>> 0.033586025238 

僅僅的幾個改變帶來了不賴的結果。然而，有時這個改變很乏味，因此讓我們來看看如何使用規則的python來實現吧。

PyPy的介紹

PyPy 是一個Python2.7.3的即時編譯器，通俗地說這意味著讓你的代碼運行的更快。Quora在生產環境中使用了PyPy。PyPy在它們的下載頁麵有一些安裝說明，但是如果你使用的Ubuntu係統，你可以通過apt-get來安裝。它的運行方式是立即可用的，因此沒有瘋狂的bash或者運行腳本，隻需下載然後運行即可。讓我們看看我們原始的生成器代碼在PyPy下的性能如何。

1. import timeit  
2. import random  
3.    
4. def generate(num):  
5. while num:  
6. yield random.randrange(10)  
7. num -= 1 
8.    
9. def create_list(num):  
10. numbers = []  
11. while num:  
12. numbers.append(random.randrange(10))  
13. num -= 1 
14. return numbers  
15. print(timeit.timeit("sum(generate(999))", setup="from __main__ import generate", number=1000))  
16. >>> 0.115154981613 #PyPy 1.9  
17. >>> 0.118431091309 #PyPy 2.0b1  
18. print(timeit.timeit("sum(create_list(999))", setup="from __main__ import create_list", number=1000))  
19. >>> 0.140175104141 #PyPy 1.9  
20. >>> 0.140514850616 #PyPy 2.0b1 

哇！沒有修改一行代碼運行速度是純python實現的8倍。

進一步測試

為什麼還要進一步研究？PyPy是冠軍！並不全對。雖然大多數程序可以運行在PyPy上，但是還是有一些庫沒有被完全支持。而且，為你的項目寫C的擴展相比換一個編譯器更加容易。讓我們更加深入一些，看看ctypes如何讓我們使用C來寫庫。我們來測試一下歸並排序和計算斐波那契數列的速度。下麵是我們要用到的C代碼（functions.c）：

1. /* functions.c */  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <string.h>  
5.  
6. /* https://rosettacode.org/wiki/Sorting_algorithms/Merge_sort#C */  
7. inline void  
8. merge (int *left, int l_len, int *right, int r_len, int *out)  
9. {  
10.   int i, j, k;  
11.   for (i = j = k = 0; i < l_len && j < r_len;)  
12.     out[k++] = left[i] < right[j] ? left[i++] : right[j++];  
13.   while (i < l_len)  
14.     out[k++] = left[i++];  
15.   while (j < r_len)  
16.     out[k++] = right[j++];  
17. }  
18.  
19. /* inner recursion of merge sort */  
20. void  
21. recur (int *buf, int *tmp, int len)  
22. {  
23.   int l = len / 2;  
24.   if (len <= 1)  
25.     return;  
26. /* note that buf and tmp are swapped */  
27.   recur (tmp, buf, l);  
28.   recur (tmp + l, buf + l, len - l);  
29.   merge (tmp, l, tmp + l, len - l, buf);  
30. }  
31.  
32. /* preparation work before recursion */  
33. void  
34. merge_sort (int *buf, int len)  
35. {  
36. /* call alloc, copy and free only once */  
37.   int *tmp = malloc (sizeof (int) * len);  
38.   memcpy (tmp, buf, sizeof (int) * len);  
39.   recur (buf, tmp, len);  
40.   free (tmp);  
41. }  
42.  
43. int  
44. fibRec (int n)  
45. {  
46.   if (n < 2)  
47.     return n;  
48.   else 
49.     return fibRec (n - 1) + fibRec (n - 2);  
50. } 

在Linux平台，我們可以用下麵的方法把它編譯成一個共享庫：

1. gcc -Wall -fPIC -c functions.c  
2. gcc -shared -o libfunctions.so functions.o 

使用ctypes， 通過加載"libfunctions.so"這個共享庫，就像我們前邊對標準C庫所作的那樣，就可以使用這個庫了。這裏我們將要比較Python實現和C實現。現在我們開始計算斐波那契數列：

1. # functions.py  
2.  
3. from ctypes import *  
4. import time  
5.    
6. libfunctions = cdll.LoadLibrary("./libfunctions.so")  
7.    
8. def fibRec(n):  
9.     if n < 2:  
10.         return n  
11.     else:  
12.         return fibRec(n-1) + fibRec(n-2)  
13.    
14. start = time.time()  
15. fibRec(32)  
16. finish = time.time()  
17. print("Python: " + str(finish - start))  
18.    
19. # C Fibonacci  
20. start = time.time()  
21. x = libfunctions.fibRec(32)  
22. finish = time.time()  
23. print("C: " + str(finish - start)) 

1. Python: 1.18783187866 #Python 2.7  
2. Python: 1.272292137145996 #Python 3.2  
3. Python: 0.563600063324 #PyPy 1.9  
4. Python: 0.567229032516 #PyPy 2.0b1  
5. C: 0.043830871582 #Python 2.7 + ctypes  
6. C: 0.04574108123779297 #Python 3.2 + ctypes  
7. C: 0.0481240749359 #PyPy 1.9 + ctypes  
8. 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. #Python Merge Sort  
2. from random import shuffle, sample  
3.    
4. #Generate 9999 random numbers between 0 and 100000  
5. numbers = sample(range(100000), 9999)  
6. shuffle(numbers)  
7. c_numbers = (c_int * len(numbers))(*numbers)  
8.    
9. from heapq import merge  
10. def merge_sort(m):  
11. if len(m) <= 1:  
12. return m  
13. middle = len(m) // 2 
14. left = m[:middle]  
15. right = m[middle:]  
16. left = merge_sort(left)  
17. right = merge_sort(right)  
18. return list(merge(left, right))  
19.    
20. start = time.time()  
21. numbers = merge_sort(numbers)  
22. finish = time.time()  
23. print("Python: " + str(finish - start))  
24.    
25. #C Merge Sort  
26. start = time.time()  
27. libfunctions.merge_sort(byref(c_numbers), len(numbers))  
28. finish = time.time()  
29. print("C: " + str(finish - start)) 

1. Python: 0.190635919571 #Python 2.7  
2. Python: 0.11785483360290527 #Python 3.2  
3. Python: 0.266992092133 #PyPy 1.9  
4. Python: 0.265724897385 #PyPy 2.0b1  
5. C: 0.00201296806335 #Python 2.7 + ctypes  
6. C: 0.0019741058349609375 #Python 3.2 + ctypes  
7. C: 0.0029308795929 #PyPy 1.9 + ctypes  
8. C: 0.00287103652954 #PyPy 2.0b1 + ctypes 

這兒通過表格和圖標來比較不同的結果。

最後更新：2017-04-03 21:30:14

  上一篇： 金山的第三次創業：“用玩兒的方式做廣告”

  下一篇： J2EE中web.xml配置servlet的load-on-startup