竞价单页网站制作/seo论坛站长交流

最近换住的地方，网费到期，有两个星期没更新博客了，博客还是要坚持写的，有时候工作时遇到了相关问题，查看相关博客，还是能够得到一些思路或者灵感。虽然写篇博客要话费不少时间(我一般要花一个半小时到两个小时之间)，但是这中间码字呀、归纳总结的过程还是让我受益匪浅的，温故而知新！当然分享自己的学习心得，也会让自己认识一些志同道合的朋友，也挺好。不说许多，今天讲讲如何提高Python性能的问题。

python的性能相对c语言等还是有一定的劣势，但是如果能掌握一些优化性能的技巧，不仅能够提高代码的运行效率，还能够使代码更加Pythonic。刚刚接触Python时，也在网上找了一些提高`python性能的博文看，还是另外受益匪浅，http://www.jb51.net/article/56699.htm

这篇博文还是写的不错的，可以参考。不过结合我自己最近看的书及书上的建议，做一个更细致的总结吧，不正之处欢迎批评指正，共同进步！

一、循环优化的基本技巧

循环的优化应遵循尽量减少循环过程中计算量的原则，多重循环的情况下尽量将内存的计算提到上一层。

(1)减少循环内部计算。先看下面例子#coding=utf-8

import datetime

import math

#第一种方法

def fun1(iter,x):

j = 0

for i in iter:

d = math.sqrt(x)

j += i * d

return j

#第二中方法

def fun2(iter,x):

j = 0

d = math.sqrt(x)

for i in iter:

j += i * d

return j

iter = range(1,1000)

t0 = datetime.datetime.now()

a = fun1(iter,9)

t1 = datetime.datetime.now()

b = fun2(iter,9)

t2 = datetime.datetime.now()

print a,"  ",b

print t1-t0,t2-t1

运行结果如下图：

第二种方法比一种速度快，因为第一种方法中，d = math.sqrt(x)在循环内部，每次循环过程中都会重复计算一次，增加了系统开销，这里的d = math.sqrt(x)还是个比较简单的计算，如果遇到自己定义的复杂的、计算量大的那么第一种方法真的就不太好了。一般情况下，第二种方法比第一种方法运算效率高40%-60%。

(2)将显示循环改为隐式循环。比如说，在求等差数列的和时，可以直接通过循环来计算，这个很简单，如下：#coding=utf-8

def SUM(n):

sum = 0

for i in xrange(n+1):

sum +=i

这么写是没问题的，但是等差数列有现成的求和公式呀，即n*(n+1)/2，没必要要再用循环了，所以说如果程序中有类似的情况，可以直接将显示循环改为隐式。

(3)在循环中尽量引用局部变量。根据"LEGB"原则(不了解的可以参考之前的博文，地址：http://11026142.blog.51cto.com/11016142/1840128  )，在命名空间局部变量优先搜索，因此局部变量查询会比全局变量更快。在循环中，如果多次引用某一变量，要尽量将其转化为局部变量，看下面例子#coding=utf-8

import datetime

import math

x = [10,20,30,40,50,60,70,80,90]

#第一种方法

def fun1(x):

for i in xrange(len(x)):

x[i] = math.sin(x[i])

return x

#第二中方法

def fun2(x):

loc_sin = math.sin

for i in xrange(len(x)):

x[i] = loc_sin(x[i])

return x

t0 = datetime.datetime.now()

a = fun1(x)

t1 = datetime.datetime.now()

b = fun2(x)

t2 = datetime.datetime.now()

print a

print b

print t1-t0,t2-t1

运行结果如下：

可以看到方法二快于方法一，我觉得这种方法，在平时应用某个库(包括标准库和自定义库，模块)的函数时，可以这样用，比较程序搜索这个库的函数也是需要时间，如果用第一种方法，那就是循环搜索了，那肯定会划分更多的时间，这个技巧我觉得值得大家去学习、借鉴。

(4)对于嵌套循环，尽量将内层循环计算往上层移。看下面例子#coding=utf-8

import datetime

#第一种方法

def fun1(iter1,iter2):

max1 = 0

for i in range(len(iter1)):

for j in range(len(iter2)):

x = iter1[i] + iter2[j]

max1 = x if x > max1 else max1

return max1

#第二中方法

def fun2(iter1,iter2):

max1 = 0

for i in range(len(iter1)):

temp = iter1[i]

for j in range(len(iter2)):

x = temp + iter2[j]

max1 = x if x > max1 else max1

return max1

l1 = [1,23,4,5,34,8,10,18,42,10,6,88]

l2 = [100,102,34,15,16,56]

t0 = datetime.datetime.now()

a = fun1(l1,l2)

t1 = datetime.datetime.now()

b = fun2(l1,l2)

t2 = datetime.datetime.now()

print a

print b

print t1-t0,t2-t1

运行结果如下：

可见方法二的速度要快些，嵌套for循环的运行机制是i=0(以上面例子为例)，然后j从0增到最大值，然后i自增1，j又从0增大到最大值，依次类推。所以在内层循环的上一层加个临时变量，内层使用是就不用重新计算。这里要说明一下，对于列表它的索引，切片等操作也是一种计算/运算，也是要花费时间的。

二、使用不同的数据结构优化性能

最常用的数据结构是list，它的内存管理类似于c++的vector，即先预分配一定数量的内存，当预分配的内存用完了但是不够用，又要继续往里插入元素，就会启动新一轮内存分配，list对象就会根据内存增长算法重新申请一块更大的内存空间，然后将原有的所有元素拷贝过去，销毁之前的内存，然后插入新元素，如果还不够用，继续重复上面的步骤。删除元素也是这样，如果发现已用空间比预分配内存空间的一半还少，list会申请一块小内存，再做一次拷贝，然后销毁大内存(如果想了解这部分知识，我推荐大家看看《Python源码剖析》这本书，这本书我也是一个月前开始看，目前还没看完，我觉得这本书写的很好，很值得读两三篇甚至四五篇，第一章与第二章内容要认真读，否则后面的东西越看越糊涂(大神除外))。

可见，如果list对象经常有元素数量的巨大变化，而且比较频繁，这个时候应该考虑使用deque。如果不了解deque，可以参考我前面的博文http://11026142.blog.51cto.com/11016142/1851791

deque是双端队列，同时具备栈和队列的特性。能够提供复杂度为O(1)的两端插入和删除操作。相对于list，它最大的优势在于内存管理。它申请的内存不够用时，不会像list那样，而是申请新的内存来容纳新的元素，然后将新元素与旧元素连接起来，避免了元素的拷贝。所以，但出现元素数量频繁出现巨大变化时，deque的性能是list的好几倍。

array，中文名是数组，是一种序列数据结构，看起来和list很相似，但是所有成员必须是相同基本类型。array实例化时需要指明其存储元素类型。如"c"，表示存储一个想当然c语言里的char类型，占用内存大小1字节。这就从另一个角度来说明，它可以优化代码的内存空间。看下面例子#coding=utf-8

import sys

import array

a = array.array("c","hello,world")

c = list("hello,world")

print sys.getsizeof(a),sys.getsizeof(c)

运行结果如下：

明显,list对象更耗内存。这就会影响到一些其它操作的性能提升，比如将容器对象转换为字符串，在这一点上array性能高于list。看下面例子#coding=utf-8

import array

import datetime

a = array.array("c","hello,world")

c = list("hello,world")

t0 = datetime.datetime.now()

s1 = "".join(c)

t1= datetime.datetime.now()

s2 = "".join(a)

t2 = datetime.datetime.now()

print t1 - t0,t2 - t1

运行结果如下：

也并不是所以的array性能提升比较大，比如排序，array性能不如list，看下例：#coding=utf-8

import array

import datetime

a = array.array("c","hello,world")

c = list("hello,world")

t0 = datetime.datetime.now()

c.reverse()

t1= datetime.datetime.now()

a.reverse()

t2 = datetime.datetime.now()

print t1 - t0,t2 - t1

结果如下：

(三)利用好set的优势

set是集合，python中集合是通过Hash算法实现的无序不重复元素集，创建集合是通过set()来实现的。看下图：

set对象也支持添加元素，但它的性能是list添加元素性能的好几倍，这个不在此过多叙述，有时间专门写篇关于python集合的博文。

set在求交集、并集、差集等与集合有关的操作，性能要逼list快，因此涉及到list的交集、并集、差集等运算，可以将list转换为set

四、使用生成器提高效率

生成器是Python中的一个高级用法，概念非常简单，如果一个函数中有yield语句，则称为生成器(generator)，它是一种特殊的迭代器(iterator)，也可以称为可迭代对象(iterable)。这三者关系如下图：

如果你熟悉/了解Python的对象协议的话，最上面的那个是容器类协议，第二个是迭代器协议，如果你对这些不太熟悉，我觉得有必要找本经典教材来看看，我看的是《Python学习手册》，这本书还不错，介绍的比较详细，对于比较熟的内容，可以跳过。

调用生成器函数会返回一个迭代器对象，只是这个迭代器对象是以生成器对象的形式出现的。看下面例子：#coding=utf-8

def fun(n):

a,b = 1,1

while a 

yield a

a,b = b,a + b

f = fun(10)

print type(f)

print dir(f)

输出结果如下：

["__class__", "__delattr__", "__doc__", "__format__", "__getattribute__", "__hash__", "__init__", "__iter__", "__name__", "__new__", "__reduce__", "__reduce_ex__", "__repr__", "__setattr__", "__sizeof__", "__str__", "__subclasshook__", "close", "gi_code", "gi_frame", "gi_running", "next", "send", "throw"]

可以看到它返回的是一个generator类型对象，而这个对象有__iter__()和__next__()方法，熟悉迭代器协议的都知道，迭代器协议就是要实现__iter__()和__next__()方法，可见它也是一个迭代器对象。

生成器为什么能够提高运行效率？

这是因为每一个生成器函数在调用之后，它的函数体并不执行，而是第一次调用next()的时候才会执行，仅在需要的时候产生对应的元素，而不是一次性生成所有的元素，从而节省了空间内存，提高了效率，理论上来讲，无限循环成为可能不会导致内存不够用的情况，这个在读数据处理的时候尤为重要。所以在循环过程中依次处理一个元素的时候，用生成器是最好的。

五、使用多进程

由于GIT的存在，是的Python中的多线程无法充分利用多核优势来提高运行效率，但是python提供了另外一个解决方案，多进程。 可以使用multiprocessing的Process,Pool等封装好的类，通过多进程的方式实现并行计算。由于篇幅有限，在此不过多介绍。

另外还有一些其它的方法，比如推到式啊，借助一些其它的开发工具呀等等，这也是一个很值得去花时间去了解的知识，由于篇幅有限，无法详细叙述，后面我会慢慢尝试使用PyPy，Cython以及一些分析工具，然后将我的学习经验与大家分享。这些都是一些技巧，平时写代码的时候就要注意考虑进这些东西，多实践多总结，相信你会越来越优秀！