Performance Python : Variables locales vs globales (CPython)

Savez-vous qu'il y a une différence entre la manière dont sont accédées les variables globales et les variables locales aux fonctions en Python ?

Tout part d'une comparaison de code : la mesure d'exécution d'un code global et du même code dans une fonction.

Une observation simple

En formation sur les décorateurs, le premier exercice que je propose est de créer un décorateur permettant de suivre la durée d'exécution sur la base du code suivant :

import time

start = time.perf_counter()

for x in range(1_000_000):
    y = x ** 2

end = time.perf_counter()

print(f'{end - start}, secondes se sont écoulées')

Ceci conduit à la proposition suivante :

import time

def time_it(func):
    def wrapper():
        start = time.perf_counter()
        func()
        end = time.perf_counter()

        print(f'{end - start}, secondes se sont écoulées')

    return wrapper

@time_it
def pow_2():
    for x in range(1_000_000):
        y = x ** 2

pow_2()

Et quand on y prête attention, on remarque que le code avec le décorateur a un temps d’exécution plus rapide que le code initial !

Quelle est cette diablerie ?

Le décorateur n'accélère évidemment pas l’exécution. Il y a une autre différence importante : le premier code est à la racine du script et s'exécute donc au niveau global du module, le second, à l'intérieur d'une fonction.

Accès aux variables locales et globales en Python

Ceci illustre une caractéristique de Python : les variables locales d’une fonction sont beaucoup plus rapides d’accès que les variables utilisées au niveau global. Les variables globales vivent dans l’espace de noms du module, qui est essentiellement un dictionnaire. Pour les variables locales aux fonctions, CPython réserve directement des emplacements dans le frame de la fonction. Leur lecture/écriture est donc nettement moins coûteuse.

Dans la pratique, la lecture et l'écriture de variables globales passent par les instructions LOAD_NAME et STORE_NAME qui recherchent un nom ce qui peut nécessiter de passer par plusieurs contextes. Pour les variables locales, il s'agit de LOAD_FAST et STORE_FAST qui utilisent un index numérique direct sur la pile d'exécution.

Qu'en est-il des paramètres de fonctions ?

Les paramètres des fonctions sont eux aussi des variables locales à la fonction. Sur un code comme :

def pow_2(iterations:int):
    for x in range(iterations):
        y = x ** 2

la différence est dans leur mode d'initialisation :

iterations reçoit sa valeur lors de l'initialisation de la fonction
x et y reçoivent leurs valeurs lors de l'exécution de la fonction

Et tous trois sont des variables locales même si la valeur passée à iterations peut avoir été créée au niveau global.

Est-ce que c'est un critère pour la manière d'écrire du code ?

En toute honnêteté, pas vraiment…

La différence de performance du code dans cet exemple est significative du fait qu'il y a de nombreux accès aux variables. Ajoutez par exemple quelques I/O et le gain est négligeable.

Mais surtout, il est question dans le premier exemple d'un code d'exercice où toute la logique est à la racine, sans aucune organisation. Un code réel s'organise naturellement avec des fonctions et une répartition cohérente des variables.

La connaissance de ce fonctionnement de CPython ne fait que renforcer l'incitation à organiser son code en fonctions. Et bien entendu d'aller vers des fonctions pures en particulier en évitant toute interaction en dehors de sa portée.

Ajoutez que la différence de performance dépend du système et de la version de Python. La conséquence est donc qu'il est intéressant de connaître cette différence, mais elle n'est pas un critère d'organisation du code.

En résumé

Python et en particulier CPython gère différemment l'accès aux variables globales et locales. Les premières sont accédées par leur nom et recherchées dans un dictionnaire sur plusieurs contextes alors que les secondes sont accédées par index sur une pile d'exécution rendant leur accès beaucoup plus rapide.