I den här handledningen kommer vi att lära oss om namnutrymmet i Python, strukturen som används för att organisera de symboliska namnen som tilldelats objekt i ett Python-program, varför namnutrymmet är viktigt och hur vi kan använda dem i vårt Python-program. Låt oss ha en kort introduktion till ett namnområde.
Vad är namnutrymme?
I Python är ett sätt att ge varje objekt ett unikt namn genom ett namnutrymme. Variabler och metoder är exempel på objekt i Python. För att uttrycka det på ett annat sätt är det en samling av de kända symboliska namnen och detaljerna om den sak som varje namn refererar till. Ett namn kan ses som en nyckel i en ordbok, och objekt är värdena i ett namnområde. Vi borde ta reda på det med en äkta modell - Ett namnområde liknar ett efternamn. Om det finns flera 'Peter'-namn i klassen kan det vara svårt att hitta ett 'Peter'-namn; men när vi specifikt begär 'Peter Warner' eller 'Peter Cummins' i en klass kanske det inte är vanligt att flera elever har samma för- och efternamn.
Python-tolken kan få en bättre förståelse för den exakta metoden eller variabeln i koden tack vare namnutrymmet. Som ett resultat innehåller dess namn ytterligare information, inklusive Space (relaterat till omfattning) och Namn, som anger en unik identifierare.
bash if uttalande
I Python finns det fyra typer av namnrymder som anges nedan.
- Inbyggt
- Global
- Omslutande
- Lokal
Eftersom dessa olika namnutrymmen har livstider, skapar Python-tolken namnområden efter behov och tar bort dem när de inte längre behövs.
Låt oss förstå de olika typerna av namnutrymme i Python.
Den inbyggda namnrymden
Som namnet antyder innehåller den fördefinierade namn på alla Pythons inbyggda objekt som redan finns tillgängliga i Python. Låt oss lista dessa namn med följande kommando.
Öppna Python-terminalen och skriv följande kommando.
Kommando -
dir(__builtins__)
Produktion:
['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']
Det inbyggda namnutrymmet skapas av Python-tolken när det startar. Dessa avslutas när Python-tolken avslutas.
Den globala namnrymden
Den globala namnrymden består av alla namn i Python på vilken nivå som helst i huvudprogrammet. Den skapas när huvuddelen körs och förblir i existens tills tolken avslutas.
Python-tolken skapar en global namnrymd för alla moduler som vår Python laddar med importsatsen. För att få mer information, besök vår Python-modul.
De lokala och omslutande namnområdena
De lokala namnområdena används av funktionen; När funktionen körs skapar Python-tolken ett nytt namnområde. De lokala namnområdena fortsätter att existera efter att funktionen har körts färdigt. Förmågan kan också bestå av en annan kapacitet. Som visas nedan kan vi definiera en funktion inom en annan.
Exempel -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
I ovanstående modell karakteriseras förmågan g() i samlingen av f(). Vi kallade g()-funktionen inom f() och huvudfunktionen f(). Låt oss titta på hur ovanstående funktion fungerar:
- Python skapar ett nytt namnområde för f() när vi kallar det.
- På samma sätt anropar f() g(), g() får sitt eget olika namnområde.
- Det lokala namnutrymmet g() skapades för det omslutande namnutrymmet, f().
Var och en av dessa namnområden avslutas när funktionen avslutas.
Objektets/variabelns omfattning
Termen 'scope' anger vilken kodningsregion för ett visst Python-objekt som kan nås. Varje objekt och variabel har ett omfång i programmet från vilket vi kan komma åt den variabeln. Till exempel kan en funktionsvariabel endast nås inom funktionen. Låt oss undersöka följande illustration:
teknikens fördelar och nackdelar
Exempel -
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()
Produktion:
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
Python Namespace Dictionaries
I den tidigare handledningen pratade vi om hur namnrymder är som ordböcker, med nycklar som representerar objektnamn och värden som representerar faktiska objekt. Som ordböcker använder Python både globala och lokala namnrymder. Tillgång till globala och lokala namnrymdsordböcker möjliggörs av Pythons metoder globals() och locals().
Globals()-metoden
Metoden globals() returnerar en referens till den aktuella globala namnrymdsordboken. Vi kan använda den för att komma åt objekten i det globala namnområdet. Låt oss se exemplet nedan.
Exempel -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Som vi kan se det finns det många inbyggda poster i globals() metod. Det kan skilja sig beroende på ditt operativsystem och Python-version. Låt oss nu definiera den globala variabeln och observera skillnaderna.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Efter tilldelningen av a = 20, tilldelas en ny global variabel till den globala namnrymdsordboken. Vi kan komma åt värdena som vi kommer åt i ordböckerna. Låt oss se exemplet nedan.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Vi kan ändra ordboksvärdet med hjälp av funktionen globals().
>>> globals()['a'] = 100 >>> a 100
Nu kommer det nya värdet av a att visas i de globala ordböckerna.
Locals()-funktionen
Python tillhandahåller också metoden locals() som liknar globals() men får åtkomst till objekt i det lokala namnområdet istället. Låt oss se följande exempel.
Exempel -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} När vi anropar func(10, 20) returnerar locals() ordboken som representerar funktionens lokala namnområde. I funktionsomfånget definierade vi den lokala variabeln str1; det lokala namnområdet inkluderade funktionsargumenten eftersom de är lokala för func().
Trots det, när vi kallar local people() capability, agerar det likvärdigt med globals()-kapaciteten. Funktionerna globals() och funktionen locals() skiljer sig något åt. Funktionen globals() definierar inte bara ytterligare variabler utan lagrar även returvärdet. Ordboken kommer att innehålla de nya variablerna och deras värden. Ta en titt på exemplet nedan.
java matematik slumpmässigt
Exempel -
>>> 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'} Här glob_var är en referens till den globala namnutrymmesordboken. De nya uppdragsbeskrivningarna x och och dök upp i glob_var lexikon.
Ändra variabler utanför räckvidd
I den anropande miljön kan funktionen ändra argumentet genom att skicka ett annat värde, men ibland kan den inte ändra värdet.
Ett oföränderligt argument kan inte modifieras av en funktion.
Ett föränderligt argument kan ändras på plats, men det kan inte helt omdefinieras.
Låt oss förstå följande scenario.
Exempel -
x = 20 def func(): x = 40 print(x) func() print(x)
Produktion:
40 20
Vi definierar en global variabel x = 20 och även i funktion med samma namn. När func() körs skapar den den nya lokala variabelreferensen till ett heltalsobjekt vars värde är 40. Inuti func() body, kommer tilldelningssatsen inte att påverka det globala objektet.
En funktion kan dock modifiera ett objekt av en föränderlig typ utanför dess lokala räckvidd. Låt oss förstå exemplet nedan.
tostring-metoden i java
Exempel -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
My_list är en lista och den är föränderlig typ. Func() kan modifieras inuti my_list även om den ligger utanför det lokala omfånget. Men om vi försöker tilldela om my_list, kommer det att skapa det nya lokala objektet och kommer inte att ändra den globala my_list. Låt oss se exemplet nedan.
Exempel -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Produktion:
['A', 'B', 'C', 'D', 'E']
Slutsats
Vi tar hand om namnutrymmet, hur vi kan använda det och variabelns grad. Många distinkta objekt kan skapas med ett kort Python-program. Detta antal kan överstiga tusen i ett komplicerat Python-program. Python-namnutrymmet gör det lättare för tolken att komma ihåg dessa objekts namn.