-
優化算法時間複雜度
算法的時間複雜度對程序的執行效率影響最大，在Python中能夠經過選擇合適的數據結構來優化時間複雜度，如list和set查找某一個元素的時間複雜度分別是O(n)和O(1)。不一樣的場景有不一樣的優化方式，總得來講，通常有分治，分支界限，貪心，動態規劃等思想。html
-
減小冗餘數據
如用上三角或下三角的方式去保存一個大的對稱矩陣。在0元素佔大多數的矩陣裏使用稀疏矩陣表示。java
-
合理使用copy與deepcopy
對於dict和list等數據結構的對象，直接賦值使用的是引用的方式。而有些狀況下須要複製整個對象，這時可使用copy包裏的copy和deepcopy，這兩個函數的不一樣之處在於後者是遞歸複製的。效率也不同：（如下程序在ipython中運行）python
import copy a = range(100000) %timeit -n 10 copy.copy(a)
timeit後面的-n表示運行的次數，後兩行對應的是兩個timeit的輸出，下同。因而可知後者慢一個數量級。linux
-
使用dict或set查找元素
python dict和set都是使用hash表來實現(相似c++11標準庫中unordered_map)，查找元素的時間複雜度是O(1)nginx
a = range(1000) s = set(a) d = dict((i,1) for i in a) %timeit -n 10000 100 in d %timeit -n 10000 100 in s 10000 loops, best of 3: 43.5 ns per loop 10000 loops, best of 3: 49.6 ns per loop
dict的效率略高(佔用的空間也多一些)。c++
-
合理使用生成器（generator）和yield
%timeit -n 100 a = (i for i in range(100000)) %timeit -n 100 b = [i for i in range(100000)] 100 loops, best of 3: 1.54 ms per loop 100 loops, best of 3: 4.56 ms per loop
使用()獲得的是一個generator對象，所須要的內存空間與列表的大小無關，因此效率會高一些。在具體應用上，好比set(i for i in range(100000))會比set([i for i in range(100000)])快。程序員
可是對於須要循環遍歷的狀況：web
%timeit -n 10 for x in (i for i in range(100000)): pass %timeit -n 10 for x in [i for i in range(100000)]: pass 10 loops, best of 3: 6.51 ms per loop 10 loops, best of 3: 5.54 ms per loop
後者的效率反而更高，可是若是循環裏有break,用generator的好處是顯而易見的。yield也是用於建立generator：算法
def yield_func(ls): for i in ls: yield i+1 def not_yield_func(ls): return [i+1 for i in ls] ls = range(1000000) %timeit -n 10 for i in yield_func(ls):pass %timeit -n 10 for i in not_yield_func(ls):pass 10 loops, best of 3: 63.8 ms per loop 10 loops, best of 3: 62.9 ms per loop
對於內存不是很是大的list，能夠直接返回一個list，可是可讀性yield更佳(人個喜愛)。sql
python2.x內置generator功能的有xrange函數、itertools包等。
-
優化循環
循環以外能作的事不要放在循環內，好比下面的優化能夠快一倍：
a = range(10000) size_a = len(a) %timeit -n 1000 for i in a: k = len(a) %timeit -n 1000 for i in a: k = size_a 1000 loops, best of 3: 569 µs per loop 1000 loops, best of 3: 256 µs per loop
-
優化包含多個判斷表達式的順序
對於and，應該把知足條件少的放在前面，對於or，把知足條件多的放在前面。如：
a = range(2000) %timeit -n 100 [i for i in a if 10 < i < 20 or 1000 < i < 2000] %timeit -n 100 [i for i in a if 1000 < i < 2000 or 100 < i < 20] %timeit -n 100 [i for i in a if i % 2 == 0 and i > 1900] %timeit -n 100 [i for i in a if i > 1900 and i % 2 == 0] 100 loops, best of 3: 287 µs per loop 100 loops, best of 3: 214 µs per loop 100 loops, best of 3: 128 µs per loop 100 loops, best of 3: 56.1 µs per loop
-
使用join合併迭代器中的字符串
In [1]: %%timeit ...: s = '' ...: for i in a: ...: s += i ...: 10000 loops, best of 3: 59.8 µs per loop In [2]: %%timeit s = ''.join(a) ...: 100000 loops, best of 3: 11.8 µs per loop
join對於累加的方式，有大約5倍的提高。
-
選擇合適的格式化字符方式
s1, s2 = 'ax', 'bx' %timeit -n 100000 'abc%s%s' % (s1, s2) %timeit -n 100000 'abc{0}{1}'.format(s1, s2) %timeit -n 100000 'abc' + s1 + s2 100000 loops, best of 3: 183 ns per loop 100000 loops, best of 3: 169 ns per loop 100000 loops, best of 3: 103 ns per loop 三種狀況中，%的方式是最慢的，可是三者的差距並不大（都很是快）。(我的以爲%的可讀性最好)
-
不借助中間變量交換兩個變量的值
In [3]: %%timeit -n 10000 a,b=1,2 ....: c=a;a=b;b=c; ....: 10000 loops, best of 3: 172 ns per loop In [4]: %%timeit -n 10000 a,b=1,2 a,b=b,a ....: 10000 loops, best of 3: 86 ns per loop
使用a,b=b,a而不是c=a;a=b;b=c;來交換a,b的值，能夠快1倍以上。
-
使用if is
a = range(10000) %timeit -n 100 [i for i in a if i == True] %timeit -n 100 [i for i in a if i is True] 100 loops, best of 3: 531 µs per loop 100 loops, best of 3: 362 µs per loop
使用 if is True 比 if == True 將近快一倍。
-
使用級聯比較x < y < z
x, y, z = 1,2,3 %timeit -n 1000000 if x < y < z:pass %timeit -n 1000000 if x < y and y < z:pass 1000000 loops, best of 3: 101 ns per loop 1000000 loops, best of 3: 121 ns per loop
x < y < z效率略高，並且可讀性更好。
-
while 1 比 while True 更快
def while_1(): n = 100000 while 1: n -= 1 if n <= 0: break def while_true(): n = 100000 while True: n -= 1 if n <= 0: break m, n = 1000000, 1000000 %timeit -n 100 while_1() %timeit -n 100 while_true() 100 loops, best of 3: 3.69 ms per loop 100 loops, best of 3: 5.61 ms per loop
while 1 比 while true快不少，緣由是在python2.x中，True是一個全局變量，而非關鍵字。
-
使用**而不是pow
%timeit -n 10000 c = pow(2,20) %timeit -n 10000 c = 2**20 10000 loops, best of 3: 284 ns per loop 10000 loops, best of 3: 16.9 ns per loop
**就是快10倍以上！
-
使用 cProfile, cStringIO 和 cPickle等用c實現相同功能（分別對應profile, StringIO, pickle）的包
import cPickle import pickle a = range(10000) %timeit -n 100 x = cPickle.dumps(a) %timeit -n 100 x = pickle.dumps(a) 100 loops, best of 3: 1.58 ms per loop 100 loops, best of 3: 17 ms per loop
由c實現的包，速度快10倍以上！
-
使用最佳的反序列化方式
下面比較了eval, cPickle, json方式三種對相應字符串反序列化的效率：
import json import cPickle a = range(10000) s1 = str(a) s2 = cPickle.dumps(a) s3 = json.dumps(a) %timeit -n 100 x = eval(s1) %timeit -n 100 x = cPickle.loads(s2) %timeit -n 100 x = json.loads(s3) 100 loops, best of 3: 16.8 ms per loop 100 loops, best of 3: 2.02 ms per loop 100 loops, best of 3: 798 µs per loop
可見json比cPickle快近3倍，比eval快20多倍。
-
使用C擴展(Extension)
目前主要有CPython(python最多見的實現的方式)原生API, ctypes,Cython，cffi三種方式，它們的做用是使得Python程序能夠調用由C編譯成的動態連接庫，其特色分別是：
CPython原生API: 經過引入Python.h頭文件，對應的C程序中能夠直接使用Python的數據結構。實現過程相對繁瑣，可是有比較大的適用範圍。
ctypes: 一般用於封裝(wrap)C程序，讓純Python程序調用動態連接庫（Windows中的dll或Unix中的so文件）中的函數。若是想要在python中使用已經有C類庫，使用ctypes是很好的選擇，有一些基準測試下，python2+ctypes是性能最好的方式。
Cython: Cython是CPython的超集，用於簡化編寫C擴展的過程。Cython的優勢是語法簡潔，能夠很好地兼容numpy等包含大量C擴展的庫。Cython的使得場景通常是針對項目中某個算法或過程的優化。在某些測試中，能夠有幾百倍的性能提高。
cffi: cffi的就是ctypes在pypy（詳見下文）中的實現，同進也兼容CPython。cffi提供了在python使用C類庫的方式，能夠直接在python代碼中編寫C代碼，同時支持連接到已有的C類庫。
使用這些優化方式通常是針對已有項目性能瓶頸模塊的優化，能夠在少許改動原有項目的狀況下大幅度地提升整個程序的運行效率。
-
並行編程
由於GIL的存在，Python很難充分利用多核CPU的優點。可是，能夠經過內置的模塊multiprocessing實現下面幾種並行模式：
多進程：對於CPU密集型的程序，可使用multiprocessing的Process,Pool等封裝好的類，經過多進程的方式實現並行計算。可是由於進程中的通訊成本比較大，對於進程之間須要大量數據交互的程序效率未必有大的提升。
多線程：對於IO密集型的程序，multiprocessing.dummy模塊使用multiprocessing的接口封裝threading，使得多線程編程也變得很是輕鬆(好比可使用Pool的map接口，簡潔高效)。
分佈式：multiprocessing中的Managers類提供了能夠在不一樣進程之共享數據的方式，能夠在此基礎上開發出分佈式的程序。
不一樣的業務場景能夠選擇其中的一種或幾種的組合實現程序性能的優化。
-
終級大殺器：PyPy
PyPy是用RPython(CPython的子集)實現的Python，根據官網的基準測試數據，它比CPython實現的Python要快6倍以上。快的緣由是使用了Just-in-Time(JIT)編譯器，即動態編譯器，與靜態編譯器(如gcc,javac等)不一樣，它是利用程序運行的過程的數據進行優化。因爲歷史緣由，目前pypy中還保留着GIL，不過正在進行的STM項目試圖將PyPy變成沒有GIL的Python。
若是python程序中含有C擴展(非cffi的方式)，JIT的優化效果會大打折扣，甚至比CPython慢（比Numpy）。因此在PyPy中最好用純Python或使用cffi擴展。
隨着STM，Numpy等項目的完善，相信PyPy將會替代CPython。
-
使用性能分析工具
除了上面在ipython使用到的timeit模塊，還有cProfile。cProfile的使用方式也很是簡單： python -m cProfile filename.py，filename.py 是要運行程序的文件名，能夠在標準輸出中看到每個函數被調用的次數和運行的時間，從而找到程序的性能瓶頸，而後能夠有針對性地優化。
參考
[1] http://www.ibm.com/developerworks/cn/linux/l-cn-python-optim/
[2] http://maxburstein.com/blog/speeding-up-your-python-code/
=========================
http://code.oneapm.com/python/2015/05/18/python-performance-tips/
原文地址：https://blog.newrelic.com/2015/01/21/python-performance-tips/
Python是一門優秀的語言，它能讓你在短期內經過極少許代碼就能完成許多操做。不只如此，它還輕鬆支持多任務處理，好比多進程。
不喜歡Python的人常常會吐嘈Python運行太慢。可是，事實並不是如此。嘗試如下六個竅門，來爲你的Python應用提速。
竅門一：關鍵代碼使用外部功能包
Python簡化了許多編程任務，可是對於一些時間敏感的任務，它的表現常常不盡人意。使用C/C++或機器語言的外部功能包處理時間敏感任務，能夠有效提升應用的運行效率。這些功能包每每依附於特定的平臺，所以你要根據本身所用的平臺選擇合適的功能包。簡而言之，這個竅門要你犧牲應用的可移植性以換取只有經過對底層主機的直接編程才能得到的運行效率。如下是一些你能夠選擇用來提高效率的功能包：
這些功能包的用處各有不一樣。好比說，使用C語言的數據類型，可使涉及內存操做的任務更高效或者更直觀。Pyrex就能幫助Python延展出這樣的功能。Pylnline能使你在Python應用中直接使用C代碼。內聯代碼是獨立編譯的，可是它把全部編譯文件都保存在某處，並能充分利用C語言提供的高效率。
竅門二：在排序時使用鍵
Python含有許多古老的排序規則，這些規則在你建立定製的排序方法時會佔用不少時間，而這些排序方法運行時也會拖延程序實際的運行速度。最佳的排序方法實際上是儘量多地使用鍵和內置的sort()方法。譬如，拿下面的代碼來講：
import operator somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)] somelist.sort(key=operator.itemgetter(0)) somelist #Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)] somelist.sort(key=operator.itemgetter(1)) somelist #Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)] somelist.sort(key=operator.itemgetter(2)) somelist #Output = [(6, 2, 4), (9, 7, 5), (1, 5, 8)],
在每段例子裏，list都是根據你選擇的用做關鍵參數的索引進行排序的。這個方法不只對數值類型有效，還一樣適用於字符串類型。
竅門三：針對循環的優化
每一種編程語言都強調最優化的循環方案。當使用Python時，你能夠藉助豐富的技巧讓循環程序跑得更快。然而，開發者們常常遺忘的一個技巧是：儘可能避免在循環中訪問變量的屬性。譬如，拿下面的代碼來講：
lowerlist = ['this', 'is', 'lowercase'] upper = str.upper upperlist = [] append = upperlist.append for word in lowerlist: append(upper(word)) print(upperlist) #Output = ['THIS', 'IS', 'LOWERCASE']
每次你調用str.upper, Python都會計算這個式子的值。然而，若是你把這個求值賦值給一個變量，那麼求值的結果就能提早知道，Python程序就能運行得更快。所以，關鍵就是儘量減少Python在循環中的工做量。由於Python解釋執行的特性，在上面的例子中會大大減慢它的速度。
（注意：優化循環的方法還有不少，這只是其中之一。好比，不少程序員會認爲，列表推導式是提升循環速度的最佳方法。關鍵在於，優化循環方案是提升應用程序運行速度的上佳選擇。）
竅門四：使用較新的Python版本
若是你在網上搜索Python，你會發現數不盡的信息都是關於如何升級Python版本。一般，每一個版本的Python都會包含優化內容，使其運行速度優於以前的版本。可是，限制因素在於，你最喜歡的函數庫有沒有同步更新支持新的Python版本。與其爭論函數庫是否應該更新，關鍵在於新的Python版本是否足夠高效來支持這一更新。
你要保證本身的代碼在新版本里還能運行。你須要使用新的函數庫才能體驗新的Python版本，而後你須要在作出關鍵性的改動時檢查本身的應用。只有當你完成必要的修正以後，你才能體會新版本的不一樣。
然而，若是你只是確保本身的應用在新版本中能夠運行，你極可能會錯過新版本提供的新特性。一旦你決定更新，請分析你的應用在新版本下的表現，並檢查可能出問題的部分，而後優先針對這些部分應用新版本的特性。只有這樣，用戶才能在更新之初就覺察到應用性能的改觀。
竅門五：嘗試多種編碼方法
每次建立應用時都使用同一種編碼方法幾乎無一例外會致使應用的運行效率不盡人意。能夠在程序分析時嘗試一些試驗性的辦法。譬如說，在處理字典中的數據項時，你既可使用安全的方法，先確保數據項已經存在再進行更新，也能夠直接對數據項進行更新，把不存在的數據項做爲特例分開處理。請看下面第一段代碼：
n = 16 myDict = {} for i in range(0, n): char = 'abcd'[i%4] if char not in myDict: myDict[char] = 0 myDict[char] += 1 print(myDict)
當一開始myDict爲空時，這段代碼會跑得比較快。然而，一般狀況下，myDict填滿了數據，至少填有大部分數據，這時換另外一種方法會更有效率。
n = 16 myDict = {} for i in range(0, n): char = 'abcd'[i%4] try: myDict[char] += 1 except KeyError: myDict[char] = 1 print(myDict)
在兩種方法中輸出結果都是同樣的。區別在於輸出是如何得到的。跳出常規的思惟模式，建立新的編程技巧能使你的應用更有效率。
竅門六：交叉編譯你的應用
開發者有時會忘記計算機其實並不理解用來建立現代應用程序的編程語言。計算機理解的是機器語言。爲了運行你的應用，你藉助一個應用將你所編的人類可讀的代碼轉換成機器可讀的代碼。有時，你用一種諸如Python這樣的語言編寫應用，再以C++這樣的語言運行你的應用，這在運行的角度來講，是可行的。關鍵在於，你想你的應用完成什麼事情，而你的主機系統能提供什麼樣的資源。
Nuitka是一款有趣的交叉編譯器，能將你的Python代碼轉化成C++代碼。這樣，你就能夠在native模式下執行本身的應用，而無需依賴於解釋器程序。你會發現本身的應用運行效率有了較大的提升，可是這會因平臺和任務的差別而有所不一樣。
（注意：Nuitka如今還處在測試階段，因此在實際應用中請多加註意。實際上，當下最好仍是把它用於實驗。此外，關於交叉編譯是否爲提升運行效率的最佳方法還存在討論的空間。開發者已經使用交叉編譯多年，用來提升應用的速度。記住，每一種解決辦法都有利有弊，在把它用於生產環境以前請仔細權衡。）
在使用交叉編譯器時，記得確保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。爲了讓解決方案生效，你須要一個Python解釋器和一個C++編譯器。Nuitka支持許多C++編譯器，其中包括Microsoft Visual Studio,MinGW 和 Clang/LLVM。
交叉編譯可能形成一些嚴重問題。好比，在使用Nuitka時，你會發現即使是一個小程序也會消耗巨大的驅動空間。由於Nuitka藉助一系列的動態連接庫（DDLs）來執行Python的功能。所以，若是你用的是一個資源頗有限的系統，這種方法或許不太可行。
結論
前文所述的六個竅門都能幫助你建立運行更有效率的Python應用。可是銀彈是不存在的。上述的這些竅門不必定每次都能奏效。在特定的Python的版本下，有的竅門或許比其餘的表現更好，但這有時候甚至取決於平臺的差別。你須要總結分析你的應用，找到它效率低下的部分，而後嘗試這些竅門，找到解決問題的最佳方法。
這篇文章主要介紹了幾個提高Python運行效率的方法之間的對比,包括使用Cython和PyPy等這些熱門方法,須要的朋友能夠參考下
在我看來，python社區分爲了三個流派，分別是python 2.x組織，3.x組織和PyPy組織。這個分類基本上能夠歸根於類庫的兼容性和速度。這篇文章將聚焦於一些通用代碼的優化技巧以及編譯成C後性能的顯著提高，固然我也會給出三大主要python流派運行時間。個人目的不是爲了證實一個比另外一個強，只是爲了讓你知道如何在不一樣的環境下使用這些具體例子做比較。
使用生成器
一個廣泛被忽略的內存優化是生成器的使用。生成器讓咱們建立一個函數一次只返回一條記錄，而不是一次返回全部的記錄，若是你正在使用python2.x，這就是你爲啥使用xrange替代range或者使用ifilter替代filter的緣由。一個很好地例子就是建立一個很大的列表並將它們拼合在一塊兒。
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
這不只是快了一點，也避免了你在內存中存儲所有的列表!
Ctypes的介紹
對於關鍵性的性能代碼python自己也提供給咱們一個API來調用C方法，主要經過 ctypes來實現，你能夠不寫任何C代碼來利用ctypes。默認狀況下python提供了預編譯的標準c庫，咱們再回到生成器的例子，看看使用ctypes實現花費多少時間。
import timeit
from ctypes import cdll def generate_c(num):
僅僅換成了c的隨機函數，運行時間減了大半！如今若是我告訴你咱們還能作得更好，你信嗎?
Cython的介紹
Cython 是python的一個超集，容許咱們調用C函數以及聲明變量來提升性能。嘗試使用以前咱們須要先安裝Cython.
sudo pip install cython
Cython 本質上是另外一個再也不開發的相似類庫Pyrex的分支，它將咱們的類Python代碼編譯成C庫，咱們能夠在一個python文件中調用。對於你的python文件使用.pyx後綴替代.py後綴，讓咱們看一下使用Cython如何來運行咱們的生成器代碼。
咱們須要建立個setup.py以便咱們能獲取到Cython來編譯咱們的函數。
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"])] )
編譯使用:
python setup.py build_ext --inplace
你應該能夠看到兩個文件cython_generator.c 文件 和 generator.so文件，咱們使用下面方法測試咱們的程序:
import timeit
print(timeit.timeit("sum(generator.generate(999))", setup="import generator", number=1000)) >>> 0.835658073425
還不賴，讓咱們看看是否還有能夠改進的地方。咱們能夠先聲明「num」爲整形，接着咱們能夠導入標準的C庫來負責咱們的隨機函數。
若是咱們再次編譯運行咱們會看到這一串驚人的數字。
>>> 0.033586025238
僅僅的幾個改變帶來了不賴的結果。然而，有時這個改變很乏味，所以讓咱們來看看如何使用規則的python來實現吧。
PyPy的介紹
PyPy 是一個Python2.7.3的即時編譯器，通俗地說這意味着讓你的代碼運行的更快。Quora在生產環境中使用了PyPy。PyPy在它們的下載頁面有一些安裝說明，可是若是你使用的Ubuntu系統，你能夠經過apt-get來安裝。它的運行方式是當即可用的，所以沒有瘋狂的bash或者運行腳本，只需下載而後運行便可。讓咱們看看咱們原始的生成器代碼在PyPy下的性能如何。
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
哇！沒有修改一行代碼運行速度是純python實現的8倍。
進一步測試爲何還要進一步研究？PyPy是冠軍！並不全對。雖然大多數程序能夠運行在PyPy上，可是仍是有一些庫沒有被徹底支持。並且，爲你的項目寫C的擴展相比換一個編譯器更加容易。讓咱們更加深刻一些，看看ctypes如何讓咱們使用C來寫庫。咱們來測試一下歸併排序和計算斐波那契數列的速度。下面是咱們要用到的C代碼（functions.c）：
在Linux平臺，咱們能夠用下面的方法把它編譯成一個共享庫：
gcc -Wall -fPIC -c functions.c
gcc -shared -o libfunctions.so functions.o
使用ctypes， 經過加載」libfunctions.so」這個共享庫，就像咱們前邊對標準C庫所做的那樣，就可使用這個庫了。這裏咱們將要比較Python實現和C實現。如今咱們開始計算斐波那契數列：
正如咱們預料的那樣，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文件中了。
#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)) 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
這兒經過表格和圖標來比較不一樣的結果。
.
