1、优化循环

循环之外能做的事不要放在循环内，比如下面的优化可以快一倍

2、使用join合并迭代器中的字符串

join对于累加的方式，有大约5倍的提升

3、使用if is

使用if is True比if == True将近快一倍

4、使用级联比较x < y < z

x < y < z效率略高，而且可读性更好

5、使用**而不是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倍以上！

6、优化包含多个判断表达式的顺序

对于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

7、使用dict或set查找元素

python dict和set都是使用hash表来实现，查找元素的时间复杂度是O(1)

8、合理使用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

9、使用列表解析和生成器表达式

表解析要比在循环中重新构建一个新的 list 更为高效，因此我们可以利用这一特性来提高运行的效率。

 1 from time import time  
 2  t = time()  
 3  list = [‘a‘,‘b‘,‘is‘,‘python‘,‘jason‘,‘hello‘,‘hill‘,‘with‘,‘phone‘,‘test‘,  
 4  ‘dfdf‘,‘apple‘,‘pddf‘,‘ind‘,‘basic‘,‘none‘,‘baecr‘,‘var‘,‘bana‘,‘dd‘,‘wrd‘]  
 5  total=[]  
 6  for i in range (1000000):  
 7  for w in list:  
 8  total.append(w)  
 9  print "total run time:" 
10  print time()-t 

使用列表解析：

1. for i in range (1000000):  
2. 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。

10、使用xrange代替range

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

11、使用局部变量

使用局部变量，避免”global” 关键字。python 访问局部变量会比全局变量要快得多，因 此可以利用这一特性提升性能

12、使用is not

if done is not None 比语句 if done != None 更快

13、while 1要比while Trule更快

很多Python优化的文章，都会谈及这个。那么，到底能提高多少呢？我们来试试看

 1 import random
 2 import time
 3 
 4 start_time = time.time()  
 5 print start_time  
 6   
 7 j = 1  
 8 while True:  
 9     j += 1  
10     end_time = time.time()  
11     if end_time - start_time >= 1 :  
12         break  
13 print j  
14 print end_time
15 
16 print "======== split =========="
17 start_time = time.time()  
18 print start_time  
19   
20 j = 1  
21 while 1:  
22     j += 1  
23     end_time = time.time()  
24     if end_time - start_time >= 1 :  
25         break  
26 print j  
27 print end_time

输出结果：

1399342863.16
2573550
1399342864.16
======== split ==========
1399342864.18
2973070
1399342865.18

一个是25万，一个是29万。大约提升了16%左右的性能。其实不是很明显。只是聊胜于无。

14、使用内置函数更快，如add(a,b)要快于a+b

15、如果需要交换两个变量的值使用 a,b=b,a 而不是借助中间变量 t=a;a=b;b=t；

16、生成序列

用range()函数生成序列，与自定义序列

（1）a = range(0,6)

（2）a = [0, 1, 2, 3, 4, 5]

分别测试了一下，结果如下：

loop_num: 1029877

loop_num: 1602341

结论：还是自己显式定义序列，效率更高。

17、生成序列副本

 生成一个序列的副本：用copy，与用切片特性

a = [0, 1, 2, 3, 4, 5]

（1）b = copy.copy(a)

（2）b = a[:]

分别测试了一下，结果如下：

loop_num: 677838

loop_num: 1530012

结论：变通的切片应用作为拷贝，比浅拷贝函数效率更高。注意，深拷贝效率很低！

18、慎用python内置函数

python内置函数，只是为了应对通用情况。在很多情况下，内置函数的性能，远远不如自己写的，有针对性的函数。动动手，换个算法，就能把性能提高一倍以上。

19、选择合适的格式化字符方式

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 

三种情况中，%的方式是最慢的，但是三者的差距并不大（都非常快）。(个人觉得%的可读性最好)

20、合理使用del

用del可以将对象占用内存空间的引用计数值置零（Deletion of a name removes the binding of that name from the local or global namespace）。它并不能让对象占用的内存被回收，但一段内存的引用计数变为零，就说明它可以再次被重新使用了（所以del后，不必要GC介入）。

如果不用del，下面这段代码就可能MemoryError

1 import numpy as np
2 
3 matrix1 = np.zeros((60000,100000))
4 matrix2 = np.zeros((60000,100000))
5 # using matrix1
6 # using matrix2

利用del，可以将用完后没必要占用内存的对象删掉，下面的代码对内存耗费就没上面的大。

1 import numpy as np
2 
3 matrix1 = np.zeros((60000,100000))
4 # using matrix1
5 del matrix1
6 
7 matrix2 = np.zeros((60000,100000))
8 # using matrix2
9 del matrix2

python 性能优化