能让Python性能起飞的15个小技巧（亲测，真的好用）

1.使用map()进行函数映射

测试数组为 oldlist = ['life', 'is', 'short', 'i', 'choose', 'python']。

• 方法一

	

		newlist = [] for word in oldlist: newlist.append(word.upper())
	

• 方法二

	

		list(map(str.upper, oldlist))
	

方法一耗时 0.5267724000000005s，方法二耗时 0.41462569999999843s，性能提升 21.29%

2.使用set()求交集

• 方法一

	

		overlaps = [] for x in a: for y in b: if x == y: overlaps.append(x)
	

• 方法二

	

		list(set(a) & set(b))
	

方法一耗时 0.9507264000000006s，方法二耗时 0.6148200999999993s，性能提升 35.33%

3.使用sort()或sorted()排序

测试数组：lists = [2,1,4,3,0]。

	

		def quick_sort(lists,i,j): if i >= j: return list pivot = lists[i] low = i
high = j while i < j: while i < j and lists[j] >= pivot: j -= 1 lists[i]=lists[j] while i < j and lists[i] <=pivot: i += 1 lists[j]=lists[i] lists[j] = pivot
quick_sort(lists,low,i-1) quick_sort(lists,i+1,high) return lists
	

	

		lists.sort()
	

方法一耗时 2.4796975000000003s，方法二耗时 0.05551999999999424s，性能提升 97.76%

• 通过lambda定义

	

		#学生：（姓名，成绩，年龄） students = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)] students.sort(key = lambda student: student[0]) #根据姓名排序 sorted(students, key = lambda student: student[0])
	

• 通过operator定义

	

		import operator

students = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)] students.sort(key=operator.itemgetter(0)) sorted(students, key = operator.itemgetter(1, 0)) #先对成绩排序，再对姓名排序 operator的itemgetter()适用于普通数组排序，attrgetter()适用于对象数组排序
	

• 通过cmp_to_key()定义，最为灵活

	

		import functools def cmp(a,b): if a[1] != b[1]: return -1 if a[1] < b[1] else 1 #先按照成绩升序排序 elif a[0] != b[0]: return -1 if a[0] < b[0] else 1 #成绩相同，按照姓名升序排序 else: return -1 if a[2] > b[2] else 1 #成绩姓名都相同，按照年龄降序排序 students = [('john', 'A', 15),('john', 'A', 14),('jane', 'B', 12),('dave', 'B', 10)] sorted(students, key = functools.cmp_to_key(cmp))
	

4.使用collections.Counter()计数

• 方法一

	

		counts = {} for char in sentence:
	

• 方法二

	

		from collections import Counter
Counter(sentence)
	

方法一耗时 2.8105250000000055s，方法二耗时 1.6317423000000062s，性能提升 41.94%

5.使用列表推导

• 方法一

	

		newlist = [] for x in oldlist: if x % 2 == 1:
	

• 方法二

	

		[x**2 for x in oldlist if x%2 == 1]
	

方法一耗时 1.5342976000000021s，方法二耗时 1.4181957999999923s，性能提升 7.57%

6.使用 join() 连接字符串

	

		sentence = "" for word in oldlist: sentence += word
	

	

		"".join(oldlist)
	

方法一耗时 0.27489080000000854s，方法二耗时 0.08166570000000206s，性能提升 70.29%

	

		oldlist = ['life', 'is', 'short', 'i', 'choose', 'python'] sentence = "//".join(oldlist) print(sentence)
	

life//is//short//i//choose//python

7.使用x, y = y, x交换变量

	

		temp = x
x = y
y = temp
	

	

		x, y = y, x
	

方法一耗时 0.027853900000010867s，方法二耗时 0.02398730000000171s，性能提升 13.88%

8.使用while 1取代while True

	

		i = 0 while True: i += 1 if i > 100: break
	

	

		i = 0 while 1: i += 1 if i > 100: break
	

方法一耗时 3.679268300000004s，方法二耗时 3.607847499999991s，性能提升1.94%

9.使用装饰器缓存

	

		def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 return fibonacci(n - 1) + fibonacci(n-2)
	

	

		import functools @functools.lru_cache(maxsize=128) def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 return fibonacci(n - 1) + fibonacci(n-2)
	

方法一耗时 3.955014900000009s，方法二耗时 0.05077979999998661s，性能提升 98.72%

	

		import functools @functools.lru_cache(maxsize=100) def demo(a, b): print('我被执行了') return a + b if __name__ == '__main__': demo(1, 2) demo(1, 2)
	

	

		from functools import lru_cache @lru_cache(maxsize=100) def list_sum(nums: list): return sum(nums) if __name__ == '__main__': list_sum([1, 2, 3, 4, 5])
	

TypeError: unhashable type: 'list'

10.减少点运算符(.)的使用

	

		newlist = [] for word in oldlist: newlist.append(str.upper(word))
	

	

		newlist = [] upper = str.upper for word in oldlist: newlist.append(upper(word))
	

11.使用for循环取代while循环

	

		i = 0 while i < 100: i += 1
	

	

		for _ in range(100): pass
	

方法一耗时 3.894683299999997s，方法二耗时 1.0198077999999953s，性能提升73.82%

12.使用Numba.jit加速计算

	

		def my_sum(n): x = 0 for i in range(1, n+1): x += i return x
	

	

		from numba import jit @jit(nopython=True) def numba_sum(n): x = 0 for i in range(1, n+1): x += i return x
	

方法一耗时 3.7199997000000167s，方法二耗时 0.23769430000001535s，性能提升 93.61%

13.使用Numpy矢量化数组

	

		[a[i]*b[i] for i in range(len(a))]
	

	

		import numpy as np
a = np.array([1,2,3,4,5]) b = np.array([2,4,6,8,10]) a*b
	

方法一耗时 0.6706845000000214s，方法二耗时 0.3070132000000001s，性能提升 54.22%

14.使用in检查列表成员

	

		def check_member(target, lists): for member in lists: if member == target: return True return False
	

	

		if target in lists: pass
	

方法一耗时 0.16038449999999216s，方法二耗时 0.04139250000000061s，性能提升 74.19%

15.使用itertools库迭代

	

		def permutations(lst): if len(lst) == 1 or len(lst) == 0: return [lst] result = [] for i in lst: temp_lst = lst[:] temp_lst.remove(i) temp = permutations(temp_lst) for j in temp: j.insert(0, i) result.append(j) return result
	

	

		import itertools
itertools.permutations(["Alice", "Bob", "Carol"])
	

方法一耗时 3.867292899999484s，方法二耗时 0.3875405000007959s，性能提升 89.98%

1.尽量使用内置库函数 内置库函数由专业的开发人员编写并经过了多次测试，很多库函数的底层是用C语言开发的。因此，这些函数总体来说是非常高效的（比如sort()、join()等），自己编写的方法很难超越它们，还不如省省功夫，不要重复造轮子了，何况你造的轮子可能更差。所以，如果函数库中已经存在该函数，就直接拿来用。 2.尽量使用优秀的第三方库 有很多优秀的第三方库，它们的底层可能是用 C 和 Fortran 来实现的，像这样的库用起来绝对不会吃亏，比如前文提到的 Numpy 和 Numba，它们带来的提升都是非常惊人的。类似这样的库还有很多，比如Cython、PyPy等，这里我只是抛砖引玉。