Espaces de noms et portée des variables en Python : Comprendre les noms, liaisons et portées

Espaces de noms et portée des variables en Python

Explorez comment les noms, espaces de noms et portées de variables fonctionnent en Python, avec des exemples clairs et des bonnes pratiques.

Qu'est-ce qu'un nom en Python ?

Dans « The Zen of Python » (import this), la dernière ligne dit : « Les espaces de noms sont une idée géniale — faisons-en plus ! » Alors, que sont ces espaces de noms ? D'abord, définissons un nom.

Un nom, ou identifiant, est une étiquette qui référence un objet. Tout en Python est un objet, et un nom fournit un moyen pratique d'y accéder.

Par exemple, quand nous exécutons a = 2, l'entier 2 est stocké en mémoire et a devient sa référence. La fonction intégrée id() retourne l'adresse mémoire d'un objet.

# Note : Vos valeurs id peuvent différer
a = 2
print('id(2) =', id(2))
print('id(a) =', id(a))

Sortie

id(2) = 9302208
id(a) = 9302208

Les deux noms pointent vers le même objet, donc leurs valeurs id() correspondent. Voyons ce qui se passe quand nous rebindons a :

# Note : Vos valeurs id peuvent différer
a = 2
print('id(a) =', id(a))
a = a + 1
print('id(a) =', id(a))
print('id(3) =', id(3))
b = 2
print('id(b) =', id(b))
print('id(2) =', id(2))

Sortie

id(a) = 9302208
id(a) = 9302240
id(3) = 9302240
id(b) = 9302208
id(2) = 9302208

Quand a = a + 1 est exécuté, un nouvel objet 3 est créé, et a le référence maintenant. Notez que id(a) et id(3) sont identiques. L'assignation suivante b = 2 lie simplement b à l'objet existant 2, évitant le stockage en double.

Cette liaison dynamique de noms est ce qui rend Python flexible : un seul identifiant peut pointer vers des valeurs de n'importe quel type — y compris des fonctions.

def printHello():
    print("Hello")
a = printHello
a()

Sortie

Hello

L'identifiant a référence maintenant la fonction printHello, que nous pouvons invoquer directement.

---

Qu'est-ce qu'un espace de noms ?

Un espace de noms est un mappage de noms vers des objets. Considérez-le comme un dictionnaire qui contient chaque identifiant que vous avez défini ainsi que son objet associé.

Python prend en charge plusieurs espaces de noms simultanés, chacun isolé des autres. L'interpréteur crée un espace de noms global contenant tous les noms intégrés qui persiste pendant la vie de la session. Chaque module obtient son propre espace de noms global, et chaque définition de fonction ou de classe introduit un nouvel espace de noms local.

---

Portée des variables en Python

Alors que les espaces de noms existent, la portée détermine où un nom peut être accédé sans qualification.

À tout moment, un programme a au moins trois portées imbriquées :

1. La portée locale de la fonction en cours d'exécution.
2. La portée globale du module.
3. La portée intégrée qui est toujours disponible.

Lorsqu'un nom est référencé à l'intérieur d'une fonction, Python recherche d'abord l'espace de noms local, puis le global, et enfin l'espace de noms intégré. Si une fonction en contient une autre, la plus interne introduit une nouvelle portée imbriquée.

---

Exemple : Interaction portée et espace de noms

Considérez le code suivant :

def outer_function():
    b = 20
    def inner_func():
        c = 30
    a = 10

Ici, a vit dans l'espace de noms global du module. La variable b est locale à outer_function, et c appartient à l'espace de noms local imbriqué de inner_func.

À l'intérieur de inner_func, c est local, b est non-local, et a est global. Vous pouvez lire et écrire c, mais seulement lire b et a à moins de les déclarer explicitement avec global ou nonlocal.

Voici une illustration plus concrète :

def outer_function():
    a = 20
    def inner_function():
        a = 30
        print('a =', a)
    inner_function()
    print('a =', a)
a = 10
outer_function()
print('a =', a)

La sortie démontre trois liaisons distinctes de a :

a = 30
a = 20
a = 10

Pour forcer toutes les assignations vers le a global, utilisez le mot-clé global :

def outer_function():
    global a
    a = 20
    def inner_function():
        global a
        a = 30
        print('a =', a)
    inner_function()
    print('a =', a)
a = 10
outer_function()
print('a =', a)

La sortie reflète maintenant un unique a global :

a = 30
a = 30
a = 30

Ces exemples illustrent comment les règles d'espace de noms et de portée de Python régissent la visibilité et la mutation des variables.