Why is looping over range() in Python faster than using a while loop?

see the disassembly of python byte code, you may get a more concrete idea

use while loop:

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

The loop body has 10 op

use range:

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

The loop body has 3 op

The time to run C code is much shorter than intepretor and can be ignored.

range() is implemented in C, whereas i += 1 is interpreted.

Using xrange() could make it even faster for large numbers. Starting with Python 3.0 range() is the same as previously xrange().

It must be said that there is a lot of object creation and destruction going on with the while loop.

i += 1

is the same as:

i = i + 1

But because Python ints are immutable, it doesn't modify the existing object; rather it creates a brand new object with a new value. It's basically:

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

The garbage collector will also have a large amount of cleanup to do."Object creation is expensive".