Python性能优化的20条建议

优化算法时间复杂度

算法的时间复杂度对程序的执行效率影响最大，在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

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

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

可是对于须要循环遍历的状况：

%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 是要运行程序的文件名，能够在标准输出中看到每个函数被调用的次数和运行的时间，从而找到程序的性能瓶颈，而后能够有针对性地优化。

---

 

​

    识别图中二维码,领取python全套视频资料