Python内置数据类型list各方法的性能测试过程解析

这篇文章主要介绍了Python内置数据类型list各方法的性能测试过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

测试环境

本文所涉及的代码均在MacOS系统与CentOS7下测试，使用的Python版本为3.6.8。

测试模块

测试用的模块是Python内置的timeit模块：

timeit模块可以用来测试一小段Python代码的执行速度。

Timer类

class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>)

Timer是测量小段代码执行速度的类。

stmt参数是要测试的代码语句（statment）；

setup参数是运行代码时需要的设置；

timer参数是一个定时器函数，与平台有关。

Timer类的timeit方法

timeit.Timer.timeit(number=1000000)

Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数，默认为1000000次。方法返回执行代码的平均耗时，一个float类型的秒数。

列表内置方法的性能测试

我们知道，生成一个列表可以使用列表生成式或者append、insert、extend这些方法，现在我们来看一下这些方法的执行效率：

1. from timeit import Timer
2.  
3.  
4. def test_list():
5. lst = list(range(1000))
6.  
7. def test_generation():
8. lst = [i for i in range(1000)]
9.  
10.  
11. def test_append():
12. lst = []
13. for i in range(1000):
14. lst.append(i)
15.  
16. def test_add():
17. lst = []
18. for i in range(1000):
19. lst += [i]
20.  
21. # 在列表的头部insert
22. def test_insert_zero():
23. lst = []
24. for i in range(1000):
25. lst.insert(0,i)
26.  
27. # 在列表的尾部insert
28. def test_insert_end():
29. lst = []
30. for i in range(1000):
31. lst.insert(-1,i)
32.  
33. def test_extend():
34. lst = []
35. lst.extend(list(range(1000)))
36.  
37.  
38. t1 = Timer("test_list()","from __main__ import test_list")
39. print(f"test_list takes {t1.timeit(number=1000)} seconds")
40.  
41. t2 = Timer("test_generation()","from __main__ import test_generation")
42. print(f"test_generation takes {t2.timeit(number=1000)} seconds")
43.  
44. t3 = Timer("test_append()","from __main__ import test_append")
45. print(f"test_append takes {t3.timeit(number=1000)} seconds")
46.  
47. t4 = Timer("test_add()","from __main__ import test_add")
48. print(f"test_add takes {t4.timeit(number=1000)} seconds")
49.  
50. t5 = Timer("test_insert_zero()","from __main__ import test_insert_zero")
51. print(f"test_insert_zero takes {t5.timeit(number=1000)} seconds")
52.  
53. t6 = Timer("test_insert_end()","from __main__ import test_insert_end")
54. print(f"test_insert_end takes {t6.timeit(number=1000)} seconds")
55.  
56. t7 = Timer("test_extend()","from __main__ import test_extend")
57. print(f"test_extend takes {t7.timeit(number=1000)} seconds")

我们先看看在MacOS系统下，执行上面这段代码的结果：

1. """
2. test_list takes 0.012904746999993222 seconds
3. test_generation takes 0.03530399600003875 seconds
4. test_append takes 0.0865129750000051 seconds
5. test_add takes 0.08066114099983679 seconds
6. test_insert_zero takes 0.30594958500023495 seconds
7. test_insert_end takes 0.1522782449992519 seconds
8. test_extend takes 0.017534753999825625 seconds
9. """

我们可以看到：直接使用list方法强转的效率最高，其次是使用列表生成式，而append与直接加的方式紧随其后并且二者的效率相当；insert方法的执行效率最低——并且从头插入的效率要低于从尾部插入的效率！最后我们将强转的列表使用extend方法放入到新的列表中的过程效率并没有减少多少。

然后试试在Linux系统下的执行结果：

列表pop方法的性能测试

pop可以从第0各位置删除元素，也可以从最后位置删除元素（默认删除最后面的元素），现在我们来测试一下两种从不同位置删除元素的性能对比：

1. from timeit import Timer
2.  
3. def test_pop_zero():
4. lst = list(range(2000))
5. for i in range(2000):
6. lst.pop(0)
7.  
8.  
9. def test_pop_end():
10. lst = list(range(2000))
11. for i in range(2000):
12. lst.pop()
13. t1 = Timer("test_pop_zero()","from __main__ import test_pop_zero")
14. print(f"test_pop_zero takes {t1.timeit(number=1000)} seconds")
15.  
16. t2 = Timer("test_pop_end()","from __main__ import test_pop_end")
17. print(f"test_pop_end takes {t2.timeit(number=1000)} seconds")

在MacOS下程序的执行结果为：

1. test_pop_zero takes 0.5015365449999081 seconds
2.  
3. test_pop_end takes 0.22170215499954793 seconds

然后我们来试试Linux系统中的执行结果：

可以看到：从列表的尾部删除元素的效率要比从头部删除的效率高很多！

关于列表insert方法的一个小坑

如果想使用insert方法生成一个列表[0,1,2,3,4,5]的话（当然使用insert方法效率会低很多，建议使用其他的方法）会有一个这样的问题，在此记录一下：

1. def test_insert():
2. lst = []
3. for i in range(6):
4. lst.insert(-1,i)
5. print(lst)
6.  
7. test_insert()

结果竟然是这样的——第一个元素竟然一直在最后！

1. [0]
2. [1, 0]
3. [1, 2, 0]
4. [1, 2, 3, 0]
5. [1, 2, 3, 4, 0]
6. [1, 2, 3, 4, 5, 0]

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。