程序运行慢？你怕是写的假Python

Python程序运行太慢的一个可能的原因是没有尽可能的调用内置方法，下面通过5个例子来演示如何用内置方法提升Python程序的性能。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、网络空间、营销软件、网站建设、蟠龙网站维护、网站推广。

1. 数组求平方和

输入一个列表，要求计算出该列表中数字的的平方和。最终性能提升了1.4倍。首先创建一个长度为10000的列表。

 
 
 
    
  
  
  
  1. arr = list(range(10000))
    2.

1.1 最常规的写法

while循环遍历列表求平方和。平均运行时间2.97毫秒。

 
 
 
    
  
  
  
  1. def sum_sqr_0(arr):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     n = len(arr)
    4. 
  
  
  
  4.     i = 0
    5. 
  
  
  
  5.     while i < n:
    6. 
  
  
  
  6.         res += arr[i] ** 2
    7. 
  
  
  
  7.         i += 1
    8. 
  
  
  
  8.     return res
    9. 
  
  
  
  9. %timeit sum_sqr_0(arr)
    10. 
  
  
  
  10. 2.97 ms ± 36.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    11.

1.2 for range代替while循环

避免i += 1的变量类型检查带来的额外开销。平均运行时间2.9毫秒。

 
 
 
    
  
  
  
  1. def sum_sqr_1(arr):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     for i in range(len(arr)):
    4. 
  
  
  
  4.         res += arr[i] ** 2
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit sum_sqr_1(arr)
    7. 
  
  
  
  7. 2.9 ms ± 137 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    8.

1.3 for x in arr代替for range

避免arr[i]的变量类型检查带来的额外开销。平均运行时间2.59毫秒。

 
 
 
    
  
  
  
  1. def sum_sqr_2(arr):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     for x in arr:
    4. 
  
  
  
  4.         res += x ** 2
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit sum_sqr_2(arr)
    7. 
  
  
  
  7. 2.59 ms ± 89 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    8.

1.4 sum函数套用map函数

平均运行时间2.36毫秒

 
 
 
    
  
  
  
  1. def sum_sqr_3(arr):
    2. 
  
  
  
  2.     return sum(map(lambda x: x**2, arr))
    3. 
  
  
  
  3. %timeit sum_sqr_3(arr)
    4. 
  
  
  
  4. 2.36 ms ± 15.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    5.

1.5 sum函数套用生成器表达式

生成器表达式如果作为某个函数的参数，则可以省略掉()。平均运行时间2.35毫秒。

 
 
 
    
  
  
  
  1. def sum_sqr_4(arr):
    2. 
  
  
  
  2.     return sum(x ** 2 for x in arr)
    3. 
  
  
  
  3. %timeit sum_sqr_4(arr)
    4. 
  
  
  
  4. 2.35 ms ± 107 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    5.

1. 6 sum函数套用列表推导式

平均运行时间2.06毫秒。

 
 
 
    
  
  
  
  1. def sum_sqr_5(arr):
    2. 
  
  
  
  2.     return sum([x ** 2 for x in arr])
    3. 
  
  
  
  3. %timeit sum_sqr_5(arr)
    4. 
  
  
  
  4. 2.06 ms ± 27.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    5.

2. 字符串拼接

输入一个列表，要求将列表中的字符串的前3个字符都拼接为一个字符串。最终性能提升了2.1倍。

首先创建一个列表，生成10000个随机长度和内容的字符串。

 
 
 
    
  
  
  
  1. from random import randint
    2. 
  
  
  
  2. 
  
  
  
  3. def random_letter():
    4. 
  
  
  
  4.     return chr(ord('a') + randint(0, 25))
    5. 
  
  
  
  5. 
  
  
  
  6. def random_letters(n):
    7. 
  
  
  
  7.     return "".join([random_letter() for _ in range(n)])
    8. 
  
  
  
  8. 
  
  
  
  9. strings = [random_letters(randint(1, 10)) for _ in range(10000)]
    10.

2.1 最常规的写法

while循环遍历列表，对字符串进行拼接。平均运行时间1.86毫秒。

 
 
 
    
  
  
  
  1. def concat_strings_0(strings):
    2. 
  
  
  
  2.     res = ""
    3. 
  
  
  
  3.     n = len(strings)
    4. 
  
  
  
  4.     i = 0
    5. 
  
  
  
  5.     while i < n:
    6. 
  
  
  
  6.         res += strings[i][:3]
    7. 
  
  
  
  7.         i += 1
    8. 
  
  
  
  8.     return res
    9. 
  
  
  
  9. %timeit concat_strings_0(strings)
    10. 
  
  
  
  10. 1.86 ms ± 74.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    11.

2.2 for range代替while循环

