Ces deux fonctions fournissent principalement un moyen basé sur un dictionnaire d'accéder aux variables locales et globales.

Pour comprendre ces deux fonctions, commençons par comprendre le concept d'espaces de noms en Python. Python utilise ce qu'on appelle un espace de noms pour enregistrer les traces des variables. Un espace de noms n'est qu'un dictionnaire ; ses clés sont les noms des variables, et les valeurs du dictionnaire sont les valeurs de ces variables.

En fait, on peut accéder aux espaces de noms exactement comme à des dictionnaires Python.

Chaque fonction possède son propre espace de noms, appelé espace de noms local, qui enregistre les variables de la fonction, y compris ses paramètres et les variables définies localement. Chaque module possède son propre espace de noms, appelé espace de noms global, qui enregistre les variables du module, y compris les fonctions, les classes, les autres modules importés, les variables et constantes au niveau du module. Il existe également l'espace de noms intégré, auquel tout module peut accéder ; il stocke les fonctions et exceptions intégrées.

Lorsqu'une ligne de code doit utiliser la valeur de la variable x, Python recherche la variable dans tous les espaces de noms disponibles, dans l'ordre suivant :

  • 1. Espace de noms local- Plus précisément la fonction actuelle ou une méthode de la classe. Si la fonction définit une variable locale x, Python utilisera cette variable puis arrêtera la recherche.
  • 2. Espace de noms global- Plus précisément le module actuel. Si le module définit une variable, une fonction ou une classe nommée x, Python utilisera cette variable puis arrêtera la recherche.
  • 3. Espace de noms intégré- Il est global pour chaque module. En dernier recours, Python supposera que x est une fonction ou une variable intégrée.

Si Python ne trouve pas x dans ces espaces de noms, il abandonnera la recherche et lèvera une exception NameError, tout en passantIl n'existe aucune variable nommée 'x'un message comme ceci.

Exemple de la fonction de variable locale locals (locals renvoie un dictionnaire de paires nom/valeur) :

Exemple

def foo(arg, a):
    x = 1
    y = 'xxxxxx'
    for i in range(10):
        j = 1
        k = i
    print(locals())
# Afficher le résultat de l'appel de la fonction
foo(1,2)
#{'k': 9, 'j': 1, 'i': 9, 'y': 'xxxxxx', 'x': 1, 'a': 2, 'arg': 1}

from module importetimport moduleLa différence entre eux. Avec import module, le module lui-même est importé, mais il conserve son propre espace de noms, c'est pourquoi vous devez utiliser le nom du module pour accéder à ses fonctions ou attributs (module.function). Mais avec from module import, vous importez réellement les fonctions et attributs spécifiés d'un autre module dans votre propre espace de noms, c'est pourquoi vous pouvez y accéder directement sans avoir besoin de référencer le module dont ils proviennent.

locals est en lecture seule, globals ne l'est pas.

locals ne peut pas être modifié, globals peut être modifié, pour la raison suivante :

  • locals()En fait, (locals) ne renvoie pas l'espace de noms local ; il renvoie une copie. Donc le modifier modifie la copie, et n'a aucun effet sur les valeurs réelles des variables dans l'espace de noms local.
  • globals() renvoie l'espace de noms global réel, pas une copie, ce qui est complètement opposé au comportement de locals.

Par conséquent, toute modification du dictionnaire renvoyé par globals affectera directement les valeurs des variables globales.

Exemple

#!/usr/bin/env python    

z = 7 # Définir une variable globale
def foo(arg):  
    x = 1  
    print( locals() )  
    print('x=',x)
    locals()['x'] = 2 # Ce qui est modifié est la copie de l'espace de noms local, et il n'y a aucun effet sur les valeurs réelles des variables dans l'espace de noms local.
    print( locals() )
    print( "x=",x )
 
foo(3)  
print( globals() )
print( 'z=',z )
globals()["z"] = 8 # globals() renvoie l'espace de noms global réel, en modifiant la valeur de la variable z
print( globals() )
print( "z=",z )

Le résultat de sortie est:

{'x': 1, 'arg': 3}
x= 1
{'x': 1, 'arg': 3}
x= 1
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 7, 'foo': <function foo at 0x10ae48e18>}
z= 7
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 8, 'foo': <function foo at 0x10ae48e18>}
z= 8

Lien de référence :

https://blog.csdn.net/scelong/article/details/6977867

https://blog.csdn.net/sxingming/article/details/52061630