转自：http://www.douban.com/group/topic/31478102/

这个资料库还有些不错的好文章： 
http://www.ibm.com/developerworks/cn/ 

来看这篇《Python 代码性能优化技巧》http://www.ibm.com/developerworks/cn/linux/l-cn-python-optim/index.html 

原文标题是代码性能优化，关键是性能优化，如果纯是代码优化则跟代码重构无异。 

代码性能优化的本质：保证代码正确行的前提下，优化代码运行效率，节约时间资源和硬件资源（cpu，内存）（如此说来，代码体积上的减少不算是性能优化）。 

改进算法，选择合适的数据结构 
一个良好的算法能够对性能起到关键作用，因此性能改进的首要点是对算法的改进。在算法的时间复杂度排序上依次是： 
O(1) -> O(lg n) -> O(n lg n) -> O(n)-> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!) 
（O(n)是我加上的） 

优化前要根据特定场景选择合适的数据结构：set, list, dict. 

因此如果能够在时间复杂度上对算法进行一定的改进，对性能的提高不言而喻。但对具体算法的改进不属于本文讨论的范围，读者可以自行参考这方面资料。下面的内容将集中讨论数据结构的选择。 
字典 (dictionary) 与列表 (list) 
Python 字典中使用了 hash table，因此查找操作的复杂度为 O(1)，而 list 实际是个数组，在 list 中，查找需要遍历整个 list，其复杂度为 O(n)，因此对成员的查找访问等操作字典要比 list 更快。 

清单 1. 代码 dict.py 

from time import time 
t = time() 
list = [‘a‘,‘b‘,‘is‘,‘python‘,‘jason‘,‘hello‘,‘hill‘,‘with‘,‘phone‘,‘test‘, 
‘dfdf‘,‘apple‘,‘pddf‘,‘ind‘,‘basic‘,‘none‘,‘baecr‘,‘var‘,‘bana‘,‘dd‘,‘wrd‘] 
#list = dict.fromkeys(list,True) 
print list 
filter = [] 
for i in range (1000000): 
for find in [‘is‘,‘hat‘,‘new‘,‘list‘,‘old‘,‘.‘]: 
if find not in list: 
filter.append(find) 
print "total run time:" 
print time()-t 

上述代码运行大概需要 16.09seconds。如果去掉行 #list = dict.fromkeys(list,True) 的注释，将 list 转换为字典之后再运行，时间大约为 8.375 seconds，效率大概提高了一半。因此在需要多数据成员进行频繁的查找或者访问的时候，使用 dict 而不是 list 是一个较好的选择。 

我的点评： 
range改为xrange更好（python2的话，后面有） 
dict.fromkeys(list[, v]) creates a new dict with keys from list and values equal to v, v defaults to None. 


集合 (set) 与列表 (list) 
set 的 union， intersection，difference 操作要比 list 的迭代要快。因此如果涉及到求 list 交集，并集或者差的问题可以转换为 set 来操作。 
清单 2. 求 list 的交集： 

from time import time 
t = time() 
lista=[1,2,3,4,5,6,7,8,9,13,34,53,42,44] 
listb=[2,4,6,9,23] 
intersection=[] 
for i in range (1000000): 
for a in lista: 
for b in listb: 
if a == b: 
intersection.append(a) 


print "total run time:" 
print time()-t 

上述程序的运行时间大概为： 
total run time: 
38.4070000648 


清单 3. 使用 set 求交集 

from time import time 
t = time() 
lista=[1,2,3,4,5,6,7,8,9,13,34,53,42,44] 
listb=[2,4,6,9,23] 
intersection=[] 
for i in range (1000000): 
list(set(lista)&set(listb)) 
print "total run time:" 
print time()-t 

改为 set 后程序的运行时间缩减为 8.75，提高了 4 倍多，运行时间大大缩短。读者可以自行使用表 1 其他的操作进行测试。 

表 1. set 常见用法 
语法 操作 说明 
set(list1) | set(list2) union 包含 list1 和 list2 所有数据的新集合 
set(list1) & set(list2) intersection 包含 list1 和 list2 中共同元素的新集合 
set(list1) - set(list2) difference 在 list1 中出现但不在 list2 中出现的元素的集合 

补上： 
set(list1) ^ set(list2) 异或，不同时在list1和list2中的元素的集合，等价于 (set(list1) | set(list2)) - (set(list1) & set(list2)) <==> (set(list1) - set(list2)) + (set(list2) - set(list1)) 
异或用英语怎么表达来着？ 

