Pourquoi l'encapsulation de fonctions améliore-t-elle la vitesse d'exécution du code Python ?

Amélioration de la vitesse d'exécution du code grâce à l'encapsulation de fonctions

Lors de l'exécution du code Python, on remarque que le code contenu dans une fonction s'exécute beaucoup plus rapidement que le même code exécuté en dehors d’une fonction. Pour étudier ce phénomène, analysons un simple extrait de code :

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

Ce code s'exécute en environ 1,8 seconde lorsqu'il est exécuté dans la fonction main(). Cependant, si la boucle for est placée en dehors de la fonction, le temps d'exécution augmente jusqu'à environ 4,5 secondes :

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

La raison de cette disparité de performances réside dans la manière dont Python compile le code. Lorsque le code est exécuté dans une fonction, il est compilé sous une forme appelée bytecode. Le bytecode est une séquence d'instructions que la machine virtuelle Python (PVM) exécute plus efficacement que le code Python d'origine.

L'examen du bytecode de l'extrait de code à l'aide du module dis révèle la différence :

Au sein d'une fonction :

  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        

En dehors d'une function :

  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        

La différence cruciale réside dans les instructions aux lignes 16 et 19. Dans la fonction, la variable i est stockée à l'aide de STORE_FAST, qui est optimisé pour les variables locales. Cependant, en dehors de la fonction, i est stocké à l'aide de STORE_NAME, qui nécessite plus de calculs puisqu'il concerne des variables globales.

Par conséquent, en encapsulant le code dans une fonction, nous optimisons le stockage et la récupération des variables, ce qui entraîne dans des temps d'exécution plus rapides.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!