Les variables globales en Python

Le mot-clé global en Python permet de déclarer qu’une variable modifiée à l’intérieur d’une fonction est globale, c’est-à-dire définie au niveau du script et non uniquement dans la portée locale de la fonction.

Autrement dit, il permet à une fonction de modifier une variable définie en dehors d’elle-même.

Syntaxe du mot-clé global

L’usage de global est très simple :

global nom_de_variable

Ce mot-clé doit être écrit avant toute utilisation ou affectation de la variable dans la fonction.

Pourquoi existe-t-il ?

Dans Python, chaque fonction crée sa propre portée (scope).

Par défaut, une variable qui est assignée dans une fonction est locale à cette fonction. Le mot-clé global sert donc à briser cette barrière volontairement pour accéder à une variable globale.

Exemple rapide

x = 5

def augmenter():
    global x
    x += 1

augmenter()
print(x)  # Affiche 6

Dans cet exemple, sans le mot-clé global, l’opération x += 1 lèverait une erreur car Python croirait que l'on tente d’écrire une nouvelle variable x locale sans l’avoir déclarée.

Si vous oubliez de déclarer global, Python pensera que vous déclarez une nouvelle variable locale, et lèvera une erreur si la variable globale était censée être modifiée.

Portée globale vs portée locale

Limitations et dangers de global

Même si global peut sembler pratique, son usage comporte de nombreux risques.

Par exemple, parlons de la collisions de noms : si plusieurs fonctions modifient la même variable globale, les effets deviennent imprévisibles.

Un autre problème : il devient difficile de savoir d'où vient une valeur modifiée, surtout dans les gros fichiers. Nous avons donc un problème de lisibilité réduite.

Enfin, le code devient fragile. Tout changement local peut avoir un impact à l'échelle du programme.

Par exemple, ceci est un petit piège qui illustre ces dangers :

mode = "dev"

def toggle_mode():
    global mode
    mode = "prod"

def afficher_mode():
    print(f"Le mode est : {mode}")

toggle_mode()
afficher_mode()  # "Le mode est : prod"

Ici, toute la logique du programme peut changer à cause d’une seule ligne dans une fonction. 👀

Les variables globales peuvent agir comme des "bombes à retardement" si elles sont modifiées dans plusieurs endroits sans discipline.

Quelles sont les alternatives à global ?

Heureusement, Python propose plusieurs solutions plus sûres que l’usage de global.

Le passage de paramètres

Plutôt que modifier une variable globale, nous pouvons la passer comme paramètre à une fonction, puis récupérer le résultat :

def ajouter(x):
    return x + 1

total = 0
total = ajouter(total)

Avec une valeur de retour

Il est possible de retourer la nouvelle valeur pour ensuite l'assigner à la variable d’origine :

def activer_debug():
    return True

debug = False
debug = activer_debug()

Avec une classe

Enfin, on peut également créer une classe pour gérer nos variables :

class Compteur:
    def __init__(self):
        self.valeur = 0

    def incrementer(self):
        self.valeur += 1

c = Compteur()
c.incrementer()
print(c.valeur)

C’est plus clair, structuré, évolutif et parfait dans du code maintenu à long terme. 😋

Les différences entre local et nonlocale

Le mot-clé nonlocal permet de modifier une variable définie dans une fonction englobante (non globale). Il est très utile dans des fonctions imbriquées.

Prenons cet exemple pour mieux illustrer notre propos :

def exterieur():
    compteur = 0

    def interieur():
        nonlocal compteur
        compteur += 1
        return compteur

    return interieur()

print(exterieur())  # Résultat : 1

Ici compteur n’est pas global mais il est déclaré dans la fonction parent (exterieur).

nonlocal ne fonctionne que dans des fonctions imbriquées. Si vous essayez de l’utiliser hors contexte, Python lèvera une erreur.

Le mot-clé global dans les modules

Dans un projet Python composé de plusieurs fichiers (main.py, utils.py, etc), le mot-clé global agit uniquement dans le fichier (module) où il est défini.

Voici un petit exemple ! Imaginons que nous avons ces deux fichiers :

config.py

option = "default"

main.py

from config import option

def changer_option():
    global option
    option = "avancé"

changer_option()
print(option)  # ❌ Affiche "avancé", mais ne modifie pas config.option

Ici, option dans main.py est copiée depuis config.py.

L’utilisation de global ne modifie que la variable locale au module main.py.

Questions fréquentes sur global

Peut-on déclarer plusieurs variables globales à la fois ?

Oui, il suffit de les séparer par une virgule :

global x, y, z

Mais attention : cela accroît la complexité et le risque d’erreur. Il vaut mieux rester sobre (sauf le vendredi soir).

Faut-il initialiser une variable globale avant de l’utiliser dans une fonction ?

Oui, idéalement. Même si Python donne cette possibilité de créer une variable globale depuis l’intérieur d’une fonction avec global, cela rend le code moins lisible. C'est bien mieux d’initialiser toutes les variables globales au début du script.

Quelle est la différence entre global et globals() ?

C'est assez simple à comprendre : global est un mot-clé utilisé dans une fonction pour signaler que vous voulez modifier une variable globale. Alors que de son côté, globals() est une fonction qui retourne le dictionnaire de toutes les variables globales du module.

Comment apprendre Python ?

En suivant une bonne formation ! 🥸