对循环的优化 
对循环的优化所遵循的原则是尽量减少循环过程中的计算量，有多重循环的尽量将内层的计算提到上一层。 下面通过实例来对比循环优化后所带来的性能的提高。程序清单 4 中，如果不进行循环优化，其大概的运行时间约为 132.375。 
清单 4. 为进行循环优化前 

from time import time 
t = time() 
lista = [1,2,3,4,5,6,7,8,9,10] 
listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
for i in range (1000000): 
for a in range(len(lista)): 
for b in range(len(listb)): 
x=lista[a]+listb[b] 
print "total run time:" 
print time()-t 

现在进行如下优化，将长度计算提到循环外，range 用 xrange 代替，同时将第三层的计算 lista[a] 提到循环的第二层。 

清单 5. 循环优化后 

from time import time 
t = time() 
lista = [1,2,3,4,5,6,7,8,9,10] 
listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
len1=len(lista) 
len2=len(listb) 
for i in xrange (1000000): 
for a in xrange(len1): 
temp=lista[a] 
for b in xrange(len2): 
x=temp+listb[b] 
print "total run time:" 
print time()-t 

上述优化后的程序其运行时间缩短为 102.171999931。在清单 4 中 lista[a] 被计算的次数为 1000000*10*10，而在优化后的代码中被计算的次数为 1000000*10，计算次数大幅度缩短，因此性能有所提升。 

点评：循环体内的代码会执行N遍，将能放在循环体外的代码尽量挪出去。 

充分利用 Lazy if-evaluation 的特性 
python 中条件表达式是 lazy evaluation 的，也就是说如果存在条件表达式 if x and y，在 x 为 false 的情况下 y 表达式的值将不再计算。因此可以利用该特性在一定程度上提高程序效率。 

清单 6. 利用 Lazy if-evaluation 的特性 

from time import time 
t = time() 
abbreviations = [‘cf.‘, ‘e.g.‘, ‘ex.‘, ‘etc.‘, ‘fig.‘, ‘i.e.‘, ‘Mr.‘, ‘vs.‘] 
for i in range (1000000): 
for w in (‘Mr.‘, ‘Hat‘, ‘is‘, ‘chasing‘, ‘the‘, ‘black‘, ‘cat‘, ‘.‘): 
if w in abbreviations: 
#if w[-1] == ‘.‘ and w in abbreviations: 
pass 
print "total run time:" 
print time()-t 

在未进行优化之前程序的运行时间大概为 8.84，如果使用注释行代替第一个 if，运行的时间大概为 6.17。 

点评：在做数据处理时（尤其是大数据量），进行数据过滤首先要将大概率的情况首先处理，依照概率（比例）依次处理之。比如mysql的where，dpark的filter表达式，最常见的是if...else。先找出数据的特征再动手往往效果更好。 

字符串的优化 
python 中的字符串对象是不可改变的，因此对任何字符串的操作如拼接，修改等都将产生一个新的字符串对象，而不是基于原字符串，因此这种持续的 copy 会在一定程度上影响 python 的性能。对字符串的优化也是改善性能的一个重要的方面，特别是在处理文本较多的情况下。字符串的优化主要集中在以下几个方面： 
在字符串连接的使用尽量使用 join() 而不是 +：在代码清单 7 中使用 + 进行字符串连接大概需要 0.125 s，而使用 join 缩短为 0.016s。因此在字符的操作上 join 比 + 要快，因此要尽量使用 join 而不是 +。 

清单 7. 使用 join 而不是 + 连接字符串 

from time import time 

t = time() 
s = "" 
list = [‘a‘,‘b‘,‘b‘,‘d‘,‘e‘,‘f‘,‘g‘,‘h‘,‘i‘,‘j‘,‘k‘,‘l‘,‘m‘,‘n‘] 
for i in range (10000): 
for substr in list: 
s+= substr 
print "total run time:" 
print time()-t 

同时要避免： 
s = "" 
for x in list: 
s += func(x) 

而是要使用： 
slist = [func(elt) for elt in somelist] 
s = "".join(slist) 

