Espace de noms

Python stocke ses variable dans un objet appelé espace de noms. Une variable a un nom et est associé à un objet python. Il est important de dissocier le nom de l'objet pour une variable et surtout la variable de l'objet qu'elle représente.

Variable et objet

La quasi-entièreté des langages actuellement sont dit objet. C'est à dire que :

• ce que manipule un programme est appelé objet.
• les variables représentent les objets. On dit aussi parfois qu'une variable est une référence d'un objet.

Ces langages permettent de créer des programmes en utilisant uniquement les deux mécanismes ci-dessous :

Objets

On y reviendra, mais pour l'instant considérez qu'un objet est une structure de donnée générique permettant de gérer tout ce dont à besoin un programme :

• des données
• des fonctions
• des modules
• ...

Tout est objet dans un langage objet.

Variables

Les variables sont des références aux objets. Pour ce faire, on utilise l’opérateur d’affectation = :

variable = objet

A gauche de l’opérateur = se trouve une variable (en gros, quelque chose ne pouvant commencer par un nombre) et à droite un objet. Dans toute la suite du programme, dès que le programme rencontrera le nom, il le remplacera par l'objet.

Il est important de comprendre que l’opérateur d’affectation = n’est pas symétrique. À gauche, des variables et à droite, des objets.

La variable peut être vue comme un nom de l'objet à ce moment du programme. Un objet pourra avoir plein de noms différents au cours de l'exécution du programme, voire plusieurs noms en même temps.

Pour s'y retrouver et avoir une procédure déterministe pour retrouver les objets associés aux variables, voire choisir parmi plusieurs variables de même nom, elles sont regroupées par ensembles — nommés espaces de noms — hiérarchiquement ordonnés.

Espaces de noms

Les espaces de noms sont des objets de python qui nous permettent de lier variables et objets :

• on considère que les objets sont stockés dans l'espace des objets : cet espace est unique
• on accède aux objets via leurs noms, eux même stockés dans des espaces de noms qui sont des objets comme les autres : il y a de nombreux espaces de noms.

Pour chaque espace de noms :

• il ne peut y avoir 2 noms identiques dans un même espace de noms
• à chaque nom est associé un objet
• certains espaces de noms possèdent un parent

Lorsque l'on exécute un programme, un premier espace de noms est créé :

Au départ, il ne contient rien, à part des noms commençant et finissant par __, qui sont utilisés par python.

>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}

A tout moment de l'exécution d'un programme, un espace de noms pourra être créé. En revanche :

On donnera dans la suite de cette partie des exemples qui permettront de mieux comprendre ce processus.

Noms et variables

Prenons plusieurs exemples, qui illustreront les cas principaux.

Association objet et noms

Considérons le programme suivant :

x = 1
y = 1

Exécutons le ligne à ligne :

1. avant l'exécution de la première ligne :
   1. on a un unique espace de noms (global) qui est l'espace courant (en vert sur la figure)
2. on exécute la première ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on crée un objet de type entier
   2. on crée le nom x dans l'espace de noms courant (ici global) et on lui affecte l'objet.
3. on exécute la deuxième ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on crée un objet de type entier
   2. on crée le nom y dans l'espace de noms courant (ici global) et on lui affecte l'objet.

A la fin du programme, il y a 2 objets entiers différents (même si tous les 2 valent 1), dont les noms sont, dans l'espace de noms global, respectivement x et y.

Réutilisation du même nom

x = 1
x = 3

Exécutons le ligne à ligne :

1. avant l'exécution de la première ligne :
   1. on a un unique espace de noms (global) qui est l'espace courant (en vert sur la figure)
2. on exécute la première ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on crée un objet de type entier
   2. on crée le nom x dans l'espace de noms courant (ici global) et on lui affecte l'objet.
3. on exécute la deuxième ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on crée un objet de type entier
   2. on crée le nom x dans l'espace de noms courant (ici global) et on lui affecte l'objet.

Notez que le fait qu'un nom identique existe déjà n'est pas important. Le nouveau nom écrase l'autre :

Le programme a créé 2 objets (un entier valant 1 et un entier valant 3), mais à la fin de la deuxième ligne du programme, seul l'entier valant 3 a un nom (x).

Comme il est maintenant impossible d'accéder à l'entier valant 1 : python le détruit.

Un objet peut avoir plusieurs noms

x = 1
y = x

Exécutons le ligne à ligne :

1. avant l'exécution de la première ligne :
   1. on a un unique espace de noms (global) qui est l'espace courant (en vert sur la figure)
2. on exécute la première ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on crée un objet de type entier
   2. on crée le nom x dans l'espace de noms courant (ici global) et on lui affecte l'objet.
3. on exécute la deuxième ligne. Elle s'exécute ainsi :
   1. on commence à droite du = : on cherche le nom x dans l'espace de noms courant. On le trouve et on lui substitue son objet (un entier valant 1)
   2. on crée le nom x dans l'espace de noms courant (ici global) et on lui affecte l'objet.

