关于python性能提升的一些方案(上)

一、函数调用优化（空间跨度，避免访问内存）

1.大数据求和，使用sum

a = range(100000)
%timeit -n 10 sum(a)
10 loops, best of 3: 3.15 ms per loop
%%timeit
   ...: s = 0
   ...: for i in a:
   ...:   s += i
   ...:
100 loops, best of 3: 6.93 ms per loop

2.小数据求和，避免使用sum

%timeit -n 1000 s = a + b + c + d + e + f + g + h + i + j + k # 数据量较小时直接累加更快
1000 loops, best of 3: 571 ns per loop
%timeit -n 1000 s = sum([a,b,c,d,e,f,g,h,i,j,k]) # 小数据量调用 sum 函数，空间效率降低
1000 loops, best of 3: 669 ns per loop

结论：大数据求和sum效率高，小数据求和直接累加效率高。

二、for循环优化之取元素（使用栈或寄存器，避免访问内存）

for lst in [(1, 2, 3), (4, 5, 6)]: # lst 索引需要额外开销
    pass

　　应尽量避免使用索引。

for a, b, c in [(1, 2, 3), (4, 5, 6)]: # better
    pass

　　相当于给每一个元素直接赋值。

def force():
  lst = range(4)
  for a1 in [1, 2]:
      for a2 in lst:
          for a3 in lst:
             for b1 in lst:
                  for b2 in lst:
                      for b3 in lst:
                          for c1 in lst:
                             for c2 in lst:
                                 for c3 in lst:
                                     for d1 in lst:
                                          yield (a1, a2, a3, b1, b2, b3, c1, c2, c3, d1)

%%timeit -n 10
for t in force():
    sum([t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9]])
10 loops, best of 3: 465 ms per loop
%%timeit -n 10
for a1, a2, a3, b1, b2, b3, c1, c2, c3, d1 in force():
    sum([a1, a2, a3, b1, b2, b3, c1, c2, c3, d1])
10 loops, best of 3: 360 ms per loop

三、生成器优化（查表代替运算）

def force(start, end): # 用于密码暴力破解程序
    for i in range(start, end):
        now = i
        sublst = []
        for j in range(10):
            sublst.append(i % 10) # 除法运算开销较大，比乘法大
            i //= 10
        sublst.reverse()
        yield(tuple(sublst), now)

def force(): # better
  lst = range(5)
  for a1 in [1]:
      for a2 in lst:
          for a3 in lst:
             for b1 in lst:
                  for b2 in lst:
                      for b3 in lst:
                          for c1 in lst:
                             for c2 in lst:
                                 for c3 in lst:
                                     for d1 in lst:
                                          yield (a1, a2, a3, b1, b2, b3, c1, c2, c3, d1)

　　

r0 = [1, 2]  # 可读性与灵活性
r1 = range(10)
r2 = r3 = r4 = r5 = r6 = r7 = r8 = r9 = r1
force = ((a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
            for a0 in r0 for a1 in r1 for a2 in r2 for a3 in r3 for a4 in r4
            for a5 in r5 for a6 in r6 for a7 in r7 for a8 in r8 for a9 in r9)

　四、幂运算优化（pow（x，y，z））　

def isprime(n):
    if n & 1 == 0:
        return False
    k, q = find_kq(n)
    a = randint(1, n - 1)
    if pow(a, q, n) == 1:  # 比使用 a ** q % n 运算优化数倍
        return True
    for j in range(k):
        if pow(a, pow(2, j) * q, n) == n - 1:  # a **((2 ** j) * q) % n
            return True
    return False

结论：pow（x,y,z）优于x**y%z.

五、除法运算优化

In [1]: from random import getrandbits

In [2]: x = getrandbits(4096)

In [3]: y = getrandbits(2048)

In [4]: %timeit -n 10000 q, r = divmod(x, y)
10000 loops, best of 3: 10.7 us per loop

In [5]: %timeit -n 10000 q, r = x//y, x % y
10000 loops, best of 3: 21.2 us per loop

结论：divmod优于//和%。

六、优化算法时间复杂度

　　算法的时间复杂度对程序的执行效率影响最大，在python中可以选择合适的数据结构来优化时间复杂度，如list和set查找某一个元素的时间复杂度分别是O(n)和O(1)。不同场景有不同的优化方式，总的来说，一般有分治，分支定界、贪心动态规划等思想。

七、合理使用copy和deepcopy

　　对于dict和list等数据结构的对象，直接赋值使用的是引用的方式。而有些情况下需要复制整个对象，这时可以使用copy包里的copy和deepcopy，这两个函数的不同之处在于deepcopy是递归复制的。效率不同：

In [23]: import copy
In [24]: %timeit -n 10 copy.copy(a)
10 loops, best of 3: 606 ns per loop
In [25]: %timeit -n 10 copy.deepcopy(a)
10 loops, best of 3: 1.17 us per loop

　　timeit后面的-n表示运行的次数，后两行对应的是两个timeit的输出，下同。由此可见后者慢一个数量级。

关于copy的一个例子：

>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

　　发生的事情是这样的，[[]]是包含一个空列表的只有一个元素的列表，所以[[]] * 3的所有三个元素都是（指向）这个空列表。修改lists的任何元素都修改这个列表。修改效率高。

八、使用dict或set查找元素

　　python 字典和集合都是使用hash表来实现（类似c++标准库unordered_map），查找元素的时间复杂度是O(1)。

In [1]: r = range(10**7)
In [2]: s = set(r) # 占用 588MB 内存
In [3]: d = dict((i, 1) for i in r)  # 占用 716MB 内存
In [4]: %timeit -n 10000 (10**7) - 1 in r
10000 loops, best of 3: 291 ns per loop
In [5]: %timeit -n 10000 (10**7) - 1 in s
10000 loops, best of 3: 121 ns per loop
In [6]: %timeit -n 10000 (10**7) - 1 in d
10000 loops, best of 3: 111 ns per loop

结论：set 的内存占用量最小，dict运行时间最短。

九、合理使用（generator）和yield（节省内存）

In [1]: %timeit -n 10 a = (i for i in range(10**7))  # 生成器通常遍历更高效
10 loops, best of 3: 933 ns per loop
In [2]: %timeit -n 10 a = [i for i in range(10**7)]
10 loops, best of 3: 916 ms per loop
In [1]: %timeit -n 10 for x in (i for i in range(10**7)): pass
10 loops, best of 3: 749 ms per loop
In [2]: %timeit -n 10 for x in [i for i in range(10**7)]: pass
10 loops, best of 3: 1.05 s per loop

　　结论：尽量使用生成器去遍历。