当对字符串可以使用正则表达式或者内置函数来处理的时候，选择内置函数。如 str.isalpha()，str.isdigit()，str.startswith((‘x‘, ‘yz‘))，str.endswith((‘x‘, ‘yz‘)) 
对字符进行格式化比直接串联读取要快，因此要使用 
out = "<html>%s%s%s%s</html>" % (head, prologue, query, tail) 

而避免 
out = "<html>" + head + prologue + query + tail + "</html>" 

使用列表解析（list comprehension）和生成器表达式（generator expression） 
列表解析要比在循环中重新构建一个新的 list 更为高效，因此我们可以利用这一特性来提高运行的效率。 
from time import time 
t = time() 
list = [‘a‘,‘b‘,‘is‘,‘python‘,‘jason‘,‘hello‘,‘hill‘,‘with‘,‘phone‘,‘test‘, 
‘dfdf‘,‘apple‘,‘pddf‘,‘ind‘,‘basic‘,‘none‘,‘baecr‘,‘var‘,‘bana‘,‘dd‘,‘wrd‘] 
total=[] 
for i in range (1000000): 
for w in list: 
total.append(w) 
print "total run time:" 
print time()-t 

使用列表解析： 
for i in range (1000000): 
a = [w for w in list] 

上述代码直接运行大概需要 17s，而改为使用列表解析后 ，运行时间缩短为 9.29s。将近提高了一半。生成器表达式则是在 2.4 中引入的新内容，语法和列表解析类似，但是在大数据量处理时，生成器表达式的优势较为明显，它并不创建一个列表，只是返回一个生成器，因此效率较高。在上述例子上中代码 a = [w for w in list] 修改为 a = (w for w in list)，运行时间进一步减少，缩短约为 2.98s。 

总结：字符串的连接操作，最好是先append到一个list，然后在用list的join操作。对字符串进行格式化比字符串相加操作要快。 

其他优化技巧 
如果需要交换两个变量的值使用 a,b=b,a 而不是借助中间变量 t=a;a=b;b=t； 
>>> from timeit import Timer 
>>> Timer("t=a;a=b;b=t","a=1;b=2").timeit() 
0.25154118749729365 
>>> Timer("a,b=b,a","a=1;b=2").timeit() 
0.17156677734181258 
>>> 

总结：交换两个变量：a, b = b, a。同样，对于三个变量进行交换：a, b, c = b, c, a， 
初始化时使用a, b = 1, 2 

在循环的时候使用 xrange 而不是 range；使用 xrange 可以节省大量的系统内存，因为 xrange() 在序列中每次调用只产生一个整数元素。而 range() 將直接返回完整的元素列表，用于循环时会有不必要的开销。在 python3 中 xrange 不再存在，里面 range 提供一个可以遍历任意长度的范围的 iterator。 

总结：python2中，使用xrange而不是range 

使用局部变量，避免"global" 关键字。python 访问局部变量会比全局变量要快得多，因 此可以利用这一特性提升性能。 
总结：python查找local变量的效率比查找global变量的效率高 

if done is not None 比语句 if done != None 更快，读者可以自行验证； 
if done is note None 

在耗时较多的循环中，可以把函数的调用改为内联的方式； 
使用级联比较 "x < y < z" 而不是 "x < y and y < z"； 

总结：使用x < y < z 而不是x < y and y < z 

while 1 要比 while True 更快（当然后者的可读性更好）； 
build in 函数通常较快，add(a,b) 要优于 a+b。 
总结：对函数做内联，或者使用内置函数。 

定位程序性能瓶颈 
对代码优化的前提是需要了解性能瓶颈在什么地方，程序运行的主要时间是消耗在哪里，对于比较复杂的代码可以借助一些工具来定位，python 内置了丰富的性能分析工具，如 profile,cProfile 与 hotshot 等。其中 Profiler 是 python 自带的一组程序，能够描述程序运行时候的性能，并提供各种统计帮助用户定位程序的性能瓶颈。Python 标准模块提供三种 profilers:cProfile,profile 以及 hotshot。 
profile 的使用非常简单，只需要在使用之前进行 import 即可。具体实例如下： 

清单 8. 使用 profile 进行性能分析 

import profile 
def profileTest(): 
Total =1; 
for i in range(10): 
Total=Total*(i+1) 
print Total 
return Total 
if __name__ == "__main__": 
profile.run("profileTest()") 

程序的运行结果如下： 

图 1. 性能分析结果 

