阅读Zen of Python,在Python 解析器中输入import this. 一个犀利的Python 新手可能会注意到"解析"一词, 认为Python 不过是另一门脚本语言. "它肯定很慢!"

     毫无疑问:Python 程序没有编译型语言高效快速. 甚至Python 拥护者们会告诉你Python 不适合这些领域. 然而,YouTube 已用Python 服务于每小时4 千万视频的请求. 你所要做的就是编写高效的代码和需要时使用外部实现(C/C++)代码. 这里有一些建议,可以帮助你成为一个更好的Python 开发者:

     你可以用Python 写出高效的代码,但很难击败内建函数. 经查证. 他们非常快速.

    

     你可以使用"+" 来连接字符串. 但由于string 在Python 中是不可变的,每一个"+"操作都会创建一个新的字符串并复制旧内容. 常见用法是使用Python 的数组模块单个的修改字符;当完成的时候,使用join() 函数创建最终字符串.

>>> #This is good to glue a large number of strings
>>> for chunk in input():
>>>     my_string.join(chunk)

     这在Python 中即优雅又快速:

>>> x, y = y, x

     这样很慢:

>>> temp = x
>>> x = y
>>> y = temp

     Python 检索局部变量比检索全局变量快. 这意味着,避免"global" 关键字.

     变量的查找顺序是：（局部变量->全局变量->内建名字空间）

     使用"in" 关键字. 简洁而快速.

>>> for key in sequence:
>>>     print “found”

     將"import" 声明移入函数中,仅在需要的时候导入. 换句话说,如果某些模块不需马上使用,稍后导入他们. 例如,你不必在一开使就导入大量模块而加速程序启动. 该技术不能提高整体性能. 但它可以帮助你更均衡的分配模块的加载时间.

     有时候在程序中你需一个无限循环.(例如一个监听套接字的实例) 尽管"while true" 能完成同样的事, 但"while 1" 是单步运算. 这招能提高你的Python 性能.

>>> while 1:
>>>     #do stuff, faster with while 1
>>> while True:
>>>     # do stuff, slower with wile True

     从Python 2.0 开始,你可以使用list comprehension 取代大量的"for" 和"while" 块.使用List comprehension 通常更快，Python 解析器能在循环中发现它是一个可预测的模式而被优化.额外好处是，list comprehension 更具可读性（函数式编程），并在大多数情况下，它可以节省一个额外的计数变量。例如，让我们计算1 到10 之间的偶数个数：

>>> # the good way to iterate a range
>>> evens = [ i for i in range(10) if i%2 == 0]
>>> [0, 2, 4, 6, 8]
>>> # the following is not so Pythonic
>>> i = 0
>>> evens = []
>>> while i < 10:
>>>     if i %2 == 0: evens.append(i)
>>>     i += 1
>>> [0, 2, 4, 6, 8]

     这样可为你节省大量的系统内存，因为xrange()在序列中每次调用只产生一个整数元素（迭代器）。而相反range()，它將直接给你一个完整的元素列表，用于循环时会有不必要的开销。

     这也可以节省内存和提高性能。例如一个视频流，你可以一个一个字节块的发送，而不是整个流。例如，

>>> chunk = ( 1000 * i for i in xrange(1000))
>>> chunk
<generator object <genexpr> at 0x7f65d90dcaa0>
>>> chunk.next()
0
>>> chunk.next()
1000
>>> chunk.next()
2000

     该模块对迭代和组合是非常有效的。让我们生成一个列表[1，2，3]的所有排列组合,仅需三行Python 代码：

>>> import itertools
>>> iter = itertools.permutations([1,2,3])
>>> list(iter)
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

     这是一个免费的二分查找实现和快速插入有序序列的工具。也就是说，你可以使用：

>>> import bisect
>>> a=[1,2,3,4,5,7,0]
>>> bisect.insort(a,6)
>>> a
[1, 2, 3, 4, 5, 6, 7, 0]