Le programme n'a crée qu'un objet (un entier valant 1) et il a deux noms (x et y) :

Les noms ne sont jamais utilisés en tant que tel. Dès qu'ils sont rencontrés, ils sont immédiatement remplacés par les objets qu'ils référencent.

La remarque précédente permet de comprendre mieux ce que fait le code suivant (et pourquoi cela fonctionne) :

x = 1
y = 3
x, y = y, x

Port d'attache d'un espace de noms

Les espaces de noms sont des objets spéciaux qui ne peuvent vivre indépendamment. Il sont toujours rattachés à leur contexte qui est soit :

• le programme principal : c'est le cas de l'espace de nom globals
• une fonction : crée lors de l'appel d'une fonction pour gérer ses paramètre et variables locales.
• un module : les espaces de noms crées après un import

Fonctions

L'exécution d'une fonction est un moment où un espace de noms est créé. Cela se passe selon le processus suivant :

Exécution d'une fonction

def f(x):
   i = 2 * x
   return i + 3

i = 2
x = f(i)

Exécutons le ligne à ligne :

1. avant l'exécution de la première ligne :
   1. on a un unique espace de noms (global) qui est l'espace courant (en vert sur la figure)
2. la ligne 2 définit une fonction de nom f qui est ajouté à l'espace de noms courant.
3. on passe directement à la ligne 5 puisque les lignes 3 et 4 sont le contenu de la fonction.
   1. Cette ligne crée un objet entier (valant 2) et l'affecte au nom i.
4. la ligne 6 est encore une affectation. On commence par trouver l'objet à droite du = c'est le résultat de f(i). Il faut donc exécuter la fonction f pour connaître cet objet :
   1. on cherche l'objet associé à i qui sera le (premier) paramètre de la fonction
   2. on crée un espace de noms qui devient l'espace de noms courant :
      1. l'ancien espace de noms courant devient son parent
   3. on affecte le premier paramètre de f au nom x (le nom du premier paramètre de f lors de sa définition)
      1. les nouveaux noms sont toujours créés dans l'espace de noms courant
   4. on exécute la ligne 2 qui est la première ligne de la fonction f :
      1. on crée un objet entier (valant 4) qui est le résultat de l'opération à droite du = (notez que le nom x est bien défini dans l'espace de noms courant) et on l'affecte au nom i dans l'espace de noms courant
   5. on exécute la ligne 3 :
      1. on crée l'objet résultant de l'opération somme (un entier valant 7)
      2. la fonction est terminée, son espace de noms courant est détruit
      3. l'espace de noms courant devient le parent de l'espace de noms détruit
      4. on rend l'objet résultat de la fonction
   6. la droite du signe = de la ligne 6 est trouvée (c'est un entier valant 7) et il est affecté à la variable x de l'espace de noms courant (qui est à nouveau global)
      1. 
      2. les objets sans nom sont détruits

Espaces de noms parent

L'espace de noms parent sert lorsque l'on cherche un nom qui n'est pas défini dans l'espace de noms courant :

def f(x):
   i = C * x
   return i + 3

C = 2
i = 2
x = f(i)

Lors de l'exécution de la fonction f (instruction de la ligne 7), sa première ligne cherche la variable nommée C. On se trouve dans cet état là :

La variable C n'existe pas dans l'espace de noms courant (celui de f), le programme va alors chercher dans l'espace de noms parent s'il existe. Ici c'est le cas puisque l'espace parent de f est global dans lequel C est défini : le programme ne produit donc pas une erreur et trouve le bon objet.

Import de module

Lorsque l'on importe un fichier, un espace de noms est créé et le fichier entier est lu. Lors de sa lecture, les noms définis sont placés dans cet espace.

import random
from math import log

print(log(random.randrange(1, 43)))

Avant l'exécution de l'instruction print on est dans cet état :

On accède à l'espace de noms du module par la notation pointée : random.randrange signifie le nom randrange dans l'espace de noms de random.

Notation pointée

En python, (pratiquement) tout a un espace de nom. On s'en sert dès qu'on utilise la notation pointée.

on l'a vue pour les modules, mais c'est aussi vrai pour les objets. En considérant le code suivant :

c = "coucou"
c2 = c.uppercase()

Le nom uppercase est défini dans l'espace de noms de la chaîne de caractères "coucou" (en fait, c'est dans sa classe, mais on le verra précisément plus tard).

C'est une notation très puissante ! Il ne faut pas avoir peur de chaîner ces notations. On appelle cela des chaînages :

a.b.c.d()

Signifie :

1. On exécute d qui est dans l'espace de noms de a.b.c
2. c est dans l'espace de noms de a.b
3. b est dans l'espace de noms de a
4. a est dans l'espace de noms courant