其中输出每列的具体解释如下： 
ncalls：表示函数调用的次数； 
tottime：表示指定函数的总的运行时间，除掉函数中调用子函数的运行时间； 
percall：（第一个 percall）等于 tottime/ncalls； 
cumtime：表示该函数及其所有子函数的调用运行的时间，即函数开始调用到返回的时间；
percall：（第二个 percall）即函数运行一次的平均时间，等于 cumtime/ncalls； 
filename:lineno(function)：每个函数调用的具体信息； 
如果需要将输出以日志的形式保存，只需要在调用的时候加入另外一个参数。如 profile.run("profileTest()","testprof")。 
对于 profile 的剖析数据，如果以二进制文件的时候保存结果的时候，可以通过 pstats 模块进行文本报表分析，它支持多种形式的报表输出，是文本界面下一个较为实用的工具。使用非常简单： 
import pstats 
p = pstats.Stats(‘testprof‘) 
p.sort_stats("name").print_stats() 

其中 sort_stats() 方法能够对剖分数据进行排序， 可以接受多个排序字段，如 sort_stats(‘name‘, ‘file‘) 将首先按照函数名称进行排序，然后再按照文件名进行排序。常见的排序字段有 calls( 被调用的次数 )，time（函数内部运行时间），cumulative（运行的总时间）等。此外 pstats 也提供了命令行交互工具，执行 python – m pstats 后可以通过 help 了解更多使用方式。 
对于大型应用程序，如果能够将性能分析的结果以图形的方式呈现，将会非常实用和直观，常见的可视化工具有 Gprof2Dot，visualpytune，KCacheGrind 等，读者可以自行查阅相关官网，本文不做详细讨论。 
回页首 
Python 性能优化工具 
Python 性能优化除了改进算法，选用合适的数据结构之外，还有几种关键的技术，比如将关键 python 代码部分重写成 C 扩展模块，或者选用在性能上更为优化的解释器等，这些在本文中统称为优化工具。python 有很多自带的优化工具，如 Psyco，Pypy，Cython，Pyrex 等，这些优化工具各有千秋，本节选择几种进行介绍。 
Psyco 
psyco 是一个 just-in-time 的编译器，它能够在不改变源代码的情况下提高一定的性能，Psyco 将操作编译成有点优化的机器码，其操作分成三个不同的级别，有"运行时"、"编译时"和"虚拟时"变量。并根据需要提高和降低变量的级别。运行时变量只是常规 Python 解释器处理的原始字节码和对象结构。一旦 Psyco 将操作编译成机器码，那么编译时变量就会在机器寄存器和可直接访问的内存位置中表示。同时 python 能高速缓存已编译的机器码以备今后重用，这样能节省一点时间。但 Psyco 也有其缺点，其本身运行所占内存较大。目前 psyco 已经不在 python2.7 中支持，而且不再提供维护和更新了，对其感兴趣的可以参考 http://psyco.sourceforge.net/ 
Pypy 
PyPy 表示 "用 Python 实现的 Python"，但实际上它是使用一个称为 RPython 的 Python 子集实现的，能够将 Python 代码转成 C， .NET， Java 等语言和平台的代码。PyPy 集成了一种即时 (JIT) 编译器。和许多编译器，解释器不同，它不关心 Python 代码的词法分析和语法树。 因为它是用 Python 语言写的，所以它直接利用 Python 语言的 Code Object.。 Code Object 是 Python 字节码的表示，也就是说， PyPy 直接分析 Python 代码所对应的字节码 ,，这些字节码即不是以字符形式也不是以某种二进制格式保存在文件中， 而在 Python 运行环境中。目前版本是 1.8. 支持不同的平台安装，windows 上安装 Pypy 需要先下载 https://bitbucket.org/pypy/pypy/downloads/pypy-1.8-win32.zip，然后解压到相关的目录，并将解压后的路径添加到环境变量 path 中即可。在命令行运行 pypy，如果出现如下错误："没有找到 MSVCR100.dll, 因此这个应用程序未能启动，重新安装应用程序可能会修复此问题"，则还需要在微软的官网上下载 VS 2010 runtime libraries 解决该问题。具体地址为 http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=5555 
安装成功后在命令行里运行 pypy，输出结果如下： 
C:\Documents and Settings\Administrator>pypy 
Python 2.7.2 (0e28b379d8b3, Feb 09 2012, 18:31:47) 
[PyPy 1.8.0 with MSC v.1500 32 bit] on win32 
Type "help", "copyright", "credits" or "license" for more information. 
And now for something completely different: ``PyPy is vast, and contains 
multitudes‘‘ 
>>>> 

