提升Python运行效率的六个窍门

Python性能优化的20条建议

http://segmentfault.com/a/1190000000666603

1. 优化算法时间复杂度

   算法的时间复杂度对程序的执行效率影响最大，在Python中能够经过选择合适的数据结构来优化时间复杂度，如list和set查找某一个元素的时间复杂度分别是O(n)和O(1)。不一样的场景有不一样的优化方式，总得来讲，通常有分治，分支界限，贪心，动态规划等思想。

2. 减小冗余数据

   如用上三角或下三角的方式去保存一个大的对称矩阵。在0元素占大多数的矩阵里使用稀疏矩阵表示。

3. 合理使用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的输出，下同。因而可知后者慢一个数量级。

4. 使用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的效率略高(占用的空间也多一些)。

5. 合理使用生成器（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包等。

6. 优化循环

   循环以外能作的事不要放在循环内，好比下面的优化能够快一倍：

   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 

7. 优化包含多个判断表达式的顺序

   对于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 

8. 使用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倍的提高。

9. 选择合适的格式化字符方式

   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 

   三种状况中，%的方式是最慢的，可是三者的差距并不大（都很是快）。(我的以为%的可读性最好)

10. 不借助中间变量交换两个变量的值

    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倍以上。

11. 使用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 将近快一倍。

12. 使用级联比较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效率略高，并且可读性更好。

13. 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是一个全局变量，而非关键字。

14. 使用**而不是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倍以上！

15. 使用 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倍以上！

16. 使用最佳的反序列化方式

    下面比较了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多倍。

17. 使用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类库。

    使用这些优化方式通常是针对已有项目性能瓶颈模块的优化，能够在少许改动原有项目的状况下大幅度地提升整个程序的运行效率。

18. 并行编程

    由于GIL的存在，Python很难充分利用多核CPU的优点。可是，能够经过内置的模块multiprocessing实现下面几种并行模式：

    多进程：对于CPU密集型的程序，可使用multiprocessing的Process,Pool等封装好的类，经过多进程的方式实现并行计算。可是由于进程中的通讯成本比较大，对于进程之间须要大量数据交互的程序效率未必有大的提升。

    多线程：对于IO密集型的程序，multiprocessing.dummy模块使用multiprocessing的接口封装threading，使得多线程编程也变得很是轻松(好比可使用Pool的map接口，简洁高效)。

    分布式：multiprocessing中的Managers类提供了能够在不一样进程之共享数据的方式，能够在此基础上开发出分布式的程序。

    不一样的业务场景能够选择其中的一种或几种的组合实现程序性能的优化。

19. 终级大杀器：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。

20. 使用性能分析工具

    除了上面在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++或机器语言的外部功能包处理时间敏感任务，能够有效提升应用的运行效率。这些功能包每每依附于特定的平台，所以你要根据本身所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有经过对底层主机的直接编程才能得到的运行效率。如下是一些你能够选择用来提高效率的功能包：

• Cython
• Pylnlne
• PyPy
• Pyrex

这些功能包的用处各有不一样。好比说，使用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的版本下，有的窍门或许比其余的表现更好，但这有时候甚至取决于平台的差别。你须要总结分析你的应用，找到它效率低下的部分，而后尝试这些窍门，找到解决问题的最佳方法。