你已將一个元素插入列表中, 而你不需要再次调用sort() 来保持容器的排序, 因为这在长序列中这会非常昂贵.

     Python 中的列表实现并不是以人们通常谈论的计算机科学中的普通单链表实现的。

     Python 中的列表是一个数组。也就是说，你可以以常量时间O(1) 检索列表的某个元素，而不需要从头开始搜索。这有什么意义呢？ Python 开发人员使用列表对象insert（）时, 需三思.

      例如：>>> list.insert（0，item）

     在列表的前面插入一个元素效率不高, 因为列表中的所有后续下标不得不改变. 然而，您可以使用list.append()在列表的尾端有效添加元素. 挑先deque，如果你想快速的在两插入或时。它是快速的，因为在Python 中的deque 用双链表实现。不再多说。:)

    检查一个元素是在dicitonary 或set 是否存在这在Python 中非常快的。这是因为dict和set 使用哈希表来实现。查找效率可以达到O(1)。因此，如果您需要经常检查成员，使用set 或dict 做为你的容器.

>>> mylist = ['a', 'b', 'c'] #Slower, check membership with list:
>>> ‘c’ in mylist
>>> True
>>> myset = set(['a', 'b', 'c']) # Faster, check membership with set:
>>> ‘c’ in myset:
>>> True

     原生的list.sort（）函数是非常快的。Python 会按自然顺序排序列表。有时，你需要非自然顺序的排序。例如，你要根据服务器位置排序的IP 地址。Python 支持自定义的比较，你可以使用list.sort（CMP（）），这会比list.sort（）慢，因为增加了函数调用的开销。如果性能有问题，你可以申请Guttman-Rosler Transform,基于Schwartzian Transform. 它只对实际的要用的算法有兴趣，它的简要工作原理是，你可以变换列表，并调用Python 内置list.sort（） - > 更快，而无需使用list.sort（CMP（） ）->慢。

“@”符号是Python 的装饰语法。它不只用于追查，锁或日志。你可以装饰一个Python函数，记住调用结果供后续使用。这种技术被称为memoization 的。下面是一个例子：

>>> from functools import wraps
>>> def memo(f):
>>>     cache = { }
>>>     @wraps(f)
>>>     def wrap(*arg):
>>>         if arg not in cache: cache['arg'] = f(*arg)
>>>         return cache['arg']
>>>     return wrap

我们也可以对Fibonacci 函数使用装饰器:

>>> @memo
>>> def fib(i):
>>>     if i < 2: return 1
>>>     return fib(i-1) + fib(i-2)

这里的关键思想是:增强函数(装饰)函数,记住每个已经计算的Fibonacci 值;如果它们在缓存中,就不需要再计算了.

     GIL 是必要的，因为CPython 的内存管理是非线程安全的。你不能简单地创建多个线程，并希望Python 能在多核心的机器上运行得更快。这是因为GIL 將会防止多个原生线程同时执行Python 字节码。换句话说，GIL 將序列化您的所有线程。然而，您可以使用线程管理多个派生进程加速程序，这些程序独立的运行于你的Python 代码外。

Python 有些模块为了性能使用C 实现。当性能至关重要而官方文档不足时，可以自由探索源代码。你可以找到底层的数据结构和算法。Python 的源码库就是一个很棒的地方：http://svn.python.org/view/python/trunk/Modules

     这些不能替代大脑思考. 打开引擎盖充分了解是开发者的职责,使得他们不会快速拼凑出一个垃圾设计. 本文的Python 建议可以帮助你获得好的性能. 如果速度还不够快, Python 將需要借助外力:分析和运行外部代码.我们將在本文的第二部分中涉及.

     有益的提醒,静态编译的代码仍然重要. 仅例举几例, Chrome,Firefox,MySQL,MS Office 和Photoshop 都是高度优化的软件,我们每天都在使用. Python 作为解析语言,很明显不适合. 不能单靠Python 来满足那些性能是首要指示的领域. 这就是为什么Python 支持让你接触底层裸机基础设施的原因, 将更繁重的工作代理给更快的语言如C. 这高性能计算和嵌入式编程中是关键的功能. Python 性能鸡汤第一部分讨论了怎样高效的使用Python. 在第二部分, 我们將涉及监控和扩展Python.

     调优给你的代码增加复杂性. 集成其它语言之前, 请检查下面的列表. 如果你的算法是"足够好", 优化就没那么迫切了.

