Python 实现循环最快方式（for、while 等速度对比）

顺势而为47

文章转自微信公众号-Python之禅
众所周知，

1. Python

复制代码

不是一种执行效率较高的语言。此外在任何语言中，循环都是一种非常消耗时间的操作。假如任意一种简单的单步操作耗费的时间为 1 个单位，将此操作重复执行上万次，最终耗费的时间也将增长上万倍。

1. while

复制代码

和

1. for

复制代码

是

1. Python

复制代码

中常用的两种实现循环的关键字，它们的运行效率实际上是有差距的。
比如下面的测试代码：

1. import timeit
   
2. 
   
3. 
   
4. def while_loop(n=100_000_000):
   
5.     i = 0
   
6.     s = 0
   
7.     while i < n:
   
8.         s += i
   
9.         i += 1
   
10.     return s
    
11. 
    
12. 
    
13. def for_loop(n=100_000_000):
    
14.     s = 0
    
15.     for i in range(n):
    
16.         s += i
    
17.     return s
    
18. 
    
19. 
    
20. def main():
    
21.     print('while loop\t\t', timeit.timeit(while_loop, number=1))
    
22.     print('for loop\t\t', timeit.timeit(for_loop, number=1))
    
23. 
    
24. 
    
25. if __name__ == '__main__':
    
26.     main()
    
27. # => while loop               4.718853999860585
    
28. # => for loop                 3.211570399813354

复制代码

这是一个简单的求和操作，计算从 1 到 n 之间所有自然数的总和。可以看到

1. for

复制代码

循环相比

1. while

复制代码

要快 1.5 秒。
其中的差距主要在于两者的机制不同。
在每次循环中，

1. while

复制代码

实际上比 for 多执行了两步操作：边界检查和变量 i 的自增。即每进行一次循环，

1. while

复制代码

都会做一次边界检查

