En aquest tutorial, coneixerem l'espai de noms a Python, l'estructura que s'utilitza per organitzar els noms simbòlics assignats als objectes en un programa de Python, per què és important l'espai de noms i com podem utilitzar-los al nostre programa Python. Fem una breu introducció a un espai de noms.

Què és l'espai de noms?

A Python, una manera de donar a cada objecte un nom únic és mitjançant un espai de noms. Les variables i els mètodes són exemples d'objectes a Python. Per dir-ho d'una altra manera, és una col·lecció dels noms simbòlics coneguts i els detalls sobre allò a què fa referència cada nom. Un nom es pot pensar com una clau en un diccionari, i els objectes són els valors d'un espai de noms. Hauríem d'esbrinar-ho amb un model genuí: un espai de noms s'assembla a un cognom. Si hi ha diversos noms de 'Pere' a la classe, pot ser difícil trobar un nom de 'Pere'; tanmateix, quan demanem específicament 'Peter Warner' o 'Peter Cummins', en una classe, pot ser que no sigui habitual que diversos estudiants tinguin el mateix nom i cognom.

L'intèrpret de Python pot entendre millor el mètode o la variable exactes del codi gràcies a l'espai de noms. Com a resultat, el seu nom conté informació addicional, com ara l'espai (relacionat amb l'abast) i el nom, que denota un identificador únic.

A Python, hi ha quatre tipus d'espais de noms que es donen a continuació.

• Integrat
• Global
• Tancant
• Local

Com que aquests espais de noms tenen una vida útil, l'intèrpret de Python crea espais de noms segons sigui necessari i els suprimeix quan ja no són necessaris.

Entendrem els diferents tipus d'espai de noms a Python.

nombre a cadena java

L'espai de noms integrat

Com el seu nom indica, conté noms predefinits de tots els objectes integrats de Python que ja estan disponibles a Python. Enumerem aquests noms amb l'ordre següent.

Obriu el terminal de Python i escriviu l'ordre següent.

Comandament -

 dir(__builtins__) 

Sortida:

 ['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'espai de noms integrat creat per l'intèrpret de Python quan s'inicia. Aquests s'acaben quan finalitza l'intèrpret de Python.

funcionament intern de hashmap

L'espai de noms global

L'espai de noms global consta de qualsevol nom en Python a qualsevol nivell del programa principal. Es crea quan el cos principal s'executa i es manté fins que l'intèrpret acaba.

L'intèrpret de Python crea un espai de noms global per a qualsevol mòdul que el nostre Python carregui amb la instrucció d'import. Per obtenir més informació, visiteu el nostre mòdul Python.

Els espais de noms locals i adjuntants

La funció utilitza els espais de noms locals; Quan s'executa la funció, l'intèrpret de Python crea un espai de noms nou. Els espais de noms locals continuen existint després que la funció s'hagi acabat d'executar. La capacitat també pot incloure una altra capacitat. Com es mostra a continuació, podem definir una funció dins d'una altra.

Exemple -

 def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f() 

En el model anterior, la capacitat g() es caracteritza dins de la col·lecció de f(). Hem anomenat la funció g() dins de la funció f() i la funció principal f(). Vegem com funciona la funció anterior:

• Python crea un nou espai de noms per a f() quan l'anomenem.
• De la mateixa manera, f() crida a g(), g() obté el seu propi espai de noms diferent.
• L'espai de noms local g() es va crear per a l'espai de noms que l'adjunta, f().

Cadascun d'aquests espais de noms s'acaba quan s'acaba la funció.

Abast de l'objecte/variable

El terme 'abast' especifica a quina regió de codificació d'un objecte Python concret es pot accedir. Cada objecte i variable té un àmbit al programa des del qual podem accedir a aquesta variable. Per exemple, només es pot accedir a una variable de funció dins de la funció. Examinem la següent il·lustració:

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() 

Sortida:

 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 

Diccionaris d'espais de noms Python

Al tutorial anterior, vam parlar de com els espais de noms són com els diccionaris, amb les claus que representen els noms dels objectes i els valors que representen els objectes reals. Com a diccionaris, Python utilitza espais de noms locals i globals. L'accés als diccionaris d'espais de noms locals i globals és possible gràcies als mètodes globals() i locals() de Python.

El mètode globals().

El mètode globals() retorna una referència al diccionari de l'espai de noms global actual. El podem utilitzar per accedir als objectes de l'espai de noms global. Vegem l'exemple següent.

Exemple -

 >>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } 

Com podem veure, hi ha moltes entrades integrades globals () mètode. Pot ser diferent segons el vostre sistema operatiu i la versió de Python. Ara definim la variable global i observem les diferències.

 >>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} 

Després de l'assignació d'a = 20, una nova variable global assignada al diccionari d'espai de noms global. Podem accedir als valors a mesura que accedim als diccionaris. Vegem l'exemple següent.

 >>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 

Podem modificar el valor del diccionari mitjançant la funció globals().

 >>> globals()['a'] = 100 >>> a 100 

Ara el nou valor de a apareixerà als diccionaris globals.

edat de mia khalifa

La funció locals().

Python també proporciona el mètode locals() similar a globals() però accedeix als objectes a l'espai de noms local. Vegem el següent exemple.

Exemple -

 >>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} 

Quan cridem la funció (10, 20), la funció locals() retorna el diccionari que representa l'espai de noms local de la funció. En l'àmbit de la funció, hem definit la variable local str1; l'espai de noms local va incloure els arguments de la funció ja que són locals a la funció func().

No obstant això, quan anomenem capacitat local people() actua de manera equivalent a la capacitat globals(). La funció globals() i la funció locals() difereixen lleugerament. La funció globals() no només defineix variables addicionals sinó que també emmagatzema el valor de retorn. El diccionari contindrà les noves variables i els seus valors. Mireu l'exemple següent.

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'} 

Aquí el glob_var és una referència al diccionari global de l'espai de noms. Les noves declaracions d'encàrrec x i i va aparèixer a la glob_var diccionari.

Canviar variables fora d'abast

En l'entorn de trucada, la funció pot canviar l'argument passant un valor diferent, però de vegades no pot canviar el valor.

bloquejar una aplicació d'Android

Una funció no pot modificar un argument immutable.

Un argument mutable es pot canviar al seu lloc, però no es pot redefinir completament.

Entenem el següent escenari.

Exemple -

 x = 20 def func(): x = 40 print(x) func() print(x) 

Sortida:

 40 20 

Definim una variable global x = 20 i també en funció amb el mateix nom. Quan la funció func() s'executa, crea la nova referència de variable local a un objecte enter el valor del qual és 40. Dins del funció () body, la instrucció d'assignació no afectarà l'objecte global.

Tanmateix, una funció pot modificar un objecte d'un tipus mutable fora del seu àmbit local. Entenem l'exemple següent.

Exemple -

 my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func()) 

La meva_lista és una llista i és de tipus mutable. El func() es pot modificar dins de my_list encara que estigui fora de l'àmbit local. Però, si intentem reassignar la meva_lista, crearà el nou objecte local i no modificarà la meva_lista global. Vegem l'exemple següent.

Exemple -

excel eliminar el primer caràcter

 my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func()) 

Sortida:

 ['A', 'B', 'C', 'D', 'E'] 

Conclusió

Ens ocupem de l'espai de noms, com podem utilitzar-lo i el grau de la variable. Es poden crear nombrosos objectes diferents amb un breu programa Python. Aquest nombre pot superar el miler en un programa Python complicat. L'espai de noms de Python facilita que l'intèrpret recordi els noms d'aquests objectes.