算法的时间复杂度对程序的执行效率影响最大，在Python中可以通过选择合适的数据结构来优化时间复杂度，如list和set查找某一个元素的时间复杂度分别是O(n)和O(1)。不同的场景有不同的优化方式，总得来说，一般有分治，分支界限，贪心，动态规划等思想。
如用上三角或下三角的方式去保存一个大的对称矩阵。在0元素占大多数的矩阵里使用稀疏矩阵表示。
对于dict和list等数据结构的对象，直接赋值使用的是引用的方式。而有些情况下需要复制整个对象，这时可以使用copy包里的copy和deepcopy，这两个函数的不同之处在于后者是递归复制的。效率也不一样：（以下程序在ipython中运行）
import copy
a = range(100000)
%timeit -n 10 copy.copy(a)
timeit后面的-n表示运行的次数，后两行对应的是两个timeit的输出，下同。由此可见后者慢一个数量级。
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的效率略高(占用的空间也多一些)。
%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
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 = 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效率略高，而且可读性更好。
def while_1():
n = 100000
if n &= 0: break
def while_true():
n = 100000
while True:
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是一个全局变量，而非关键字。
%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倍以上！
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多倍。
目前主要有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是用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&是要运行程序的文件名，可以在标准输出中看到每一个函数被调用的次数和运行的时间，从而找到程序的性能瓶颈，然后可以有针对性地优化。
=========================
/python//python-performance-tips/
原文地址：
Python是一门优秀的语言，它能让你在短时间内通过极少量代码就能完成许多操作。不仅如此，它还轻松支持多任务处理，比如多进程。
不喜欢Python的人经常会吐嘈Python运行太慢。但是，事实并非如此。尝试以下六个窍门，来为你的Python应用提速。
窍门一：关键代码使用外部功能包
Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。以下是一些你可以选择用来提升效率的功能包：
这些功能包的用处各有不同。比如说，使用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))
#Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(1))
#Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(2))
#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版本，然后你需要在做出关键性的改动时检查自己的应用。只有当你完成必要的修正之后，你才能体会新版本的不同。
然而，如果你只是确保自己的应用在新版本中可以运行，你很可能会错过新版本提供的新特性。一旦你决定更新，请分析你的应用在新版本下的表现，并检查可能出问题的部分，然后优先针对这些部分应用新版本的特性。只有这样，用户才能在更新之初就觉察到应用性能的改观。
窍门五：尝试多种编码方法
每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。可以在程序分析时尝试一些试验性的办法。譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。请看下面第一段代码：
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填满了数据，至少填有大部分数据，这时换另一种方法会更有效率。
myDict = {}
for i in range(0, n):
char = 'abcd'[i%4]
myDict[char] += 1
except KeyError:
myDict[char] = 1
print(myDict)
在两种方法中输出结果都是一样的。区别在于输出是如何获得的。跳出常规的思维模式，创建新的编程技巧能使你的应用更有效率。
窍门六：交叉编译你的应用
开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。计算机理解的是机器语言。为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。
是一款有趣的交叉编译器，能将你的Python代码转化成C++代码。这样，你就可以在native模式下执行自己的应用，而无需依赖于解释器程序。你会发现自己的应用运行效率有了较大的提高，但是这会因平台和任务的差异而有所不同。
（注意：Nuitka现在还处在测试阶段，所以在实际应用中请多加注意。实际上，当下最好还是把它用于实验。此外，关于交叉编译是否为提高运行效率的最佳方法还存在讨论的空间。开发者已经使用交叉编译多年，用来提高应用的速度。记住，每一种解决办法都有利有弊，在把它用于生产环境之前请仔细权衡。）
在使用交叉编译器时，记得确保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。为了让解决方案生效，你需要一个Python解释器和一个C++编译器。Nuitka支持许多C++编译器，其中包括,&和&。
交叉编译可能造成一些严重问题。比如，在使用Nuitka时，你会发现即便是一个小程序也会消耗巨大的驱动空间。因为Nuitka借助一系列的动态链接库（DDLs）来执行Python的功能。因此，如果你用的是一个资源很有限的系统，这种方法或许不太可行。
前文所述的六个窍门都能帮助你创建运行更有效率的Python应用。但是银弹是不存在的。上述的这些窍门不一定每次都能奏效。在特定的Python的版本下，有的窍门或许比其他的表现更好，但这有时候甚至取决于平台的差异。你需要总结分析你的应用，找到它效率低下的部分，然后尝试这些窍门，找到解决问题的最佳方法。
阅读(...) 评论()Python几种语句执行效率问题
一个功能的实现，可以用多种语句来实现，比如说:while语句、for语句、生成器、列表推导、内置函数等实现，然而他们的效率并不一样。写了一个小程序来测试它们执行的效率。
将一个数字大小为20万的数字，依次取绝对值，放到列表中，测试重复1千次.
测试程序:import time,sys
reps = 1000
#测试重复次数
nums = 200000
#测试时数字大小
def tester(func,*args):
#总体测试函数
startTime = time.time()
for i in range(reps):
func(*args)
elapsed = time.time() - startTime #用time模块来测试，结束时间与开始时间差
return elapsed
def while_Statement():
#while循环实现
while nums > x:
res.append(abs(x))
def for_Statement():
#for循环实现
for x in range(nums):
res.append(abs(x))
def generator_Expression():#生成器实现
res = list(abs(x) for x in range(nums))
def list_Comprehension():
#列表解析实现
res = [abs(x) for x in range(nums)]
def map_Function():
#内置函数map实现
res = map(abs, range(nums))
print sys.version
tests = [while_Statement, for_Statement, generator_Expression, list_Comprehension, map_Function]
for testfunc in tests:
#将待测函数放置列表中依次遍历
print testfunc.__name__.ljust(20),': ',tester(testfunc)
2.7.4 (default, Apr
6 :15) [MSC v.1500 64 bit (AMD64)]
while_Statement
for_Statement
generator_Expression :
list_Comprehension
map_Function
import sys
nums = 100
def while_Statement():
while nums > x:
res.append(abs(x))
def for_Statement():
for x in range(nums):
res.append(abs(x))
def generator_Expression():
res = list(abs(x) for x in range(nums))
def list_Comprehension():
res = [abs(x) for x in range(nums)]
def map_Function():
res = map(abs, range(nums))
if __name__=='__main__':
import timeit
#用timeit模块来测试
print sys.version
funcs = [while_Statement, for_Statement, generator_Expression, list_Comprehension, map_Function]
for func in funcs:
print func.__name__.ljust(20),': ',timeit.timeit("func()", setup="from __main__ import func")
2.7.4 (default, Apr
6 :15) [MSC v.1500 64 bit (AMD64)]
while_Statement
for_Statement
generator_Expression :
list_Comprehension
map_Function
12.测试分析:
用time模块，和timeit模块两种测试方式测试了很多组数字，得出的结果是执行内置函数最快，其次就是列表推导，再其次生成器和for循环，while循环最慢。一般最快的使用内置函数的方法要比使用最慢的while快一倍左右。所以函数式最好使用内置函数，然后才考虑使用列表推导或for循环。最好不用while循环.玩蛇网提供最新Python编程技术信息以及Python资源下载！
您现在的位置：
Python文件存储服务器IOError: [Errno 32] Broken pipe错误
# -*- coding: utf-8 -*-
#!/usr/bin/python26
from SimpleHTTPServer import SimpleHTTPRequestHandler
from BaseHTTPServer import BaseHTTPRequestHandler
from BaseHTTPServer import HTTPServer
import SocketServer
import cgi
import logging
import thread
class MyHTTPRequestHandler( BaseHTTPRequestHandler ):
def do_GET( self ):
def do_POST(self):
# 创建线程执行命令
thread.start_new_thread(self.callscript, ('cd /home/www/man-sphinx//html && /usr/bin/sphinx-build -c ./
/home/www/html//html/',))
form = cgi.FieldStorage(
# cgi.FieldStorage实例效果类似一个字典，包含键－值和len等内置函数
fp=self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD':'POST',
'CONTENT_TYPE':self.headers['Content-Type'],
self.send_response(200)
self.end_headers()
self.wfile.write('Client: %s\n' % str(self.client_address))
# self.wfile.write('User-agent: %s\n' % str(self.headers['user-agent']))
# self.wfile.write('Path: %s\n' % self.path)
params = {}
for field in form.keys():
params[field] = form[field].value
filepath = params.get('f')
data = params.get('d')
code = params.get('c')
user = params.get('u')
result = self.filesave(filepath, data, code, user)
except Exception, e:
result = 'Error in filesave:%s' % e
self.wfile.write(result)
# self.callscript('cd /home/www/man-sphinx//html && /usr/bin/sphinx-build -c ./
/home/www/html//html/')
def filesave(self, filepath, data, code, user):
if (filepath and data and code and user) is None:
return 'Params uncomplete!\n'
path = '/'.join(filepath.split('/')[:-1])
name = filepath.split('/')[-1]
if not os.path.exists(path):
os.makedirs(path)
f = open(filepath, 'w')
f.write(data.decode(code).encode('utf-8'))
self.log(filepath, user)
return 'Filesaved in %s' % filepath
def callscript(self, command):
os.popen(command)
except Exception,e:
print 'Error in CallScript:%s' % e
def log(self, filepath, user):
def do_HEAD( self ):
if __name__ == '__main__':
port = 28080
handler = SimpleHTTPRequestHandler
#httpd = SocketServer.TCPServer((&&, port ), handler )
httpd = HTTPServer(('', port ), MyHTTPRequestHandler)
print &Server is running at port&, port
httpd.serve_forever()
这是一个简单的文件存储服务器，文件存储工作正常，但是我希望接受post请求的时候开启一个线程去刷新文件目录，问题是在callscript函数里使用os.popen()会报题示的错误，如果改成os.system()就不会. 详细错误：
# Sphinx version: 1.1.3
# Python version: 2.6.5
# Docutils version: 0.11 release
# Jinja2 version: 2.7.1
Traceback (most recent call last):
File &/usr/lib/python2.6/site-packages/Sphinx-1.1.3-py2.6.egg/sphinx/cmdline.py&, line 188, in main
warningiserror, tags)
File &/usr/lib/python2.6/site-packages/Sphinx-1.1.3-py2.6.egg/sphinx/application.py&, line 94, in __init__
(bold('Running Sphinx v%s' % sphinx.__version__))
File &/usr/lib/python2.6/site-packages/Sphinx-1.1.3-py2.6.egg/sphinx/application.py&, line 238, in info
self._status.flush()
IOError: [Errno 32] Broken pipe
这是为什么呢？
玩蛇网文章，转载请注明出处和文章网址：/wenda/wd20048.html []
我要小额赞助，鼓励作者写出更好的教程↓↓↓】
玩蛇网Python QQ群，欢迎加入： ①
修订日期：日 - 16时49分09秒
发布自玩蛇网
我要分享到：
评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）
必知PYTHON教程
Must Know PYTHON Tutorials
必知PYTHON模块
Must Know PYTHON Modules
最新内容 NEWS
图文精华 RECOMMEND
热点文章 HOT
Navigation
玩蛇网Python之家，简称玩蛇网，是一个致力于推广python编程技术、程序源码资源的个人网站。站长 斯巴达 是一位 长期关注 软件、互联网、服务器与各种开发技术的Python爱好者，建立本站旨在与更多朋友分享派森编程的乐趣！
本站团队成员： 斯巴达
欢迎加入团队...}