Python性能优化的20条建议
投稿：mdxy-dxy
字体：[ ] 类型：转载 时间：
不论什么语言我们都需要注意性能优化问题，提高执行效率，这里就为大家分享下Python的性能优化技巧,需要的朋友可以参考下
优化算法时间复杂度
算法的时间复杂度对程序的执行效率影响最大，在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
%timeit -n
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:
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:
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
....: c=a;a=b;b=c;
10000 loops, best of 3: 172 ns per loop
In [4]: %%timeit -n 10000
10000 loops, best of 3: 86 ns per loop
使用a,b=b,a而不是c=a;a=b;b=c;来交换a,b的值，可以快1倍以上。
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
if n &= 0: break
def while_true():
n = 100000
while True:
if n &= 0: break
m, n = 00000
%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 是要运行程序的文件名，可以在标准输出中看到每一个函数被调用的次数和运行的时间，从而找到程序的性能瓶颈，然后可以有针对性地优化。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具您所在的位置： &
探究Python性能为什么如此的强大
探究Python性能为什么如此的强大
Python性能一直都是十分的强大，不少的用户都在使用。下面我们就详细的看看Python性能为什么如此的强大，希望大家有所收获。
Python性能十分的强大，相关的技术为什么会如此的强大呢？下面我们就详细的看看相关技术问题。问题的提出是源于 这位兄弟的BLOG，在他的这个实现中，Python性能具有相当不错的性能，不但优于帖子中的C实现性能，也优于随后的跟贴中众多的C++实现的性能。
在经过了多次尝试，我还是很难找出一个优于性能的实现。这不是一件正常的事情，Python性能注定不会优于C/C++，这是因为Python是解释执行的，解释的过程必然会消耗CPU时间，所以我查阅了Python的源码试图找出为何Python性能对于这个任务有如此好的性能的原因。
任务描述如下
对于一个78W行的文本文件，每一行是一个Email地址，文件中存在有重复的行，任务的要求是尽可能快的从这个文本文件生成一个无重复的Email的文本文件
有如下的问题需要注意
对于这种大量的字符串比较，直接使用字符串比较函数是严重妨碍性能的IO性能是要注意的尽可能的少使用占用内存在我的尝试中，发现重复调用ofstream::operator&& 是比较影响性能的，而使用 fprintf或使用copy 等 STL 算法输出到则性能好的多。使用一种好的Hash算法是影响程序性能的关键。任务中的EMail字符串总是具有[a-z]*[0-9]*@([a-z]*\.)+[a-z]* 的形式，例如 .cn .cn 的格式。
在$PySrc/Objects/dictobject.c 中，对Python的Hash机制作了一些描述，总的来说，Python的Hash机制对于这种连续型的字符串有相当好的离散度，对于这个 78W 例子，python_hash() % 780000能够很均匀的分散到各个值，最大的冲突数为 8。 以下是按照类似 Python的 Hash算法实现的 C++ 版本的结果
E:\Workspace\Temp\Emailmy& &经过了毫秒& &E:\Workspace\Temp\Emailmy& &经过了毫秒& &E:\Workspace\Temp\Emailmy& &经过了毫秒& &E:\Workspace\Temp\Emailmy& &经过了毫秒& &E:\Workspace\Temp\Emailpy_email.py& &2.& &E:\Workspace\Temp\Emailpy_email.py& &2.& &E:\Workspace\Temp\Emailpy_email.py& &2.& &E:\Workspace\Temp\Emaildir&*.txt& &&13:09&19,388,869&email.txt& &&22:51&17,779,266&email_new.txt&(py_email.py&写出)& &&22:50&17,779,266&email_new_my.txt&(my.exe&写出)&&
以上就是对Python性能的详细介绍。
【责任编辑： TEL：（010）】
关于的更多文章
Python是一种即译式的，互动的，面向对象的编程语言，它包含了模
随着云计算、物联网、大数据、移动互联网的大发展，你应该知道这些。
讲师： 26人学习过讲师： 14人学习过讲师： 34人学习过
自从MySQL被Oracle收购以后，PostgreSQL逐渐成为开源
1314的的日子在，在忙忙碌碌中过去了。一周五天，中间
本期开发频道重点推荐是2013年开发频道重点推荐的最后
本书详细描述如何在复杂技术项目中使用Scrum，并结合真实的Scrum案例及专家洞识，在简明及高度概括的理论之上更侧重于实践，并不
51CTO旗下网站微信号：callme_hr
扫码加一览职业生涯导师微信好友
深圳市一览网络股份有限公司（股票代码：833680）
版权所有 &python异常处理对性能影响怎么样？ - Python - language - ITeye论坛
python异常处理对性能影响怎么样？
锁定老帖子
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
jeffreydan
来自: 北京
发表时间：&&
最后修改：
相关知识库：
一、糟糕的代码
在使用python编程语言处理查找列表或字典中的某个数据项时，我经常看到这样的代码(省略具体逻辑)：
data_list = find("condition")[0]
dict_list = find("condition")["key"]
以上这些代码虽然能够满足程序的功能，但这都不是最佳的实现方式，原因如下：
1、try捕获异常会造成异常(软中断)，会影响性能。
2、作为靠谱的程序员，应该采取防御性的方式编码，而不应该将错误的处理都丢给系统。
二、糟糕的代码执行时间上的PK
基于上述原因，我与编码者(上述代码作者)交流过，其中的回答“python对异常的处理方式非常好，从而几乎不影响性能，这也是推荐的一种处理方式”让我好奇，于是做了个小实验---python异常处理对性能的有多大的影响？源代码如下：
#! /bin/usr/env python
# -*- coding:utf-8 -*-
import time
#统计方法执行的时间
def count_time(func):
def wrap(*args):
start = time.time()
func(*args)
end = time.time()
print "func:%s
time:(%0.3f ms)" % (func.func_name, (end-start) * 1000)
return wrap
#key不存在的时候
@count_time
def not_exists_use_try(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
dict_list["not_exists"]
#key存在的时候
@count_time
def exists_use_try(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
dict_list["do_something"]
#key不存在的时候并使用Exception
@count_time
def not_exists_use_try_except(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
dict_list["not_exists"]
except Exception, e:
#key存在的时候并使用Exception
@count_time
def exists_use_try_except(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
dict_list["do_something"]
except Exception, e:
#使用防御性编码
@count_time
def not_use_try(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
if "not_exists" in dict_list :
def run(max):
print "max:%s" % max
not_exists_use_try(max)
not_exists_use_try_except(max)
exists_use_try(max)
exists_use_try_except(max)
not_use_try(max)
if __name__ == "__main__":
run(10000)
run(100000)
#1,000,000
run(1000000)
#10,000,000
通过对上面的实验程序的3次运行，采样结果如下：
func:not_exists_use_try
time:(0.110 ms)
func:not_exists_use_try_except
time:(0.110 ms)
func:exists_use_try
time:(0.012 ms)
func:exists_use_try_except
time:(0.011 ms)
func:not_use_try
time:(0.009 ms)
func:not_exists_use_try
time:(0.941 ms)
func:not_exists_use_try_except
time:(1.058 ms)
func:exists_use_try
time:(0.091 ms)
func:exists_use_try_except
time:(0.091 ms)
func:not_use_try
time:(0.063 ms)
max:10,000
func:not_exists_use_try
time:(10.341 ms)
func:not_exists_use_try_except
time:(10.869 ms)
func:exists_use_try
time:(0.879 ms)
func:exists_use_try_except
time:(0.904 ms)
func:not_use_try
time:(0.616 ms)
max:100,000
func:not_exists_use_try
time:(95.245 ms)
func:not_exists_use_try_except
time:(109.051 ms)
func:exists_use_try
time:(9.277 ms)
func:exists_use_try_except
time:(9.290 ms)
func:not_use_try
time:(7.086 ms)
max:1,000,000
func:not_exists_use_try
time:(932.254 ms)
func:not_exists_use_try_except
time:( ms)
func:exists_use_try
time:(110.238 ms)
func:exists_use_try_except
time:(104.085 ms)
func:not_use_try
time:(85.284 ms)
max:10,000,000
func:not_exists_use_try
time:( ms)
func:not_exists_use_try_except
time:( ms)
func:exists_use_try
time:( ms)
func:exists_use_try_except
time:( ms)
func:not_use_try
time:(812.829 ms)
观察上面的采样结果得知：
一、程序执行时间随着执行的次数同比递增增长。
二、其中使用try...except,Exception的方式会比使用try...except的方式稍花时间，但这点时间可以忽略不计。
三、其中当使用try方式时发生异常比使用try方式时无异常花费时间约10倍。
四、使用防御性方式编码在这几种方式中最花费时间最少。
以上数据会根据程序执行环境的不同而得出不同的采样结果，从上面的采样数据结果来看，执行次数在10,000,000级别时候才有明显的延时，抛开性能影
响的层面，作为靠谱的程序员，应该采取防御性的方式编码，而不应该将错误的处理都丢给系统，这样的好处明显就是性能的提升，同时也加强了程序的可读性。
来自: 北京
发表时间：&&
你的测试不公平，你应当至少还加上一种测试情况：
@count_time
def exists_not_use_try(max):
dict_list = {"do_something":"...."}
for item in range(0, max):
if "do_something" in dict_list :
dict_list["do_something"]
这里做了两次判断，在我的机器上，它比exists_use_try和exists_use_try_except都慢。
从性能上来说，如果key存在的情况是大多数情况，用try except可能速度更快。
其实速度根本相差无几，可读性才重要。在python中，另一种方法是使用get。我也同意你的观点，应当使用防御性编程，可能是因为我之前是写java的，在java中创建异常会同时创建stacktrace，这是很耗时的操作，在python中异常是不带stacktrace(在python中叫做traceback)的，所以创建异常的开销比java中小很多。
请登录后投票
跳转论坛:移动开发技术
Web前端技术
Java企业应用
编程语言技术python（1）
python越来越作为一种科学技术研究的语言越来越流行，可是我们经常听到一个问题，python是慢的。那么我们从后台分析一下，为什么python是慢的。
python是一种动态类型，解释型语言，它的值都是存储在分散的对象中，而不是紧密的缓存之中。
1.python是动态类型语言
这意味着编译器在程序执行之前并不知道变量定义的类型。C定义变量和Python定义变量的方式的区别：
对于C，编译器通过定义知道变量的类型；然而对于python中的变量，当你知道变量的类型的时候已经是程序执行的时候了。
我们分析一小段代码分别在python和C中执行的具体区别：
在C中，如果你写如下代码：
int a = 1;
int b = 2;
int c = a +
1.分配一个类型1给a
2.分配一个类型2给b
3.调用一个二进制加法
1.分配1给a
设置一个对象，然后将它的类型设置为整数
将它的值设为1
2.分配2给b
设置一个对象，然后将它的类型设置为整数
将它的值设为2
3.调用一个二进制加法(a,b)
寻找一个类型在对象中
a是一个整数，它的值是a
寻找一个类型在对象中
b是一个整数，它的值是b
调用一个二进制加法
返回结果，结果是一个整数
4.产生一个对象c
将一个对象的类型设置为整数
将它的值分配给结果
动态类型意味着每一步操作需要更多的步骤。python比c慢的一个基本的原因就是数字计算上面的操作。
2.python是一种解释型的语言而不是编译型的
我们可以看到解释型语言和编译型语言的区别。一个聪明的编译器知道怎么提前优化，避免重复和不必要的操作，从而提高效率。当然，在这一点上也是仁者见仁智者见智。
3.python的对象模型导致存储效率低下
python存储数据效率低下的原因，主要可以从下图看出：
当然说了python这么多缺点，为什么python用的人还这么多，因为它很简单啊。python用起来的确很简单，就我个人的使用感受而言，除了matlab，我没有看过比python还要简单的语言了。而且python的开源的库很多，所以做很多东西都很方便。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：42518次
积分：1261
积分：1261
排名：千里之外
原创：65篇
译文：13篇
评论：16条
(1)(1)(1)(4)(2)(1)(4)(1)(4)(3)(1)(5)(5)(21)(2)(3)(4)(24)