避免i += 1的变量类型检查带来的额外开销。平均运行时间1.55毫秒。

 
 
 
    
  
  
  
  1. def concat_strings_1(strings):
    2. 
  
  
  
  2.     res = ""
    3. 
  
  
  
  3.     for i in range(len(strings)):
    4. 
  
  
  
  4.         res += strings[i][:3]
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit concat_strings_1(strings)
    7. 
  
  
  
  7. 1.55 ms ± 32.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    8.

2.3 for x in strings代替for range

避免strings[i]的变量类型检查带来的额外开销。平均运行时间1.32毫秒。

 
 
 
    
  
  
  
  1. def concat_strings_2(strings):
    2. 
  
  
  
  2.     res = ""
    3. 
  
  
  
  3.     for x in strings:
    4. 
  
  
  
  4.         res += x[:3]
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit concat_strings_2(strings)
    7. 
  
  
  
  7. 1.32 ms ± 19.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    8.

2.4 .join方法套用生成器表达式

平均运行时间1.06毫秒。

 
 
 
    
  
  
  
  1. def concat_strings_3(strings):
    2. 
  
  
  
  2.     return "".join(x[:3] for x in strings)
    3. 
  
  
  
  3. %timeit concat_strings_3(strings)
    4. 
  
  
  
  4. 1.06 ms ± 15.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

2.5 .join方法套用列表解析式

平均运行时间0.85毫秒。

 
 
 
    
  
  
  
  1. def concat_strings_4(strings):
    2. 
  
  
  
  2.     return "".join([x[:3] for x in strings])
    3. 
  
  
  
  3. %timeit concat_strings_4(strings)
    4. 
  
  
  
  4. 858 µs ± 14.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

3. 筛选奇数

输入一个列表，要求筛选出该列表中的所有奇数。最终性能提升了3.6倍。

首先创建一个长度为10000的列表。

 
 
 
    
  
  
  
  1. arr = list(range(10000))
    2.

3.1 最常规的写法

创建一个空列表res，while循环遍历列表，将奇数append到res中。平均运行时间1.03毫秒。

 
 
 
    
  
  
  
  1. def filter_odd_0(arr):
    2. 
  
  
  
  2.     res = []
    3. 
  
  
  
  3.     i = 0
    4. 
  
  
  
  4.     n = len(arr)
    5. 
  
  
  
  5.     while i < n:
    6. 
  
  
  
  6.         if arr[i] % 2:
    7. 
  
  
  
  7.             res.append(arr[i])
    8. 
  
  
  
  8.         i += 1
    9. 
  
  
  
  9.     return res
    10. 
  
  
  
  10. %timeit filter_odd_0(arr)
    11. 
  
  
  
  11. 1.03 ms ± 34.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    12.

3.2 for range代替while循环

避免i += 1的变量类型检查带来的额外开销。平均运行时间0.965毫秒。

 
 
 
    
  
  
  
  1. def filter_odd_1(arr):
    2. 
  
  
  
  2.     res = []
    3. 
  
  
  
  3.     for i in range(len(arr)):
    4. 
  
  
  
  4.         if arr[i] % 2:
    5. 
  
  
  
  5.             res.append(arr[i])
    6. 
  
  
  
  6.         i += 1
    7. 
  
  
  
  7.     return res
    8. 
  
  
  
  8. %timeit filter_odd_1(arr)
    9. 
  
  
  
  9. 965 µs ± 4.02 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    10.

3.3 for x in arr代替for range

避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.430毫秒。

 
 
 
    
  
  
  
  1. def filter_odd_2(arr):
    2. 
  
  
  
  2.     res = []
    3. 
  
  
  
  3.     for x in arr:
    4. 
  
  
  
  4.         if x % 2:
    5. 
  
  
  
  5.             res.append(x)
    6. 
  
  
  
  6.     return res
    7. 
  
  
  
  7. %timeit filter_odd_2(arr)
    8. 
  
  
  
  8. 430 µs ± 9.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    9.

3.4 list套用filter函数

平均运行时间0.763毫秒。注意filter函数很慢，在Python 3.6里非常鸡肋。

 
 
 
    
  
  
  
  1. def filter_odd_3(arr):
    2. 
  
  
  
  2.     return list(filter(lambda x: x % 2, arr))
    3. 
  
  
  
  3. %timeit filter_odd_3(arr)
    4. 
  
  
  
  4. 763 µs ± 15.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

3.5 list套用生成器表达式

平均运行时间0.398毫秒。

 
 
 
    
  
  
  
  1. def filter_odd_4(arr):
    2. 
  
  
  
  2.     return list((x for x in arr if x % 2))
    3. 
  
  
  
  3. %timeit filter_odd_4(arr)
    4. 
  
  
  
  4. 398 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

