În acest tutorial, vom afla despre spațiul de nume din Python, structura folosită pentru a organiza numele simbolice atribuite obiectelor într-un program Python, de ce este important spațiul de nume și cum le putem folosi în programul nostru Python. Să facem o scurtă introducere a unui spațiu de nume.
Ce este Namespace?
În Python, o modalitate de a da fiecărui obiect un nume unic este printr-un spațiu de nume. Variabilele și metodele sunt exemple de obiecte în Python. Cu alte cuvinte, este o colecție de nume simbolice cunoscute și detalii despre lucrul la care se referă fiecare nume. Un nume poate fi considerat ca o cheie într-un dicționar, iar obiectele sunt valorile dintr-un spațiu de nume. Ar trebui să ne dăm seama cu un model autentic - Un spațiu de nume seamănă cu un nume de familie. Dacă există mai multe nume „Petru” în clasă, poate fi dificil să găsiți un nume „Petru”; totuși, când solicităm în mod special „Peter Warner” sau „Peter Cummins”, într-o clasă, s-ar putea să nu fie obișnuit ca mai mulți studenți să aibă același prenume și același nume.
Interpretul Python poate înțelege mai bine metoda sau variabila exactă din cod datorită spațiului de nume. Drept urmare, numele său conține informații suplimentare, inclusiv Spațiu (relativ cu domeniul de aplicare) și Nume, care denotă un identificator unic.
În Python, există patru tipuri de spații de nume care sunt prezentate mai jos.
- Incorporat
- Global
- Anexând
- Local
Deoarece aceste spații de nume diferite au durate de viață, interpretul Python creează spații de nume după cum este necesar și le șterge atunci când nu mai sunt necesare.
Să înțelegem diferitele tipuri de spațiu de nume din Python.
Spațiul de nume încorporat
După cum sugerează și numele, conține nume predefinite ale tuturor obiectelor încorporate din Python deja disponibile în Python. Să listăm aceste nume cu următoarea comandă.
Deschideți terminalul Python și tastați următoarea comandă.
Comanda -
dir(__builtins__)
Ieșire:
['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']
Spațiul de nume încorporat este creat de interpretul Python când pornește. Acestea sunt terminate când interpretul Python se termină.
Spațiul de nume global
Spațiul de nume global constă din orice nume în Python la orice nivel al programului principal. Este creat atunci când corpul principal execută și rămâne în existență până când interpretul încetează.
Interpretul Python creează un spațiu de nume global pentru orice modul pe care Python-ul nostru îl încarcă cu instrucțiunea de import. Pentru a obține mai multe informații, vizitați modulul nostru Python.
Spațiile de nume locale și înglobate
Spațiile de nume locale sunt utilizate de funcție; Când funcția este rulată, interpretul Python creează un nou spațiu de nume. Spațiile de nume locale continuă să existe după ce funcția a terminat de rulat. Capacitatea poate cuprinde, de asemenea, o altă capacitate. După cum se arată mai jos, putem defini o funcție în alta.
Exemplu -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
În modelul de mai sus, capacitatea g() este caracterizată în interiorul colecției de f(). Am numit funcția g() în cadrul f() și funcția principală f(). Să vedem cum funcționează funcția de mai sus:
- Python creează un nou spațiu de nume pentru f() când îl numim.
- La fel, f() apelează g(), g() primește propriul spațiu de nume diferit.
- Spațiul de nume local g() a fost creat pentru spațiul de nume inclus, f().
Fiecare dintre aceste spații de nume este terminată atunci când funcția este terminată.
Domeniul de aplicare al obiectului/variabilei
Termenul „sfera de aplicare” specifică ce regiune de codare a unui anumit obiect Python poate fi accesată. Fiecare obiect și variabilă are un domeniu în program din care putem accesa acea variabilă. De exemplu, o variabilă de funcție poate fi accesată numai în cadrul funcției. Să examinăm următoarea ilustrație:
Exemplu -
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()
Ieșire:
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
Dicționare pentru spații de nume Python
În tutorialul anterior, am vorbit despre modul în care spațiile de nume sunt ca dicționarele, cu chei reprezentând nume de obiecte și valori reprezentând obiecte reale. Ca dicționare, Python utilizează atât spații de nume globale, cât și locale. Accesul la dicționarele de spații de nume globale și locale este posibil prin metodele globals() și locals() ale lui Python.
Metoda globals().
Metoda globals() returnează o referință la dicționarul actual al spațiului de nume global. Îl putem folosi pentru a accesa obiectele din spațiul de nume global. Să vedem exemplul de mai jos.
jpa vs hibernare
Exemplu -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } După cum putem vedea că, există multe intrări încorporate în global() metodă. Poate fi diferit în funcție de sistemul dvs. de operare și versiunea Python. Acum să definim variabila globală și să observăm diferențele.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} După atribuirea lui a = 20, o nouă variabilă globală este atribuită dicționarului de spațiu de nume global. Putem accesa valorile pe măsură ce accesăm în dicționare. Să vedem exemplul de mai jos.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Putem modifica valoarea dicționarului folosind funcția globals().
>>> globals()['a'] = 100 >>> a 100
Acum noua valoare a lui a va fi apărută în dicționarele globale.
The locals() Funcția
Python oferă, de asemenea, metoda locals() similară cu globals(), dar accesează în schimb obiectele din spațiul de nume local. Să vedem următorul exemplu.
Exemplu -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Când apelăm funcția(10, 20), locals() returnează dicționarul reprezentând spațiul de nume local al funcției. În domeniul funcției, am definit variabila locală str1; spațiul de nume local a inclus argumentele funcției, deoarece acestea sunt locale pentru func().
Cu toate acestea, atunci când numim capacitatea local people() , aceasta acționează echivalent cu capacitatea globals(). Funcția globals() și funcția locals() diferă ușor. Funcția globals() nu numai că definește variabile suplimentare, ci stochează și valoarea returnată. Dicționarul va conține noile variabile și valorile acestora. Aruncă o privire la exemplul de mai jos.
Exemplu -
>>> 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'} Aici glob_var este o referință la dicționarul global al spațiului de nume. Noile declarații de atribuire X și și a aparut in glob_var dicţionar.
Modificarea variabilelor în afara domeniului de aplicare
În mediul de apelare, funcția poate schimba argumentul prin transmiterea unei valori diferite, dar uneori nu poate schimba valoarea.
Un argument imuabil nu poate fi modificat de o funcție.
Un argument mutabil poate fi schimbat pe loc, dar nu poate fi complet redefinit.
Să înțelegem următorul scenariu.
Exemplu -
x = 20 def func(): x = 40 print(x) func() print(x)
Ieșire:
40 20
Definim o variabilă globală x = 20 și, de asemenea, în funcție cu același nume. Când func() se execută, creează noua referință la variabila locală la un obiect întreg a cărui valoare este 40. În interiorul func() body, instrucțiunea de atribuire nu va afecta obiectul global.
Cu toate acestea, o funcție poate modifica un obiect de tip mutabil în afara domeniului său local. Să înțelegem exemplul de mai jos.
Exemplu -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
My_list este o listă și este de tip mutabil. Func() se poate modifica în interiorul my_list chiar dacă este în afara domeniului local. Dar, dacă încercăm să reatribuim my_list, acesta va crea noul obiect local și nu va modifica global my_list. Să vedem exemplul de mai jos.
Exemplu -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Ieșire:
['A', 'B', 'C', 'D', 'E']
Concluzie
Ne ocupăm de spațiul de nume, de modul în care îl putem utiliza și de gradul variabilei. Numeroase obiecte distincte pot fi create cu un scurt program Python. Acest număr poate depăși o mie într-un program Python complicat. Spațiul de nume Python face mai ușor pentru interpret să-și amintească numele acestor obiecte.