1. (while i < n）

复制代码

和自增计算（i +=1）。这两步操作都是显式的纯 Python 代码。
for 循环不需要执行边界检查和自增操作，没有增加显式的

1. Python

复制代码

代码（纯 Python 代码效率低于底层的 C 代码）。当循环的次数足够多，就出现了明显的效率差距。
可以再增加两个函数，在 for 循环中加上不必要的边界检查和自增计算：

1. import timeit
   
2. 
   
3. 
   
4. def while_loop(n=100_000_000):
   
5.     i = 0
   
6.     s = 0
   
7.     while i < n:
   
8.         s += i
   
9.         i += 1
   
10.     return s
    
11. 
    
12. 
    
13. def for_loop(n=100_000_000):
    
14.     s = 0
    
15.     for i in range(n):
    
16.         s += i
    
17.     return s
    
18. 
    
19. 
    
20. def for_loop_with_inc(n=100_000_000):
    
21.     s = 0
    
22.     for i in range(n):
    
23.         s += i
    
24.         i += 1
    
25.     return s
    
26. 
    
27. 
    
28. def for_loop_with_test(n=100_000_000):
    
29.     s = 0
    
30.     for i in range(n):
    
31.         if i < n:
    
32.             pass
    
33.         s += i
    
34.     return s
    
35. 
    
36. 
    
37. def main():
    
38.     print('while loop\t\t', timeit.timeit(while_loop, number=1))
    
39.     print('for loop\t\t', timeit.timeit(for_loop, number=1))
    
40.     print('for loop with increment\t\t',
    
41.           timeit.timeit(for_loop_with_inc, number=1))
    
42.     print('for loop with test\t\t', timeit.timeit(for_loop_with_test, number=1))
    
43. 
    
44. 
    
45. if __name__ == '__main__':
    
46.     main()
    
47. # => while loop               4.718853999860585
    
48. # => for loop                 3.211570399813354
    
49. # => for loop with increment          4.602369500091299
    
50. # => for loop with test               4.18337869993411

复制代码

可以看出，增加的边界检查和自增操作确实大大影响了

1. for

复制代码

循环的执行效率。
前面提到过，

1. Python

复制代码

底层的解释器和内置函数是用 C 语言实现的。而 C 语言的执行效率远大于

1. Python

复制代码

。
对于上面的求等差数列之和的操作，借助于

1. Python

复制代码

内置的

1. sum

复制代码

函数，可以获得远大于

1. for

复制代码

或 while 循环的执行效率。

1. import timeit
   
2. 
   
3. 
   
4. def while_loop(n=100_000_000):
   
5.     i = 0
   
6.     s = 0
   
7.     while i < n:
   
8.         s += i
   
9.         i += 1
   
10.     return s
    
11. 
    
12. 
    
13. def for_loop(n=100_000_000):
    
14.     s = 0
    
15.     for i in range(n):
    
16.         s += i
    
17.     return s
    
18. 
    
19. 
    
20. def sum_range(n=100_000_000):
    
21.     return sum(range(n))
    
22. 
    
23. 
    
24. def main():
    
25.     print('while loop\t\t', timeit.timeit(while_loop, number=1))
    
26.     print('for loop\t\t', timeit.timeit(for_loop, number=1))
    
27.     print('sum range\t\t', timeit.timeit(sum_range, number=1))
    
28. 
    
29. 
    
30. if __name__ == '__main__':
    
31.     main()
    
32. # => while loop               4.718853999860585
    
33. # => for loop                 3.211570399813354
    
34. # => sum range                0.8658821999561042

复制代码

可以看到，使用内置函数

1. sum

复制代码

替代循环之后，代码的执行效率实现了成倍的增长。
内置函数

1. sum

复制代码

的累加操作实际上也是一种循环，但它由 C 语言实现，而 for 循环中的求和操作是由纯

1. Python

复制代码

代码 s += i 实现的。

1. C > Python

复制代码

。
再拓展一下思维。小时候都听说过童年高斯巧妙地计算 1 到 100 之和的故事。1…100 之和等于 (1 + 100) * 50。这个计算方法同样可以应用到上面的求和操作中。

1. import timeit
   
2. 
   
3. 
   
4. def while_loop(n=100_000_000):
   
5.     i = 0
   
6.     s = 0
   
7.     while i < n:
   
8.         s += i
   
9.         i += 1
   
10.     return s
    
11. 
    
12. 
    
13. def for_loop(n=100_000_000):
    
14.     s = 0
    
15.     for i in range(n):
    
16.         s += i
    
17.     return s
    
18. 
    
19. 
    
20. def sum_range(n=100_000_000):
    
21.     return sum(range(n))
    
22. 
    
23. 
    
24. def math_sum(n=100_000_000):
    
25.     return (n * (n - 1)) // 2
    
26. 
    
27. 
    
28. def main():
    
29.     print('while loop\t\t', timeit.timeit(while_loop, number=1))
    
30.     print('for loop\t\t', timeit.timeit(for_loop, number=1))
    
31.     print('sum range\t\t', timeit.timeit(sum_range, number=1))
    
32.     print('math sum\t\t', timeit.timeit(math_sum, number=1))
    
33. 
    
34. 
    
35. if __name__ == '__main__':
    
36.     main()
    
37. # => while loop               4.718853999860585
    
38. # => for loop                 3.211570399813354
    
39. # => sum range                0.8658821999561042
    
40. # => math sum                 2.400018274784088e-06

复制代码

最终

1. math sum

复制代码

的执行时间约为 2.4e-6，缩短了上百万倍。这里的思路就是，既然循环的效率低，一段代码要重复执行上亿次。
索性直接不要循环，通过数学公式，把上亿次的循环操作变成只有一步操作。效率自然得到了空前的加强。
最后的结论：
实现循环的最快方式—— —— ——就是不用循环
对于 Python 而言，则尽可能地使用内置函数，将循环中的纯 Python 代码降到最低。
当然，内置函数在某些情况下还不是最快的。比如在创建列表的时候，是字面量写法的速度更快
到此这篇关于Python 实现循环最快方式（for、while 等速度对比）的文章就介绍到这了,更多相关Python 实现循环最快方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
参考资料：
The Fastest Way to Loop in Python - mCoding  (https://youtu.be/Qgevy75co8c)
                                                        
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！