Les mots-clés global et nonlocal

Le mot-clé global : modifier une variable globale à l'intérieur d'une fonction

Comme nous l'avons vu précédemment, le mot-clé `global` permet de modifier une variable globale à l'intérieur d'une fonction. Sans le mot-clé `global`, Python créerait une nouvelle variable locale avec le même nom, masquant ainsi la variable globale (shadowing).

Syntaxe :

def ma_fonction():
    global x  # Déclare que x fait référence à la variable globale
    x = 20  # Modifie la variable globale x

Exemple complet :

x = 10  # Variable globale

def modifier_global():
    global x
    x = 20

print("Avant :", x)  # Affiche 10
modifier_global()
print("Après :", x)  # Affiche 20

Il est important de noter que l'utilisation de `global` modifie la variable globale elle-même. Toutes les parties du code qui utilisent cette variable globale seront affectées par la modification.

L'utilisation de `global` doit être limitée autant que possible, car elle peut rendre le code plus difficile à comprendre et à maintenir. Il est généralement préférable de passer les variables globales aux fonctions en tant qu'arguments, et de retourner les valeurs modifiées.

Le mot-clé nonlocal : modifier une variable dans une portée englobante (mais non globale)

Le mot-clé `nonlocal` est utilisé dans les fonctions imbriquées (fonctions définies à l'intérieur d'autres fonctions). Il permet de modifier une variable qui n'est ni locale à la fonction courante, ni globale, mais qui se trouve dans la portée d'une fonction englobante.

Syntaxe :

def fonction_externe():
    x = 10  # Variable locale à fonction_externe

    def fonction_interne():
        nonlocal x  # Déclare que x fait référence à la variable de fonction_externe
        x = 20  # Modifie la variable x de fonction_externe

    fonction_interne()
    print("Valeur de x dans fonction_externe :", x)  # Affiche 20

Dans cet exemple, `x` est une variable locale à `fonction_externe`. La fonction `fonction_interne` est définie à l'intérieur de `fonction_externe`. Le mot-clé `nonlocal` permet à `fonction_interne` de modifier la variable `x` de `fonction_externe`.

Si nous n'avions pas utilisé `nonlocal x`, une nouvelle variable locale `x` aurait été créée dans `fonction_interne`, masquant la variable `x` de `fonction_externe`.

Le mot-clé `nonlocal` ne peut pas être utilisé pour modifier des variables globales. Il ne s'applique qu'aux variables des portées englobantes (ni locales, ni globales).

Différences entre global et nonlocal : portée et cas d'utilisation

Voici un résumé des différences entre `global` et `nonlocal` :

• `global` : Permet de modifier une variable globale (définie au niveau du module) à l'intérieur d'une fonction.
• `nonlocal` : Permet de modifier une variable qui n'est ni locale ni globale, mais qui se trouve dans la portée d'une fonction englobante (dans le cas de fonctions imbriquées).

Cas d'utilisation typiques :

• `global` : Modification de constantes globales (rare), ou de variables partagées entre plusieurs modules (déconseillé en général).
• `nonlocal` : Création de fermetures (closures) ou de fonctions qui conservent un état entre les appels (plus avancé).

Exemple illustrant la différence :

x = 10  # Variable globale

def fonction_externe():
    x = 20  # Variable locale à fonction_externe

    def fonction_interne():
        nonlocal x
        x = 30  # Modifie la variable x de fonction_externe

    def fonction_interne2():
        global x
        x = 40  # Modifie la variable globale x

    fonction_interne()
    print("x dans fonction_externe après fonction_interne :", x)  # Affiche 30

    fonction_interne2()
    print("x dans fonction_externe après fonction_interne2 :", x) # Affiche 30 (la variable locale n'est pas affectée)

fonction_externe()
print("x global après appel de fonction_externe :", x)  # Affiche 40 (la variable globale a été modifiée)

Bonnes pratiques et alternatives

L'utilisation de `global` et `nonlocal` doit être limitée, car elle peut rendre le code plus difficile à comprendre et à maintenir. Voici quelques alternatives et bonnes pratiques :

• Préférez passer les variables en arguments : Au lieu de modifier des variables globales ou non locales, passez les variables nécessaires aux fonctions en tant qu'arguments.
• Retournez les valeurs modifiées : Si une fonction doit modifier une variable, retournez la nouvelle valeur et affectez-la à la variable d'origine à l'extérieur de la fonction.
• Utilisez des classes et des objets : Pour encapsuler l'état et le comportement, utilisez des classes et des objets plutôt que des fonctions imbriquées et des variables non locales.
• Utilisez `global` et `nonlocal` avec parcimonie : Si vous devez les utiliser, documentez clairement leur utilisation et expliquez pourquoi vous ne pouvez pas utiliser d'alternatives plus simples.
• Comprenez bien la portée des variables : Assurez-vous de bien comprendre la différence entre les variables locales, globales et non locales avant d'utiliser `global` et `nonlocal`.

En suivant ces recommandations, vous écrirez un code Python plus propre, plus lisible et plus facile à maintenir.