为什么 Python 中的 range() 循环比使用 while 循环更快？

Question

有一天，我在做一些 Python 基准测试，发现了一些有趣的东西。下面是两个循环，它们或多或少执行相同的操作。循环 1 的执行时间大约是循环 2 的两倍。

循环1：

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

循环2：

for n in range(0,100000000):
    pass

为什么第一个循环慢得多？我知道这是一个微不足道的例子，但它激起了我的兴趣。 range() 函数有什么特别之处，使其比以相同方式递增变量更有效吗？

Answer 1

看看Python字节码的反汇编，你可能会有更具体的想法

使用 while 循环：

1           0 LOAD_CONST               0 (0)
            3 STORE_NAME               0 (i)

2           6 SETUP_LOOP              28 (to 37)
      >>    9 LOAD_NAME                0 (i)              # <-
           12 LOAD_CONST               1 (100000000)      # <-
           15 COMPARE_OP               0 (<)              # <-
           18 JUMP_IF_FALSE           14 (to 35)          # <-
           21 POP_TOP                                     # <-

3          22 LOAD_NAME                0 (i)              # <-
           25 LOAD_CONST               2 (1)              # <-
           28 INPLACE_ADD                                 # <-
           29 STORE_NAME               0 (i)              # <-
           32 JUMP_ABSOLUTE            9                  # <-
      >>   35 POP_TOP
           36 POP_BLOCK

循环体有 10 个操作

使用范围：

1           0 SETUP_LOOP              23 (to 26)
            3 LOAD_NAME                0 (range)
            6 LOAD_CONST               0 (0)
            9 LOAD_CONST               1 (100000000)
           12 CALL_FUNCTION            2
           15 GET_ITER
      >>   16 FOR_ITER                 6 (to 25)        # <-
           19 STORE_NAME               1 (n)            # <-

2          22 JUMP_ABSOLUTE           16                # <-
      >>   25 POP_BLOCK
      >>   26 LOAD_CONST               2 (None)
           29 RETURN_VALUE

循环体有3个op

运行C代码的时间比intepretor短很多，可以忽略不计。

Answer 2

range()

在 C 中实现，而

i += 1

是解释型的。

使用

xrange()

可以使处理大量数据的速度更快。从 Python 3.0 开始

range()

与之前相同

xrange()

。

Answer 3

必须说的是，while 循环中进行了大量的对象创建和销毁。

i += 1

等同于：

i = i + 1

但是因为Python ints是不可变的，所以它不会修改现有的对象；相反，它创造了一个具有新价值的全新物体。基本上是：

i = new int(i + 1)   # Using C++ or Java-ish syntax

垃圾收集器也会有大量的清理工作要做。 “对象创建是昂贵的”。

更新： 有趣的。现在使用 3.11，对于低迭代次数，

for

实际上比

while

慢：

迭代	while循环	for循环
1	55	109
5	23	26
10	18	16
1_000	18	9.2
1_000_000	18	11

（纳秒/迭代，Win 10，CPython 3.11.4，ipython %timeit）

两者在 ns/迭代超过 100 次时都相当稳定。

Answer 4

我认为这里的答案比其他答案建议的更微妙，尽管它的要点是正确的：for循环更快，因为更多的操作发生在C中，而更少的操作发生在Python中。

更具体地说，在 for 循环情况下，C 中发生的两件事在 while 循环中由 Python 处理：

1. 在 while 循环中，比较

   i < 100000000

   在 Python 中执行，而在 for 循环中，作业被传递给

   range(100000000)

   的迭代器，后者在 C 中内部执行迭代（并因此进行边界检查）。

2. 在 while 循环中，循环更新

   i += 1

   发生在 Python 中，而在 for 循环中，用 C 编写的

   range(100000000)

   迭代器再次执行

   i+=1

   （或

   ++i

   ）。

我们可以看到，正是这两者的结合，通过手动将它们添加回去来查看差异，使得 for 循环变得更快。

import timeit

N = 100000000


def while_loop():
    i = 0
    while i < N:
        i += 1


def for_loop_pure():
    for i in range(N):
        pass


def for_loop_with_increment():
    for i in range(N):
        i += 1


def for_loop_with_test():
    for i in range(N):
        if i < N: pass


def for_loop_with_increment_and_test():
    for i in range(N):
        if i < N: pass
        i += 1


def main():
    print('while loop\t\t', timeit.timeit(while_loop, number=1))
    print('for pure\t\t', timeit.timeit(for_loop_pure, number=1))
    print('for inc\t\t\t', timeit.timeit(for_loop_with_increment, number=1))
    print('for test\t\t', timeit.timeit(for_loop_with_test, number=1))
    print('for inc+test\t', timeit.timeit(for_loop_with_increment_and_test, number=1))


if __name__ == '__main__':
    main()

我尝试使用数字 100000000 作为文字常量，并将其作为变量

N

，这将是更典型的。

# inline constant N
while loop      3.5131139
for pure        1.3211338000000001
for inc         3.5477727000000003
for test        2.5209639
for inc+test    4.697028999999999

# variable N
while loop      4.1298240999999996
for pure        1.3526357999999998
for inc         3.6060175
for test        3.1093069
for inc+test    5.4753364

如您所见，在这两种情况下，

while

时间非常接近

for inc+test

和

for pure

的差值。另请注意，在我们使用

N

变量的情况下，

while

会额外减慢重复查找

N

的值，但

for

不会。

这种微不足道的修改可以导致超过 3 倍的代码加速，这真的很疯狂，但这就是适合你的 Python。当你根本可以在循环上使用内置函数时，甚至不要让我开始......

Answer 5

因为你在解释器中更频繁地运行用 C 编写的代码。即 i+=1 在 Python 中，速度很慢（相对而言），而 range(0,...) 是一个 C 调用，for 循环也主要在 C 中执行。

Answer 6

Python 的大多数内置方法调用都是作为 C 代码运行的。必须解释的代码要慢得多。就内存效率和执行速度而言，差异是巨大的。 python 内部已经优化到了极致，最好利用这些优化。