Variables locales et variables globales

Portée des variables (scope) : qu'est-ce que c'est ?

La portée d'une variable (ou "scope" en anglais) définit la partie du code où cette variable est accessible. En d'autres termes, la portée détermine où vous pouvez utiliser une variable et où elle est visible.

En Python, il existe principalement deux types de portée :

• Portée locale : Les variables définies à l'intérieur d'une fonction ont une portée locale. Elles ne sont accessibles qu'à l'intérieur de cette fonction.
• Portée globale : Les variables définies en dehors de toute fonction (au niveau du module) ont une portée globale. Elles sont accessibles depuis n'importe quelle partie du module, y compris à l'intérieur des fonctions.

La portée est un concept fondamental pour comprendre comment les variables sont gérées en Python et pour éviter les erreurs liées à l'accès aux variables.

Variables locales : définies et accessibles à l'intérieur d'une fonction

Une variable locale est une variable qui est définie à l'intérieur d'une fonction. Elle n'est accessible qu'à l'intérieur de cette fonction. Une fois que l'exécution de la fonction est terminée, la variable locale est détruite et sa valeur est perdue.

Exemple :

def ma_fonction():
    x = 10  # x est une variable locale
    print("Valeur de x à l'intérieur de la fonction :", x)

ma_fonction()  # Affiche : Valeur de x à l'intérieur de la fonction : 10

# print(x)  # Ceci lèverait une NameError car x n'est pas accessible ici

Dans cet exemple, `x` est une variable locale à la fonction `ma_fonction`. Elle est créée lorsque la fonction est appelée, et elle est détruite lorsque la fonction se termine. Essayer d'accéder à `x` en dehors de la fonction provoque une erreur `NameError`.

Les paramètres d'une fonction sont également des variables locales à cette fonction.

Variables globales : définies en dehors des fonctions, accessibles partout

Une variable globale est une variable qui est définie en dehors de toute fonction, généralement au début du module (le fichier Python). Elle est accessible depuis n'importe quelle partie du module, y compris à l'intérieur des fonctions.

Exemple :

y = 20  # y est une variable globale

def ma_fonction():
    print("Valeur de y à l'intérieur de la fonction :", y)

ma_fonction()  # Affiche : Valeur de y à l'intérieur de la fonction : 20
print("Valeur de y en dehors de la fonction :", y)  # Affiche : Valeur de y en dehors de la fonction : 20

Dans cet exemple, `y` est une variable globale. Elle est accessible à la fois à l'intérieur et à l'extérieur de la fonction `ma_fonction`.

Il faut faire attention lors de l'utilisation de variables globales, car elles peuvent être modifiées depuis n'importe quelle partie du code, ce qui peut rendre le code plus difficile à comprendre et à déboguer. Il est généralement préférable d'utiliser des variables locales autant que possible, et de passer les données nécessaires aux fonctions en utilisant des arguments.

Accéder et modifier des variables globales à l'intérieur d'une fonction : le mot-clé global

Si vous essayez de modifier une variable globale à l'intérieur d'une fonction, Python créera par défaut une nouvelle variable locale avec le même nom, au lieu de modifier la variable globale. C'est ce qu'on appelle le "shadowing" (masquage).

Exemple (illustrant le shadowing) :

x = 10  # Variable globale

def ma_fonction():
    x = 20  # Crée une nouvelle variable locale x (masque la variable globale)
    print("Valeur de x à l'intérieur de la fonction :", x)  # Affiche 20

ma_fonction()
print("Valeur de x en dehors de la fonction :", x)  # Affiche 10 (la variable globale n'a pas été modifiée)

Si vous voulez réellement modifier une variable globale à l'intérieur d'une fonction, vous devez utiliser le mot-clé `global` pour déclarer explicitement que vous faites référence à la variable globale, et non à une nouvelle variable locale.

Syntaxe :

def ma_fonction():
    global x  # Déclare que x est la variable globale
    x = 20  # Modifie la variable globale x
    print("Valeur de x à l'intérieur de la fonction :", x)

Exemple (modification de la variable globale) :

x = 10  # Variable globale

def ma_fonction():
    global x
    x = 20
    print("Valeur de x à l'intérieur de la fonction :", x)  # Affiche 20

ma_fonction()
print("Valeur de x en dehors de la fonction :", x)  # Affiche 20 (la variable globale a été modifiée)

Il est recommandé d'utiliser le mot-clé `global` avec parcimonie, car un usage excessif de variables globales et de leur modification depuis l'intérieur de fonctions peut rendre le code plus difficile à comprendre et à maintenir.

Bonnes pratiques et recommandations

Voici quelques bonnes pratiques et recommendations concernant les variables locales et globales :

• Privilégiez les variables locales : Utilisez des variables locales autant que possible. Elles rendent le code plus modulaire, plus facile à tester et à déboguer.
• Limitez l'utilisation des variables globales : Utilisez des variables globales uniquement lorsque c'est nécessaire (par exemple, pour des constantes globales ou des données partagées entre plusieurs modules).
• Evitez de modifier les variables globales à l'intérieur des fonctions : Si vous devez modifier une variable globale, faites-le de manière explicite en utilisant le mot-clé `global`, et documentez clairement cette modification.
• Passez les données aux fonctions en utilisant des arguments : Au lieu d'accéder directement à des variables globales, passez les données nécessaires aux fonctions en utilisant des arguments.
• Utilisez des noms de variables clairs et distincts : Evitez d'utiliser le même nom pour une variable locale et une variable globale (même si c'est techniquement possible avec le mot-clé `global`), car cela peut prêter à confusion.
• Utilisez des constantes globales (en majuscules) : Si vous avez des valeurs constantes qui doivent être accessibles globalement, définissez-les comme des variables globales en utilisant des noms en majuscules (par exemple, `PI = 3.14159`).