Heim >Backend-Entwicklung >Python-Tutorial >Warum ist Python-Code schneller, wenn er innerhalb einer Funktion ausgeführt wird?

Warum ist Python-Code schneller, wenn er innerhalb einer Funktion ausgeführt wird?

DDD
DDDOriginal
2024-11-15 13:17:03491Durchsuche

Why is Python Code Faster When Executed Inside a Function?

Why Does Python Code Execute More Swiftly in Functions?

Consider the Python code snippet below, which executes a loop 100 million times.

def main():
    for i in range(10**8):
        pass
main()

When measured in Linux using the time function, this code runs remarkably swiftly:

real    0m1.841s
user    0m1.828s
sys     0m0.012s

Curiously, if the for loop is executed without being enclosed within a function:

for i in range(10**8):
    pass

Its execution time increases considerably:

real    0m4.543s
user    0m4.524s
sys     0m0.012s

Why does this discrepancy occur?

Inside a Function

Examining the bytecode reveals the following when the code is within a function:

  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (i)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE        

Outside a Function

In contrast, when the code is executed at the top level, the bytecode is as follows:

  1           0 SETUP_LOOP              20 (to 23)
              3 LOAD_NAME                0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_NAME               1 (i)

  2          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               2 (None)
             26 RETURN_VALUE        

The Crux of the Issue

The distinction lies in the use of STORE_FAST versus STORE_NAME. STORE_FAST is employed when the variable (in this case, i) is a local variable (within a function), whereas STORE_NAME is utilized when the variable is a global variable (outside a function). The former is significantly more efficient.

This can be explained by the fact that when a variable is declared as local, the interpreter can optimize the code to use a specific memory location for that variable. However, when a variable is declared as global, the interpreter must search through the entire global scope to find the variable, which is a more time-consuming process.

Das obige ist der detaillierte Inhalt vonWarum ist Python-Code schneller, wenn er innerhalb einer Funktion ausgeführt wird?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn