Dans ce didacticiel, nous découvrirons l'espace de noms en Python, la structure utilisée pour organiser les noms symboliques attribués aux objets dans un programme Python, pourquoi l'espace de noms est important et comment nous pouvons les utiliser dans notre programme Python. Faisons une brève introduction à un espace de noms.
Qu’est-ce que l’espace de noms ?
En Python, un moyen de donner à chaque objet un nom unique consiste à utiliser un espace de noms. Les variables et les méthodes sont des exemples d'objets en Python. En d’autres termes, il s’agit d’une collection de noms symboliques connus et de détails sur la chose à laquelle chaque nom fait référence. Un nom peut être considéré comme une clé dans un dictionnaire et les objets sont les valeurs d'un espace de noms. Nous devrions le comprendre avec un véritable modèle : un espace de noms ressemble à un nom de famille. S'il y a plusieurs noms « Peter » dans la classe, il peut être difficile de localiser un nom « Peter » ; cependant, lorsque nous demandons spécifiquement « Peter Warner » ou « Peter Cummins », dans une classe, il n'est pas courant que plusieurs élèves portent le même prénom et le même nom.
L'interpréteur Python peut mieux comprendre la méthode ou la variable exacte dans le code grâce à l'espace de noms. Par conséquent, son nom contient des informations supplémentaires, notamment Espace (lié à la portée) et Nom, qui désigne un identifiant unique.
En Python, il existe quatre types d'espaces de noms indiqués ci-dessous.
- Intégré
- Mondial
- Enfermant
- Locale
Comme ces différents espaces de noms ont une durée de vie, l'interpréteur Python crée des espaces de noms si nécessaire et les supprime lorsqu'ils ne sont plus nécessaires.
Comprenons les différents types d'espace de noms en Python.
L'espace de noms intégré
Comme son nom l'indique, il contient les noms prédéfinis de tous les objets intégrés de Python déjà disponibles dans Python. Listons ces noms avec la commande suivante.
Ouvrez le terminal Python et tapez la commande suivante.
Commande -
dir(__builtins__)
Sortir:
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
L'espace de noms intégré créé par l'interpréteur Python lors de son démarrage. Ceux-ci se terminent lorsque l'interpréteur Python se termine.
L'espace de noms global
L'espace de noms global se compose de tous les noms en Python à n'importe quel niveau du programme principal. Il est créé lorsque le corps principal s'exécute et reste en existence jusqu'à la fin de l'interprète.
L'interpréteur Python crée un espace de noms global pour tout module que notre Python charge avec l'instruction import. Pour obtenir plus d'informations, visitez notre module Python.
Les espaces de noms locaux et englobants
Les espaces de noms locaux sont utilisés par la fonction ; Lorsque la fonction est exécutée, l'interpréteur Python crée un nouvel espace de noms. Les espaces de noms locaux continuent d'exister une fois l'exécution de la fonction terminée. La capacité peut également comprendre une autre capacité. Comme indiqué ci-dessous, nous pouvons définir une fonction dans une autre.
Exemple -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
Dans le modèle ci-dessus, la capacité g() est caractérisée à l'intérieur de la collection f(). Nous avons appelé la fonction g() dans la fonction f() et la fonction principale f(). Voyons comment fonctionne la fonction ci-dessus :
- Python crée un nouvel espace de noms pour f() lorsque nous l'appelons.
- De même, le f() appelle g(), g() obtient son propre espace de noms différent.
- L'espace de noms local g() a été créé pour l'espace de noms englobant, f().
Chacun de ces espaces de noms se termine lorsque la fonction est terminée.
Portée de l'objet/de la variable
Le terme « portée » spécifie à quelle région de codage d'un objet Python particulier il est possible d'accéder. Chaque objet et variable a une portée dans le programme à partir de laquelle nous pouvons accéder à cette variable. Par exemple, une variable de fonction n'est accessible que dans la fonction. Examinons l'illustration suivante :
Exemple -
def scope_func(): print('Inside scope_func') def scope_inner_func(): var = 20 print('Inside inner function, value of var:',var) scope_inner_func() print('Try printing var from outer function: ',var) scope_func()
Sortir:
Inside scope_func Inside inner function, value of var: 20 Traceback (most recent call last): File 'd:/Python Project/listproblems.py', line 343, in scope_func() File 'd:/Python Project/listproblems.py', line 342, in scope_func print('Try printing var from outer function: ',var) NameError: name 'var' is not defined
Dictionnaires d'espaces de noms Python
Dans le didacticiel précédent, nous avons expliqué comment les espaces de noms ressemblent à des dictionnaires, avec des clés représentant les noms d'objets et des valeurs représentant les objets réels. En tant que dictionnaires, Python utilise à la fois des espaces de noms globaux et locaux. L'accès aux dictionnaires d'espaces de noms globaux et locaux est rendu possible par les méthodes globals() et locals() de Python.
La méthode globals()
La méthode globals() renvoie une référence au dictionnaire d'espace de noms global actuel. Nous pouvons l'utiliser pour accéder aux objets dans l'espace de noms global. Voyons l'exemple ci-dessous.
Exemple -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Comme nous pouvons le constater, il existe de nombreuses entrées intégrées dans globales() méthode. Cela peut différer selon votre système d'exploitation et votre version de Python. Définissons maintenant la variable globale et observons les différences.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Après l'affectation de a = 20, une nouvelle variable globale affectée au dictionnaire d'espace de noms global. Nous pouvons accéder aux valeurs comme nous accédons dans les dictionnaires. Voyons l'exemple ci-dessous.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Nous pouvons modifier la valeur du dictionnaire en utilisant la fonction globals().
>>> globals()['a'] = 100 >>> a 100
Désormais, la nouvelle valeur de a apparaîtra dans les dictionnaires globaux.
La fonction locals()
Python fournit également la méthode locals() similaire à globals() mais accède à la place aux objets dans l'espace de noms local. Voyons l'exemple suivant.
Exemple -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Lorsque nous appelons func(10, 20), locals() renvoie le dictionnaire représentant l'espace de noms local de la fonction. Dans la portée de la fonction, nous avons défini la variable locale str1 ; l'espace de noms local incluait les arguments de la fonction puisqu'ils sont locaux à func().
Néanmoins, lorsque nous appelons la capacité local people(), elle agit de manière équivalente à la capacité globals(). La fonction globals() et la fonction locals() diffèrent légèrement. La fonction globals() définit non seulement des variables supplémentaires mais stocke également la valeur de retour. Le dictionnaire contiendra les nouvelles variables et leurs valeurs. Jetez un œil à l’exemple ci-dessous.
f films
Exemple -
>>> glob_var = globals() >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} >>> x = 100 >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} Ici le var_glob est une référence au dictionnaire global des espaces de noms. Les nouvelles déclarations d'affectation X et et apparu dans le var_glob dictionnaire.
Modification des variables hors de portée
Dans l'environnement appelant, la fonction peut modifier l'argument en passant une valeur différente, mais parfois elle ne peut pas modifier la valeur.
Un argument immuable ne peut pas être modifié par une fonction.
Un argument mutable peut être modifié sur place, mais il ne peut pas être complètement redéfini.
Comprenons le scénario suivant.
Exemple -
x = 20 def func(): x = 40 print(x) func() print(x)
Sortir:
40 20
On définit une variable globale x = 20 et également en fonction du même nom. Lorsque func() s'exécute, il crée la nouvelle référence de variable locale à un objet entier dont la valeur est 40. À l'intérieur du fonction() body, l'instruction d'affectation n'affectera pas l'objet global.
Cependant, une fonction peut modifier un objet de type mutable en dehors de sa portée locale. Comprenons l'exemple ci-dessous.
Exemple -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
my_list est une liste et elle est de type mutable. Le func() peut modifier l'intérieur de my_list même s'il est en dehors de la portée locale. Mais, si nous essayons de réaffecter ma_liste, cela créera le nouvel objet local et ne modifiera pas la ma_liste globale. Voyons l'exemple ci-dessous.
Exemple -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Sortir:
['A', 'B', 'C', 'D', 'E']
Conclusion
Nous nous occupons de l'espace de noms, de la manière dont nous pouvons l'utiliser et du degré de la variable. De nombreux objets distincts peuvent être créés avec un bref programme Python. Ce nombre peut dépasser mille dans un programme Python compliqué. L'espace de noms Python permet à l'interpréteur de se souvenir plus facilement des noms de ces objets.