以清单 5 的循环为例子，使用 python 和 pypy 分别运行，得到的运行结果分别如下： 
C:\Documents and Settings\Administrator\ 桌面 \doc\python>pypy loop.py 
total run time: 
8.42199993134 

C:\Documents and Settings\Administrator\ 桌面 \doc\python>python loop.py 
total run time: 
106.391000032 

可见使用 pypy 来编译和运行程序，其效率大大的提高。 
Cython 
Cython 是用 python 实现的一种语言，可以用来写 python 扩展，用它写出来的库都可以通过 import 来载入，性能上比 python 的快。cython 里可以载入 python 扩展 ( 比如 import math)，也可以载入 c 的库的头文件 ( 比如 :cdef extern from "math.h")，另外也可以用它来写 python 代码。将关键部分重写成 C 扩展模块 
Linux Cpython 的安装： 
第一步：下载 
[root@v5254085f259 cpython]# wget -N http://cython.org/release/Cython-0.15.1.zip 
--2012-04-16 22:08:35-- http://cython.org/release/Cython-0.15.1.zip 
Resolving cython.org... 128.208.160.197 
Connecting to cython.org|128.208.160.197|:80... connected. 
HTTP request sent, awaiting response... 200 OK 
Length: 2200299 (2.1M) [application/zip] 
Saving to: `Cython-0.15.1.zip‘ 

100%[======================================>] 2,200,299 1.96M/s in 1.1s 

2012-04-16 22:08:37 (1.96 MB/s) - `Cython-0.15.1.zip‘ saved [2200299/2200299] 

第二步：解压 
[root@v5254085f259 cpython]# unzip -o Cython-0.15.1.zip 

第三步：安装 
python setup.py install 