1. 你做了性能测试报告吗?

2. 你能减少硬盘的I/O 访问吗?

3. 你能减少网络I/O 访问吗?

4. 你能升级硬件吗?

5. 你是为其它开发者编译库吗?

6.你的第三方库软件是最新版吗?

     速度的问题可能很微妙, 所以不要依赖于直觉. 感谢"cprofiles" 模块, 通过简单的运行你就可以监控Python 代码“python -m cProfile myprogram.py”

     

     我们写了个测试程序. 基于黑盒监控. 这里的瓶颈是"very_slow()" 函数调用. 我们还可以看到"fast()" 和"slow()"都被调用200次. 这意味着, 如果我们可以改善"fast()"和"slow()" 函数, 我们可以获得全面的性能提升. cprofiles 模块也可以在运行时导入. 这对于检查长时间运行的进程非常有用.

     

     控制以后, 提供一个基本的算法性能分析. 恒定时间是理想值. 对数时间复度是稳定的. 阶乘复杂度很难扩展.

     O(1) -> O(lg n) -> O(n lg n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)

     有很多为Python 设计的高性能的第三方库和工具. 下面是一些有用的加速包的简短列表.

1. NumPy: 一个开源的相当于MatLab 的包

2. SciPy: 另一个数值处理库

3. GPULib: 使用GPUs 加速代码

4. PyPy: 使用just-in-time 编译器优化Python 代码

5. Cython: 將Python 代码转成C

6. ShedSkin: 將Python 代码转成C++

     因为GIL 会序列化线程, Python 中的多线程不能在多核机器和集群中加速. 因此Python 提供了multiprocessing 模块, 可以派生额外的进程代替线程, 跳出GIL 的限制. 此外,你也可以在外部C 代码中结合该建议, 使得程序更快.

注意, 进程的开销通常比线程昂贵, 因为线程自动共享内存地址空间和文件描述符.意味着, 创建进程比创建线程会花费更多, 也可能花费更多内存. 这点在你计算使用多处理器时要牢记.

     好了, 现在你决定为了性能使用本地代码. 在标准的ctypes 模块中, 你可以直接加载已编程的二进制库(.dll 或.so 文件)到Python 中, 无需担心编写C/C++代码或构建依赖.例如, 我们可以写个程序加载libc 来生成随机数.然而, 绑定ctypes 的开销是非轻量级的. 你可以认为ctypes 是一个粘合操作系库函数或者硬件设备驱动的胶水. 有几个如SWIG, Cython 和Boost 此类Python 直接植入的库的调用比ctypes 开销要低. Python 支持面向对象特性, 如类和继承. 正如我们看到的例子, 我们可以保留常规的C++代码, 稍后导入. 这里的主要工作是编写一个包装器(行10~18).

        

       

 

     我希望这些Python 建议能让你成为一个更好的开发者. 最后, 我需要指出, 追求性能极限是一个有趣的游戏, 而过度优化就会变成嘲弄了. 虽然Python 授予你与C 接口无缝集成的能力, 你必须问自己你花数小时的艰辛优化工作用户是否买帐. 另一方面, 牺牲代码的可维护性换取几毫秒的提升是否值得. 团队中的成员常常会感谢你编写了简洁的代码. 尽量贴近Python 的方式, 因为人生苦短. :)

英文原文:http://blog.monitis.com/index.php/2012/02/13/python-performance-tips-part-1/

英文原文:http://blog.monitis.com/index.php/2012/03/21/python-performance-tips-part-2/