3.6 带条件的列表推导式

平均运行时间0.290毫秒。

 
 
 
    
  
  
  
  1. def filter_odd_5(arr):
    2. 
  
  
  
  2.     return [x for x in arr if x % 2]
    3. 
  
  
  
  3. %timeit filter_odd_5(arr)
    4. 
  
  
  
  4. 290 µs ± 5.54 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

4. 两个数组相加

输入两个长度相同的列表，要求计算出两个列表对应位置的数字之和，返回一个与输入长度相同的列表。最终性能提升了2.7倍。

首先生成两个长度为10000的列表。

 
 
 
    
  
  
  
  1. arr1 = list(range(10000)) 
    2. 
  
  
  
  2. arr2 = list(range(10000)) 
    3.

4.1 最常规的写法

创建一个空列表res，while循环遍历列表，将两个列表对应的元素之和append到res中。平均运行时间1.23毫秒。

 
 
 
    
  
  
  
  1. def arr_sum_0(arr1, arr2):
    2. 
  
  
  
  2.     i = 0
    3. 
  
  
  
  3.     n = len(arr1)
    4. 
  
  
  
  4.     res = []
    5. 
  
  
  
  5.     while i < n:
    6. 
  
  
  
  6.         res.append(arr1[i] + arr2[i])
    7. 
  
  
  
  7.         i += 1
    8. 
  
  
  
  8.     return res
    9. 
  
  
  
  9. %timeit arr_sum_0(arr1, arr2)
    10. 
  
  
  
  10. 1.23 ms ± 3.77 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    11.

4.2 for range代替while循环

避免i += 1的变量类型检查带来的额外开销。平均运行时间0.997毫秒。

 
 
 
    
  
  
  
  1. def arr_sum_1(arr1, arr2):
    2. 
  
  
  
  2.     res = []
    3. 
  
  
  
  3.     for i in range(len(arr1)):
    4. 
  
  
  
  4.         res.append(arr1[i] + arr2[i])
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit arr_sum_1(arr1, arr2)
    7. 
  
  
  
  7. 997 µs ± 7.42 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    8.

4.3 for i, x in enumerate代替for range

部分避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.799毫秒。

 
 
 
    
  
  
  
  1. def arr_sum_2(arr1, arr2):
    2. 
  
  
  
  2.     res = arr1.copy()
    3. 
  
  
  
  3.     for i, x in enumerate(arr2):
    4. 
  
  
  
  4.         res[i] += x
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit arr_sum_2(arr1, arr2)
    7. 
  
  
  
  7. 799 µs ± 16.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    8.

4.4 for x, y in zip代替for range

避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.769毫秒。

 
 
 
    
  
  
  
  1. def arr_sum_3(arr1, arr2):
    2. 
  
  
  
  2.     res = []
    3. 
  
  
  
  3.     for x, y in zip(arr1, arr2):
    4. 
  
  
  
  4.         res.append(x + y)
    5. 
  
  
  
  5.     return res
    6. 
  
  
  
  6. %timeit arr_sum_3(arr1, arr2)
    7. 
  
  
  
  7. 769 µs ± 12.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    8.

4.5 列表推导式套用zip

平均运行时间0.462毫秒。

 
 
 
    
  
  
  
  1. def arr_sum_4(arr1, arr2):
    2. 
  
  
  
  2.     return [x + y for x, y in zip(arr1, arr2)]
    3. 
  
  
  
  3. %timeit arr_sum_4(arr1, arr2)
    4. 
  
  
  
  4. 462 µs ± 3.43 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    5.

5. 两个列表相同元素的数量

输入两个列表，要求统计两个列表相同元素的数量。其中每个列表内的元素都是不重复的。最终性能提升了5000倍。

首先创建两个列表，并将元素的顺序打乱。

 
 
 
    
  
  
  
  1. from random import shuffle
    2. 
  
  
  
  2. arr1 = list(range(2000))
    3. 
  
  
  
  3. shuffle(arr1)
    4. 
  
  
  
  4. arr2 = list(range(1000, 3000))
    5. 
  
  
  
  5. shuffle(arr2)
    6.

5.1 最常规的写法

while循环嵌套，判断元素arr1[i]是否等于arr2[j]，平均运行时间338毫秒。

 
 
 
    
  
  
  
  1. def n_common_0(arr1, arr2):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     i = 0
    4. 
  
  
  
  4.     m = len(arr1)
    5. 
  
  
  
  5.     n = len(arr2)
    6. 
  
  
  
  6.     while i < m:
    7. 
  
  
  
  7.         j = 0
    8. 
  
  
  
  8.         while j < n:
    9. 
  
  
  
  9.             if arr1[i] == arr2[j]:
    10. 
  
  
  
  10.                 res += 1
    11. 
  
  
  
  11.             j += 1
    12. 
  
  
  
  12.         i += 1
    13. 
  
  
  
  13.     return res
    14. 
  
  
  
  14. %timeit n_common_0(arr1, arr2)
    15. 
  
  
  
  15. 338 ms ± 7.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
    16.