安装完成后直接输入 cython，如果出现如下内容则表明安装成功。 
[root@v5254085f259 Cython-0.15.1]# cython 
Cython (http://cython.org) is a compiler for code written in the 
Cython language. Cython is based on Pyrex by Greg Ewing. 

Usage: cython [options] sourcefile.{pyx,py} ... 

Options: 
-V, --version Display version number of cython compiler 
-l, --create-listing Write error messages to a listing file 
-I, --include-dir <directory> Search for include files in named directory 
(multiple include directories are allowed). 
-o, --output-file <filename> Specify name of generated C file 
-t, --timestamps Only compile newer source files 
-f, --force Compile all source files (overrides implied -t) 
-q, --quiet Don‘t print module names in recursive mode 
-v, --verbose Be verbose, print file names on multiple compil ation 
-p, --embed-positions If specified, the positions in Cython files of each 
function definition is embedded in its docstring. 
--cleanup <level> 
Release interned objects on python exit, for memory debugging. 
Level indicates aggressiveness, default 0 releases nothing. 
-w, --working <directory> 
Sets the working directory for Cython (the directory modules are searched from) 
--gdb Output debug information for cygdb 
-D, --no-docstrings 
Strip docstrings from the compiled module. 
-a, --annotate 
Produce a colorized HTML version of the source. 
--line-directives 
Produce #line directives pointing to the .pyx source 
--cplus 
Output a C++ rather than C file. 
--embed[=<method_name>] 
Generate a main() function that embeds the Python interpreter. 
-2 Compile based on Python-2 syntax and code seman tics. 
-3 Compile based on Python-3 syntax and code seman tics. 
--fast-fail Abort the compilation on the first error 
--warning-error, -Werror Make all warnings into errors 
--warning-extra, -Wextra Enable extra warnings 
-X, --directive <name>=<value> 
[,<name=value,...] Overrides a compiler directive 

其他平台上的安装可以参考文档：http://docs.cython.org/src/quickstart/install.html 
Cython 代码与 python 不同，必须先编译，编译一般需要经过两个阶段，将 pyx 文件编译为 .c 文件，再将 .c 文件编译为 .so 文件。编译有多种方法： 
通过命令行编译： 
假设有如下测试代码，使用命令行编译为 .c 文件。 
def sum(int a,int b): 
print a+b 

[root@v5254085f259 test]# cython sum.pyx 
[root@v5254085f259 test]# ls 
total 76 
4 drwxr-xr-x 2 root root 4096 Apr 17 02:45 . 
4 drwxr-xr-x 4 root root 4096 Apr 16 22:20 .. 
4 -rw-r--r-- 1 root root 35 Apr 17 02:45 1 
60 -rw-r--r-- 1 root root 55169 Apr 17 02:45 sum.c 
4 -rw-r--r-- 1 root root 35 Apr 17 02:45 sum.pyx 

在 linux 上利用 gcc 编译为 .so 文件： 
[root@v5254085f259 test]# gcc -shared -pthread -fPIC -fwrapv -O2 
-Wall -fno-strict-aliasing -I/usr/include/python2.4 -o sum.so sum.c 
[root@v5254085f259 test]# ls 
total 96 
4 drwxr-xr-x 2 root root 4096 Apr 17 02:47 . 
4 drwxr-xr-x 4 root root 4096 Apr 16 22:20 .. 
4 -rw-r--r-- 1 root root 35 Apr 17 02:45 1 
60 -rw-r--r-- 1 root root 55169 Apr 17 02:45 sum.c 
4 -rw-r--r-- 1 root root 35 Apr 17 02:45 sum.pyx 
20 -rwxr-xr-x 1 root root 20307 Apr 17 02:47 sum.so 

使用 distutils 编译 
建立一个 setup.py 的脚本： 
from distutils.core import setup 
from distutils.extension import Extension 
from Cython.Distutils import build_ext 

ext_modules = [Extension("sum", ["sum.pyx"])] 

setup( 
name = ‘sum app‘, 
cmdclass = {‘build_ext‘: build_ext}, 
ext_modules = ext_modules 
) 


[root@v5254085f259 test]# python setup.py build_ext --inplace 
running build_ext 
cythoning sum.pyx to sum.c 
building ‘sum‘ extension 
gcc -pthread -fno-strict-aliasing -fPIC -g -O2 -DNDEBUG -g -fwrapv -O3 
-Wall -Wstrict-prototypes -fPIC -I/opt/ActivePython-2.7/include/python2.7 
-c sum.c -o build/temp.linux-x86_64-2.7/sum.o 
gcc -pthread -shared build/temp.linux-x86_64-2.7/sum.o 
-o /root/cpython/test/sum.so 

编译完成之后可以导入到 python 中使用： 
[root@v5254085f259 test]# python 
ActivePython 2.7.2.5 (ActiveState Software Inc.) based on 
Python 2.7.2 (default, Jun 24 2011, 11:24:26) 
[GCC 4.0.2 20051125 (Red Hat 4.0.2-8)] on linux2 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import pyximport; pyximport.install() 
>>> import sum 
>>> sum.sum(1,3) 

下面来进行一个简单的性能比较： 

清单 9. Cython 测试代码 

from time import time 
def test(int n): 
cdef int a =0 
cdef int i 
for i in xrange(n): 
a+= i 
return a 

t = time() 
test(10000000) 
print "total run time:" 
print time()-t 

测试结果： 
[GCC 4.0.2 20051125 (Red Hat 4.0.2-8)] on linux2 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import pyximport; pyximport.install() 
>>> import ctest 
total run time: 
0.00714015960693 


清单 10. Python 测试代码 

from time import time 
def test(n): 
a =0; 
for i in xrange(n): 
a+= i 
return a 

t = time() 
test(10000000) 
print "total run time:" 
print time()-t 

[root@v5254085f259 test]# python test.py 
total run time: 
0.971596002579 

从上述对比可以看到使用 Cython 的速度提高了将近 100 多倍。 
回页首 
总结 
本文初步探讨了 python 常见的性能优化技巧以及如何借助工具来定位和分析程序的性能瓶颈，并提供了相关可以进行性能优化的工具或语言，希望能够更相关人员一些参考。 

参考资料 
学习 
参考 Cython 官网，了解更多关于 Cython 的信息。 

参考 Pypy 官网，了解更多关于 pypy 的知识。 

查看文章"可爱的 Python: 用 Psyco 让 Python 运行得像 C 一样快"，了解如何使用 Psyco 提高效率。 

总结：在进行性能优化之前，要先使用性能分析工具（profile，cprofile，hotshot）对性能瓶颈做分析，找出代码中的热点再动手，对症下药。 

上述代码中大量用到time模块进行代码运行时间的计时，补充一下： 

from time import time 

Functions: 

time() -- return current time in seconds since the Epoch as a float, i.e. 1343446821.615205 
clock() -- return CPU time since process start as a float 
sleep() -- delay for a number of seconds given as a float, i.e. time.sleep(5)(这要能在现实中成真多好，最诱惑的方法） 
gmtime() -- convert seconds since Epoch to UTC tuple 
localtime() -- convert seconds since Epoch to local time tuple 
上述两个方法都返回tuple，i.e. time.struct_time(tm_year=2012, tm_mon=7, tm_mday=28, tm_hour=3, tm_min=42, tm_sec=22, tm_wday=5, tm_yday=210, tm_isdst=0) 

asctime() -- convert time tuple to string 
ctime() -- convert time in seconds to string 

上述两个方法都返回string表示的time，i.e. Sat Jul 28 11:43:15 2012 

mktime() -- convert local time tuple to seconds since Epoch 
maketime? i.e. time.mktime(time.localtime()) 

strftime() -- convert time tuple to string according to format specification 
time.strftime, string format time, i.e. time.strftime(‘%Y%m%d‘) <==> datetime.now().strftime 

strptime() -- parse string to time tuple according to format specification 
<==> datetime.datetime.strptime 

tzset() -- change the local timezone

gmtime和localtime()如果单纯返回tuple，那取值只能用index： 

lt = time.localtime() 
print lt[0] 

但想想写api的人不会这么笨，果然，lt.tm_year可用，可见是named tuple，但参数的名陈还是没有datetime.datetime好用 

python性能优化工具： 
Psyco，Pypy，Cython，Pyrex 

psyco(http://psyco.sourceforge.net) 
In short: run your existing Python software much faster, with no change in your source 
Think of Psyco as a kind of just-in-time (JIT) compiler, a little bit like what exists for other languages, that emit machine code on the fly instead of interpreting your Python program step by step. The difference with the traditional approach to JIT compilers is that Psyco writes several version of the same blocks (a block is a bit of a function), which are optimized by being specialized to some kinds of variables (a "kind" can mean a type, but it is more general). The result is that your unmodified Python programs run faster. 

Benefits 

2x to 100x speed-ups, typically 4x, with an unmodified Python interpreter and unmodified source code, just a dynamically loadable C extension module. 

Drawbacks 

Psyco currently uses a lot of memory. It only runs on Intel 386-compatible processors (under any OS) right now. There are some subtle semantic differences (i.e. bugs) with the way Python works; they should not be apparent in most programs. 

Psyco is unmaintained and dead. Please look at PyPy for the state-of-the-art in JIT compilers for Python. 

总结：Psyco是个JIT编译器，目标是在不改动python源代码的情况下提高代码运行的性能，通常性能提升在4倍（范围是2～100倍）。它的缺点是比较耗内存，现在已经不再维护。

这篇文章介绍psyco如何工作： 
http://www.ibm.com/developerworks/cn/linux/sdk/python/charm-28/

PyPy(http://pypy.org/) 
PyPy is a fast, compliant alternative implementation of the Python language (2.7.2). It has several advantages and distinct features: 
Speed: thanks to its Just-in-Time compiler, Python programs often run faster on PyPy. (What is a JIT compiler?) 
Memory usage: large, memory-hungry Python programs might end up taking less space than they do in CPython. 
Compatibility: PyPy is highly compatible with existing python code. It supports ctypes and can run popular python libraries like twisted and django. 
Sandboxing: PyPy provides the ability to run untrusted code in a fully secure way. 
Stackless: PyPy comes by default with support for stackless mode, providing micro-threads for massive concurrency. 

总结Pypy的特点： 
1. 使用python实现了对python代码的hack。其实，只使用了python中一个子集rPython。可将python代码编译为C，CIL，Javascript 等目标代码。 
2. 在pypy上运行的python代码速度会更快，比CPython快 
3. 作为Psyco的替代者，Pypy做到了动态编译 
4. 提供沙箱（运行速度会下降） 
5. 提供微线程，stackless 
6. 跟python代码兼容性很高 

Cython 
CPython is the default, most-widely used implementation of the Python programming language. It is written in C. In addition to CPython, there are two other production-quality Python implementations: Jython, written in Java, and IronPython, which is written for the Common Language Infrastructure. There are also several experimental implementations. 

CPython is a bytecode interpreter. It has a foreign function interface with several languages including C, in which one must explicitly write bindings in a language other than Python.