Python性能優化的20條建議 (轉載)

時間 2019-11-13

標籤 python 性能優化建議轉載欄目 Python 简体版

原文原文鏈接

優化算法時間複雜度
算法的時間複雜度對程序的執行效率影響最大，在Python中能夠經過選擇合適的數據結構來優化時間複雜度，如list和set查找某一個元素的時間複雜度分別是O(n)和O(1)。不一樣的場景有不一樣的優化方式，總得來講，通常有分治，分支界限，貪心，動態規劃等思想。php
減小冗餘數據
如用上三角或下三角的方式去保存一個大的對稱矩陣。在0元素佔大多數的矩陣裏使用稀疏矩陣表示。java
合理使用copy與deepcopy
對於dict和list等數據結構的對象，直接賦值使用的是引用的方式。而有些狀況下須要複製整個對象，這時可使用copy包裏的copy和deepcopy，這兩個函數的不一樣之處在於後者是遞歸複製的。效率也不同：（如下程序在ipython中運行）python

import copy
a = range(100000)
%timeit -n 10 copy.copy(a) # 運行10次 copy.copy(a)
%timeit -n 10 copy.deepcopy(a)
10 loops, best of 3: 1.55 ms per loop
10 loops, best of 3: 151 ms per loop

timeit後面的-n表示運行的次數，後兩行對應的是兩個timeit的輸出，下同。因而可知後者慢一個數量級。linux
使用dict或set查找元素
python dict和set都是使用hash表來實現(相似c++11標準庫中unordered_map)，查找元素的時間複雜度是O(1)c++

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的效率略高(佔用的空間也多一些)。算法
合理使用生成器（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)])快。編程

可是對於須要循環遍歷的狀況：json

%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更佳(人個喜愛)。多線程

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 是要運行程序的文件名，能夠在標準輸出中看到每個函數被調用的次數和運行的時間，從而找到程序的性能瓶頸，而後能夠有針對性地優化。