5.2 for range代替while循环

避免i += 1的变量类型检查带来的额外开销。平均运行时间233毫秒。

 
 
 
    
  
  
  
  1. def n_common_1(arr1, arr2):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     for i in range(len(arr1)):
    4. 
  
  
  
  4.         for j in range(len(arr2)):
    5. 
  
  
  
  5.             if arr1[i] == arr2[j]:
    6. 
  
  
  
  6.                 res += 1
    7. 
  
  
  
  7.     return res
    8. 
  
  
  
  8. %timeit n_common_1(arr1, arr2)
    9. 
  
  
  
  9. 233 ms ± 10.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
    10.

5.3 for x in arr代替for range

避免arr[i]的变量类型检查带来的额外开销。平均运行时间84.8毫秒。

 
 
 
    
  
  
  
  1. def n_common_2(arr1, arr2):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     for x in arr1:
    4. 
  
  
  
  4.         for y in arr2:
    5. 
  
  
  
  5.             if x == y:
    6. 
  
  
  
  6.                 res += 1
    7. 
  
  
  
  7.     return res
    8. 
  
  
  
  8. %timeit n_common_2(arr1, arr2)
    9. 
  
  
  
  9. 84.8 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
    10.

5.4 使用if x in arr2代替内层循环

平均运行时间24.9毫秒。

 
 
 
    
  
  
  
  1. def n_common_3(arr1, arr2):
    2. 
  
  
  
  2.     res = 0
    3. 
  
  
  
  3.     for x in arr1:
    4. 
  
  
  
  4.         if x in arr2:
    5. 
  
  
  
  5.             res += 1
    6. 
  
  
  
  6.     return res
    7. 
  
  
  
  7. %timeit n_common_3(arr1, arr2)
    8. 
  
  
  
  8. 24.9 ms ± 1.39 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
    9.

5.4 使用更快的算法

将数组用.sort方法排序，再进行单层循环遍历。把时间复杂度从O(n2)降低到O(nlogn)，平均运行时间0.239毫秒。

 
 
 
    
  
  
  
  1. def n_common_4(arr1, arr2):
    2. 
  
  
  
  2.     arr1.sort()
    3. 
  
  
  
  3.     arr2.sort()
    4. 
  
  
  
  4.     res = i = j = 0
    5. 
  
  
  
  5.     m, n = len(arr1), len(arr2)
    6. 
  
  
  
  6.     while i < m and j < n:
    7. 
  
  
  
  7.         if arr1[i] == arr2[j]:
    8. 
  
  
  
  8.             res += 1
    9. 
  
  
  
  9.             i += 1
    10. 
  
  
  
  10.             j += 1
    11. 
  
  
  
  11.         elif arr1[i] > arr2[j]:
    12. 
  
  
  
  12.             j += 1
    13. 
  
  
  
  13.         else:
    14. 
  
  
  
  14.             i += 1
    15. 
  
  
  
  15.     return res
    16. 
  
  
  
  16. %timeit n_common_4(arr1, arr2)
    17. 
  
  
  
  17. 329 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    18.

5.5 使用更好的数据结构

将数组转为集合，求交集的长度。平均运行时间0.067毫秒。

 
 
 
    
  
  
  
  1. def n_common_5(arr1, arr2):
    2. 
  
  
  
  2.     return len(set(arr1) & set(arr2))
    3. 
  
  
  
  3. %timeit n_common_5(arr1, arr2)
    4. 
  
  
  
  4. 67.2 µs ± 755 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
    5.

 【责任编辑：庞桂玉 TEL：（010）68476606】

标题名称：程序运行慢？你怕是写的假Python
文章转载：http://www.gawzjz.com/qtweb/news21/175371.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

同城分类信息

平昌保洁　　 　重庆网站建设　　 　网站定制　　 　腾讯云香港虚拟主机　　 　等级保护测评　　 　攀枝花网站建设　　 　金融行业网站建设方案　　 　广汉长尔科技　　 　Android开发　　 　成都网站设计　　 　网站搜索引擎优化　　 　网站设计　　 　高端网站设计　　 　雅安服务器托管　　 　子晨包装　　 　兴久牧业　　 　自贡服务器托管　　 　木包装箱　　 　手机APP开发　　 　广东帝美豪门窗