Visibilité des variables

10.1 Variables locales d'une fonction

En Python, une variable est accessible (on peut y faire référence) à partir du moment de sa création jusqu'à la fin de son scope — le plus souvent, c'est la fonction où elle est déclarée. Si une variable est déclarée en dehors de toutes les fonctions, elle est appelée globale.

En Python, les scopes des variables définissent le contexte dans lequel les variables sont accessibles pour être utilisées. Les scopes aident à éviter les conflits de noms et à gérer l'accès aux données. Les principaux types de scopes en Python incluent:

Scope local : Les variables créées à l'intérieur d'une fonction existent dans le scope local de cette fonction et ne sont accessibles qu'à l'intérieur d'elle.

Scope des fonctions imbriquées : Si une fonction est définie à l'intérieur d'une autre fonction, ses variables ne sont accessibles qu'à l'intérieur de cette fonction imbriquée.

Scope global : Les variables définies au niveau du script ou du module sont considérées comme globales et sont accessibles depuis n'importe quelle partie du code dans le même module.

Scope intégré : C'est un scope spécial qui inclut tous les objets et fonctions intégrés de Python accessibles par défaut (par exemple, print() et len()).

La règle LEGB

Pour la résolution des variables, Python utilise la règle LEGB qui détermine l'ordre dans lequel l'interpréteur cherche les variables :

• L (Local) — Recherche d'abord dans le scope local.
• E (Enclosed) — Ensuite dans les scopes de toutes les fonctions imbriquées, de la plus proche à la plus extérieure.
• G (Global) — Puis dans le scope global.
• B (Built-in) — Enfin, dans le scope intégré.

Exemples d'utilisation

x = "global"  # Variable globale

def outer():
    y = "outer local"  # Variable locale de la fonction externe
    def inner():
        z = "inner local"  # Variable locale de la fonction imbriquée
        print(x)  # Affiche "global"
        print(y)  # Affiche "outer local"
        print(z)  # Affiche "inner local"
    inner()

outer()

La variable z est accessible uniquement à l'intérieur de la fonction inner().

La variable y est accessible à l'intérieur de la fonction outer() et dans toutes les fonctions déclarées à l'intérieur d'elle.

La variable x est accessible partout dans le fichier actuel (module).

10.2 Accès aux variables globales : global x

Une caractéristique intéressante de Python est que les variables des scopes extérieurs (dans lequel est le scope actuel) ne peuvent être que lues.

En tentant d'écrire quelque chose dans une variable externe, une variable locale avec le même nom sera créée, et l'accès à la variable externe sera perdu.

Exemple :

x = 10

def change_global():
    print(x)  # Cela provoquera une erreur, car x sera considéré comme une variable locale après l'affectation
    x = 20  # Une variable locale x sera créée ici
    print(x)  # Affiche 20 (accès à la variable locale x)
        
change_global()
print(x)  # Affiche 10

Cet exemple ne fonctionne pas et provoquera une erreur UnboundLocalError, car l'interpréteur Python voit d'abord l'assignation x = 20 et considère que x est une variable locale. Cependant, lorsqu'il arrive à la ligne print(x), il ne trouve pas de variable locale x, car elle n'a pas encore été définie.

Cela est fait pour des raisons de sécurité, pour éviter que les variables locales ne modifient accidentellement les variables globales.

L'opérateur global

Si tu veux consciemment modifier la valeur d'une variable globale à l'intérieur d'une fonction, tu peux utiliser l'opérateur global. Cet opérateur te permet d'indiquer explicitement que la modification doit se faire dans la variable globale, et non dans la locale.

Pour modifier la valeur d'une variable globale à l'intérieur d'une fonction, tu dois déclarer cette variable au début de la fonction avec global. Cela donne à la fonction l'accès en écriture à la variable :

x = 10

def change_global():
    global x  # Déclare x comme variable globale
    print(x)  # Affiche 10 (accès à la variable globale x)
    x = 20  # Ici, on assigne une nouvelle valeur à la variable globale x
    print(x)  # Affiche 20 (accès à la variable globale x)

change_global()
print(x)  # Affiche 20

L'utilisation de l'opérateur global permet d'éviter les erreurs et de gérer correctement les variables globales.

Les variables globales peuvent rendre le programme moins prévisible et plus difficile à comprendre, car leurs valeurs peuvent être modifiées n'importe où dans le programme. Cela est particulièrement critique si le programme est grand et développé par une équipe de programmeurs.

Bien que parfois l'utilisation de variables globales soit inévitable, il vaut mieux essayer de minimiser leur utilisation. Au lieu des variables globales, envisage d'utiliser des paramètres de fonctions, des valeurs retournées et des classes pour stocker l'état.

L'utilisation de variables globales peut conduire à des effets secondaires inattendus, rendre le débogage et les tests du code plus difficiles, et réduire sa réutilisabilité. Par conséquent, il est recommandé d'utiliser les variables globales avec précaution et seulement lorsque c'est vraiment nécessaire.

10.3 Accès aux variables non locales : nonlocal

En plus des variables globales et locales, Python propose des variables provenant de scopes intermédiaires. Par exemple, lorsque une fonction est imbriquée dans une autre fonction. Pour travailler avec ces variables, l'opérateur nonlocal est utilisé.

L'opérateur nonlocal permet de travailler avec des variables dans des fonctions imbriquées, en modifiant leurs valeurs dans le scope le plus proche, à l'exclusion des variables globales.

L'opérateur nonlocal aide à éviter la création d'une nouvelle variable locale dans une fonction imbriquée lorsqu'il est nécessaire de modifier une variable définie dans une fonction externe. Sans utiliser nonlocal, les modifications affecteront uniquement la variable locale de la fonction interne, sans influencer la variable dans la fonction externe.

Exemple :

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        return count

    return inner

counter = outer()
print(counter())  # Affiche 1

Voici un exemple plus pratique de l'utilisation de nonlocal pour créer un compteur :

def create_counter():
    count = 0
    
    def increment():
        nonlocal count
        count += 1
        return count
    
    return increment

counter = create_counter()
print(counter())  # Affiche 1
print(counter())  # Affiche 2
print(counter())  # Affiche 3

Cet exemple montre comment nonlocal peut être utilisé dans des scénarios réels pour créer une fonction qui conserve son état entre les appels.