In questo tutorial impareremo lo spazio dei nomi in Python, la struttura utilizzata per organizzare i nomi simbolici assegnati agli oggetti in un programma Python, perché lo spazio dei nomi è importante e come possiamo usarli nel nostro programma Python. Facciamo una breve introduzione a uno spazio dei nomi.

Cos'è lo spazio dei nomi?

In Python, un modo per dare a ciascun oggetto un nome univoco è attraverso uno spazio dei nomi. Variabili e metodi sono esempi di oggetti in Python. Per dirla in altro modo, è una raccolta dei nomi simbolici conosciuti e dei dettagli sulla cosa a cui si riferisce ciascun nome. Un nome può essere considerato come una chiave in un dizionario e gli oggetti sono i valori in uno spazio dei nomi. Dovremmo capirlo con un modello autentico: uno spazio dei nomi assomiglia a un cognome. Se nella classe sono presenti più nomi 'Pietro', potrebbe essere difficile individuare il nome 'Pietro'; tuttavia, quando richiediamo specificamente 'Peter Warner' o 'Peter Cummins', in una classe potrebbe non essere comune che più studenti abbiano lo stesso nome e cognome.

L'interprete Python può comprendere meglio il metodo esatto o la variabile nel codice grazie allo spazio dei nomi. Di conseguenza, il suo nome contiene informazioni aggiuntive, tra cui Spazio (relativo all'ambito) e Nome, che denota un identificatore univoco.

In Python, ci sono quattro tipi di spazi dei nomi indicati di seguito.

• Integrato
• Globale
• Racchiudere
• Locale

Poiché questi spazi dei nomi hanno una durata di vita, l'interprete Python crea gli spazi dei nomi secondo necessità e li elimina quando non sono più necessari.

Comprendiamo i vari tipi di namespace in Python.

Lo spazio dei nomi integrato

Come suggerisce il nome, contiene nomi predefiniti di tutti gli oggetti integrati di Python già disponibili in Python. Elenchiamo questi nomi con il seguente comando.

Apri il terminale Python e digita il seguente comando.

Comando -

 dir(__builtins__) 

Produzione:

 ['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'] 

Lo spazio dei nomi integrato viene creato dall'interprete Python all'avvio. Questi vengono terminati quando termina l'interprete Python.

Lo spazio dei nomi globale

Lo spazio dei nomi globale è costituito da qualsiasi nome in Python a qualsiasi livello del programma principale. Viene creato quando il corpo principale viene eseguito e rimane esistente finché l'interprete non termina.

L'interprete Python crea uno spazio dei nomi globale per qualsiasi modulo che il nostro Python carica con l'istruzione import. Per ottenere maggiori informazioni, visita il nostro modulo Python.

Gli spazi dei nomi locali e di inclusione

Gli spazi dei nomi locali vengono utilizzati dalla funzione; Quando la funzione viene eseguita, l'interprete Python crea un nuovo spazio dei nomi. Gli spazi dei nomi locali continuano a esistere al termine dell'esecuzione della funzione. La capacità può parimenti comprendere un'altra capacità. Come mostrato di seguito, possiamo definire una funzione all'interno di un'altra.

Esempio -

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

Nel modello precedente, la capacità g() è caratterizzata all'interno della raccolta di f(). Abbiamo chiamato la funzione g() all'interno di f() e la funzione principale f(). Diamo un'occhiata a come funziona la funzione di cui sopra:

• Python crea un nuovo spazio dei nomi per f() quando lo chiamiamo.
• Allo stesso modo, f() chiama g(), g() ottiene il proprio spazio dei nomi diverso.
• Lo spazio dei nomi locale g() è stato creato per lo spazio dei nomi che lo racchiude, f().

Ciascuno di questi spazi dei nomi viene terminato quando viene terminata la funzione.

Ambito dell'oggetto/variabile

Il termine 'ambito' specifica a quale regione di codifica di un particolare oggetto Python è possibile accedere. Ogni oggetto e variabile ha un ambito nel programma da cui possiamo accedere a quella variabile. Ad esempio, è possibile accedere a una variabile di funzione solo all'interno della funzione. Esaminiamo la seguente illustrazione:

Esempio -

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

Produzione:

 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 

Dizionari degli spazi dei nomi Python

Nel tutorial precedente abbiamo parlato di come gli spazi dei nomi siano come dizionari, con le chiavi che rappresentano i nomi degli oggetti e i valori che rappresentano gli oggetti reali. Come dizionari, Python utilizza sia spazi dei nomi globali che locali. L'accesso ai dizionari dei namespace globali e locali è reso possibile dai metodi globals() e locals() di Python.

Il metodo globals()

Il metodo globals() restituisce un riferimento al dizionario dello spazio dei nomi globale corrente. Possiamo usarlo per accedere agli oggetti nello spazio dei nomi globale. Vediamo l'esempio qui sotto.

Esempio -

come rimuovere il primo carattere in Excel

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

Come possiamo vedere, ci sono molte voci integrate in globali() metodo. Potrebbe variare in base al sistema operativo e alla versione di Python. Ora definiamo la variabile globale e osserviamo le differenze.

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

Dopo l'assegnazione di a = 20, una nuova variabile globale assegnata al dizionario dello spazio dei nomi globale. Possiamo accedere ai valori mentre accediamo ai dizionari. Vediamo l'esempio qui sotto.

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

Possiamo modificare il valore del dizionario usando la funzione globals().

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

Ora il nuovo valore di a apparirà nei dizionari globali.

La funzione locals()

Python fornisce anche il metodo locals() simile a globals() ma accede invece agli oggetti nello spazio dei nomi locale. Vediamo il seguente esempio.

Esempio -

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

Quando chiamiamo func(10, 20), locals() restituisce il dizionario che rappresenta lo spazio dei nomi locale della funzione. Nell'ambito della funzione, abbiamo definito la variabile locale str1; lo spazio dei nomi locale include gli argomenti della funzione poiché sono locali rispetto a func().

Tuttavia, quando chiamiamo la capacità local people(), essa agisce in modo equivalente alla capacità globals(). La funzione globals() e la funzione locals() differiscono leggermente. La funzione globals() non solo definisce variabili aggiuntive ma memorizza anche il valore restituito. Il dizionario conterrà le nuove variabili e i loro valori. Dai un'occhiata all'esempio qui sotto.

Esempio -

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

Ecco il glob_var è un riferimento al dizionario dello spazio dei nomi globale. Le nuove dichiarazioni di assegnazione X E E è apparso nel glob_var dizionario.

Modifica delle variabili fuori ambito

Nell'ambiente chiamante, la funzione può modificare l'argomento passando un valore diverso, ma a volte non può modificare il valore.

Un argomento immutabile non può essere modificato da una funzione.

Un argomento mutabile può essere modificato sul posto, ma non può essere completamente ridefinito.

Comprendiamo il seguente scenario.

Esempio -

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

Produzione:

 40 20 

Definiamo una variabile globale x = 20 e anche una funzione con lo stesso nome. Quando func() viene eseguito, crea la nuova variabile locale riferimento a un oggetto intero il cui valore è 40. All'interno di funzione() body, l'istruzione di assegnazione non influenzerà l'oggetto globale.

Tuttavia, una funzione può modificare un oggetto di tipo modificabile al di fuori del suo ambito locale. Comprendiamo l'esempio seguente.

Esempio -

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

my_list è un elenco ed è di tipo modificabile. Il func() può modificare all'interno di my_list anche se è al di fuori dell'ambito locale. Ma, se proviamo a riassegnare my_list, creerà il nuovo oggetto locale e non modificherà il my_list globale. Vediamo l'esempio qui sotto.

Esempio -

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

Produzione:

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

Conclusione

Ci prendiamo cura dello spazio dei nomi, di come possiamo utilizzarlo e del grado della variabile. Numerosi oggetti distinti possono essere creati con un breve programma Python. Questo numero può superare il migliaio in un programma Python complicato. Lo spazio dei nomi Python rende più facile per l'interprete ricordare i nomi di questi oggetti.

funzione anonima Java