Les fonctions locals et globals

Accrochez-vous, dans cette vidéo, on va faire un peu d'introspection avec deux fonctions : les fonctions globals() et locals() qui vont nous permettre d'afficher à n'importe quel endroit l'espace global et l'espace local.

Ces fonctions vont tout simplement nous retourner un objet de type dictionnaire qui va avoir d'un côté le nom des objets, et de l'autre côté leur valeur.

globals()

def foo():
    b = 5

a = 5
foo()
print(globals())

Si je lance le script ci-dessus, le print(globals()) au niveau de mon espace global affiche un dictionnaire avec beaucoup d'éléments puisque de base, dans l'espace global, il y a pas mal de choses qui sont définies.

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fbdf55b8df0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/thibh/code.py', '__cached__': None, 'foo': <function foo at 0x7fbdf55baf70>, 'a': 5}

On a par exemple la variable spéciale __name__ qui est égale à la chaîne de caractères __main__ quand on exécute directement notre script, on a la variable __file__ qui nous permet de récupérer le chemin complet vers le script, et d'autres choses du genre comme les __builtins__. On retrouve également ce que l'on a défini dans l'espace global de notre script, donc notre fonction foo() qui est bien définie, et on retrouve de la même façon notre variable a et la valeur 5 qui est associée à cette variable.

locals()

Si on remplace print(globals()) par print(locals()) dans notre espace global, on obtient le même dictionnaire. Vous pouvez tester l'égalité comme ceci :

print(locals() == globals())

On a bien True qui est retourné, ce qui est tout à fait normal puisqu'on est dans l'espace global : l'espace local est aussi l'espace global.

Par contre, si je fais un print de locals() dans la fonction foo(), on va retrouver uniquement ce qui est défini dans l'espace local de la fonction.

def foo():
    b = 5
    print(locals())

a = 5
foo()

Si je lance le script, on obtient un dictionnaire beaucoup plus restreint qui contient le nom de la variable b et la valeur associée 5, qui représente tout ce qui est disponible uniquement à l'intérieur de la fonction foo().

Si j'essaye de faire un print de b en dehors de la fonction, dans l'espace global, cela ne fonctionne pas puisque cette variable n'est accessible que dans l'espace local de la fonction foo().

Si par contre dans la fonction je fais un print de globals(), cette fois-ci on va retrouver les variables de l'espace global.

def foo():
    b = 5
    print(globals())

a = 5
foo()

On va ainsi retrouver le __name__, le __file__, notre fonction foo() et également la variable a que l'on a définie en dehors de notre fonction.

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fd3a8db8df0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/thibh/code.py', '__cached__': None, 'foo': <function foo at 0x7fd3a8dbaf70>, 'a': 5}

Ce qu'il faut bien comprendre, c'est que Python va fonctionner déjà en local, et ensuite en global.

def foo():
    b = 5
    print(globals())
    print(b)

a = 5
foo()

Dans l'exemple ci-dessus, lorsque je fais un print(b) dans la fonction foo(), Python va regarder dans les variables locales si b existe, et si c'est le cas, il va utiliser la valeur associée à cette variable. S'il ne trouve pas cette variable b dans l'espace local, il va aller chercher dans l'espace global. C'est pour ça que l'on peut accéder à des variables qui sont définies dans l'espace global, dans la fonction foo().

def foo():
    b = 5
    print(locals())
    print(a)

a = 5
foo()

Dans le script ci-dessus, si je fais un print(a) dans la fonction foo(), Python va déjà regarder dans l'espace local, qui ne contient uniquement que la variable b, et se rendre compte que dans son dictionnaire local, il n'a pas de variable qui s'appelle a. Il va regarder dans globals() s'il a quelque chose qui s'appelle a, et c'est bien le cas puisqu'on a a qui est égale à 5. On n'aura donc pas d'erreur et on va bien afficher la valeur associée à la variable a.

Pour résumer

Je trouve assez intéressant de pouvoir utiliser ces deux fonctions locals() et globals() quand vous n'êtes pas trop sûr de ce que vous avez défini à l'intérieur de vos différents espaces.

On peut passer des heures à vous expliquer les espaces, la portée des variables, mais c'est finalement mieux si vous comprenez bien ce que fait Python et comment il fonctionne.

Python va d'abord regarder dans l'espace local et s'il trouve quelque chose, il l'affiche. S'il ne le trouve pas, il va regarder dans l'espace global et s'il le trouve, il l'affiche. Et s'il n'est ni dans l'espace local, ni dans l'espace global, on obtient une erreur.

Deux derniers petits exemples

def foo():
    b = 5
    print(c)

a = 5
foo()

Dans le script ci-dessus, on va avoir une erreur avec la ligne print(c) puisque Python va regarder dans l'espace local, c n'existe pas, il va regarder dans l'espace global, c n'existe pas non plus, et donc on aura une erreur.

def foo():
    b = 5
    c = 10

a = 5
foo()
print(c)

Dans cet autre exemple, la variable c qui est égale à 10 est définie dans la fonction foo(), et à la ligne contenant print(c), Python va regarder dans l'espace local qui correspond à l'espace global. Dans l'espace local, on a défini la variable a, la fonction foo() et toutes les variables spéciales comme __name__ ou __file__, mais il n'y a pas de variable c. Donc Python ne va pas pouvoir aller chercher dans l'espace local d'une fonction. Il aura juste accès à l'espace local et ensuite l'espace global qui, à ce niveau du script, sont les mêmes.

Entrainez-vous

N'hésitez pas à revoir cette vidéo une deuxième fois, il y a beaucoup de choses qui ont été abordées. Essayez également de votre côté de créer des variables et essayez de les afficher. Vous devez vraiment vous habituer à manipuler ces différents espaces et à comprendre ce que Python vous permet de faire, que ce soit dans l'espace local d'une fonction ou l'espace global de votre script.