Python效能優化的20條建議

發表於2016-06-14

優化演算法時間複雜度

演算法的時間複雜度對程式的執行效率影響最大，在Python中可以通過選擇合適的資料結構來優化時間複雜度，如list和set查詢某一個元素的時間複雜度分別是O(n)和O(1)。不同的場景有不同的優化方式，總得來說，一般有分治，分支界限，貪心，動態規劃等思想。

減少冗餘資料

如用上三角或下三角的方式去儲存一個大的對稱矩陣。在0元素佔大多數的矩陣裡使用稀疏矩陣表示。

合理使用copy與deepcopy

對於dict和list等資料結構的物件，直接賦值使用的是引用的方式。而有些情況下需要複製整個物件，這時可以使用copy包裡的copy和deepcopy，這兩個函式的不同之處在於後者是遞迴複製的。效率也不一樣：（以下程式在ipython中執行）

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

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的輸出，下同。由此可見後者慢一個數量級。

使用dict或set查詢元素

python dict和set都是使用hash表來實現(類似c++11標準庫中unordered_map)，查詢元素的時間複雜度是O(1)

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

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

%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)])快。

但是對於需要迴圈遍歷的情況：

%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

%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

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

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

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

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

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

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

Python

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

1
2
3
4
5
6
7

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

Python

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

1
2
3
4
5
6
7

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

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

Python

%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

1
2
3
4
5
6

%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

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

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/

8條關於Web前端效能的優化建議
2017-12-26
Web前端優化
UITableView效能優化的幾點建議
2020-10-17
UIView優化
優化 Webpack 構建效能的幾點建議
2017-12-27
優化Web
優化Webpack構建效能的幾點建議
2017-12-26
優化Web
PHP程式碼優化的40條建議
2017-11-27
PHP優化
oracle 效能優化建議小結
2014-07-13
Oracle優化
Android 優化APP 構建速度的17條建議
2017-03-16
Android優化APP
Android 優化 APP 構建速度的 17 條建議
2017-03-22
Android優化APP
雅虎軍規——前端優化的35條建議
2017-07-14
前端優化
ORACLE SQL 效能優化的一些建議
2016-07-18
OracleSQL優化
.NET程式的效能要領和優化建議
2015-07-30
優化
挑戰月薪30K | 前端效能優化的12 條建議（乾貨收藏）
2020-12-22
前端優化
對Android開發者有益的40條優化建議
2013-09-16
Android優化
優化python程式的幾點建議
2017-07-21
優化Python
MySQL 高效能優化規範建議
2020-02-09
MySql優化
關於Android開發的40條優化建議
2016-03-24
Android優化
(1) Mysql高效能優化規範建議
2019-01-04
MySql優化
CSS 寫作建議和效能優化小結
2017-09-28
CSS優化
記一次介面效能優化實踐總結：優化介面效能的八個建議
2020-06-08
優化
SQL語句優化的34條建議(轉-浪花七八朵 )
2008-12-25
SQL優化
Redis優化建議
2019-08-04
Redis優化
EntityFramework 優化建議
2018-06-09
Framework優化
Mysql優化建議
2016-02-23
MySql優化
MySQL 效能優化的最佳 20+ 條經驗
2015-05-18
MySql優化
MySQL效能優化的最佳20+條經驗
2013-03-15
MySql優化
Zabbix 5.0 優化建議
2021-05-20
優化
html前端優化建議
2019-01-21
HTML前端優化
頁面優化建議
2016-06-15
優化
mysql優化 | 儲存引擎，建表，索引，sql的優化建議
2019-02-01
MySql優化儲存引擎索引
優化MySQL的21個建議
2014-11-27
優化MySql
iOS 實際開發中對效能優化的幾點建議
2017-02-15
iOS優化
成為優秀Swift開發者的10條建議
2016-11-25
Swift
一條sql語句的建議調優分析
2015-06-19
SQL
MySQL 調優/優化的 100 個建議
2015-07-08
MySql優化
資料庫優化建議
2018-05-15
資料庫優化
總結 90 條寫 Python 程式的建議
2020-05-27
Python
python效能優化
2020-04-03
Python優化
Python 效能優化
2017-11-27
Python優化

Python效能優化的20條建議

減少冗餘資料

合理使用copy與deepcopy

使用dict或set查詢元素

合理使用生成器（generator）和yield

優化迴圈

優化包含多個判斷表示式的順序

使用join合併迭代器中的字串

選擇合適的格式化字元方式

不借助中間變數交換兩個變數的值

使用`if is`

使用級聯比較`x < y < z`

`while 1` 比 `while True` 更快

使用`**`而不是pow

使用 cProfile, cStringIO 和 cPickle等用c實現相同功能（分別對應profile, StringIO, pickle）的包

使用最佳的反序列化方式

使用C擴充套件(Extension)

並行程式設計

終級大殺器：PyPy

使用效能分析工具

參考

相關文章

Python效能優化的20條建議

減少冗餘資料

合理使用copy與deepcopy

使用dict或set查詢元素

合理使用生成器（generator）和yield

優化迴圈

優化包含多個判斷表示式的順序

使用join合併迭代器中的字串

選擇合適的格式化字元方式

不借助中間變數交換兩個變數的值

使用if is

使用級聯比較x < y < z

while 1 比 while True 更快

使用**而不是pow

使用 cProfile, cStringIO 和 cPickle等用c實現相同功能（分別對應profile, StringIO, pickle）的包

使用最佳的反序列化方式

使用C擴充套件(Extension)

並行程式設計

終級大殺器：PyPy

使用效能分析工具

參考

相關文章

使用`if is`

使用級聯比較`x < y < z`

`while 1` 比 `while True` 更快

使用`**`而不是pow