I denne øvelse lærer vi om navnerummet i Python, strukturen, der bruges til at organisere de symbolske navne, der er tildelt objekter i et Python-program, hvorfor navneområdet er vigtigt, og hvordan vi kan bruge dem i vores Python-program. Lad os få en kort introduktion til et navneområde.
Hvad er navneområde?
I Python er en måde at give hvert objekt et unikt navn på gennem et navneområde. Variabler og metoder er eksempler på objekter i Python. For at sige det på en anden måde er det en samling af de kendte symbolske navne og detaljerne om den ting, som hvert navn refererer til. Et navn kan opfattes som en nøgle i en ordbog, og objekter er værdierne i et navneområde. Vi burde finde ud af det med en ægte model - Et navneområde ligner et efternavn. Hvis der er flere 'Peter'-navne i klassen, kan det være svært at finde et 'Peter'-navn; Men når vi specifikt anmoder om 'Peter Warner' eller 'Peter Cummins' i en klasse, er det måske ikke almindeligt, at flere elever har det samme for- og efternavn.
Python-fortolkeren kan få en bedre forståelse af den nøjagtige metode eller variabel i koden takket være navneområdet. Som følge heraf indeholder dens navn yderligere information, herunder mellemrum (relateret til omfang) og navn, som angiver en unik identifikator.
I Python er der fire typer navneområder, som er angivet nedenfor.
- Indbygget
- Global
- Omsluttende
- Lokal
Da disse forskellige navneområder har levetider, opretter Python-fortolkeren navnerum efter behov og sletter dem, når de ikke længere er nødvendige.
Lad os forstå de forskellige typer navneområde i Python.
Det indbyggede navneområde
Som navnet antyder, indeholder den foruddefinerede navne på alle Pythons indbyggede objekter, der allerede er tilgængelige i Python. Lad os liste disse navne med følgende kommando.
Åbn Python-terminalen og skriv følgende 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 indbyggede navneområde oprettes af Python-fortolkeren, når det starter op. Disse afsluttes, når Python-fortolkeren afsluttes.
Det globale navneområde
Det globale navneområde består af alle navne i Python på et hvilket som helst niveau i hovedprogrammet. Det oprettes, når hovedorganet udfører og forbliver i eksistens, indtil tolken afslutter.
Python-fortolkeren opretter et globalt navneområde for ethvert modul, som vores Python indlæser med importerklæringen. Besøg vores Python-modul for at få mere information.
De lokale og omsluttende navnerum
De lokale navneområder bruges af funktionen; Når funktionen køres, opretter Python-fortolkeren et nyt navneområde. De lokale navneområder fortsætter med at eksistere efter funktionen er færdig med at køre. Evnen kan ligeledes omfatte en anden kapacitet. Som vist nedenfor kan vi definere en funktion i en anden.
Eksempel -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
I ovenstående model er kapaciteten g() karakteriseret inde i samlingen af f(). Vi kaldte g()-funktionen i f()- og hovedfunktionen f()-funktion. Lad os se på, hvordan ovenstående funktion fungerer:
- Python opretter et nyt navneområde for f(), når vi kalder det.
- Ligeledes kalder f() g(), g() får sit eget forskellige navneområde.
- Det lokale navneområde g() blev oprettet for det omsluttende navneområde, f().
Hvert af disse navneområder afsluttes, når funktionen afsluttes.
Objektets/variablens omfang
Udtrykket 'scope' specificerer, hvilken kodningsregion af et bestemt Python-objekt, der kan tilgås. Hvert objekt og variabel har et omfang i programmet, hvorfra vi kan få adgang til denne variabel. For eksempel kan en funktionsvariabel kun tilgås i funktionen. Lad os undersøge følgende illustration:
Eksempel -
np betyder
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 Ordbøger
I den forrige tutorial talte vi om, hvordan navnerum er som ordbøger, med taster, der repræsenterer objektnavne og værdier, der repræsenterer faktiske objekter. Som ordbøger bruger Python både globale og lokale navnerum. Adgang til globale og lokale navnerumsordbøger er muliggjort af Pythons globals() og locals() metoder.
Globals()-metoden
Globals()-metoden returnerer en reference til den aktuelle globale navnerumsordbog. Vi kan bruge det til at få adgang til objekterne i det globale navneområde. Lad os se nedenstående eksempel.
Eksempel -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Som vi kan se, er der mange indbyggede poster i globals() metode. Det kan være forskelligt afhængigt af dit operativsystem og Python-version. Lad os nu definere den globale variabel og observere forskellene.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Efter tildelingen af a = 20 tildeles en ny global variabel til den globale navnerumsordbog. Vi kan tilgå værdierne, som vi tilgår i ordbøgerne. Lad os se nedenstående eksempel.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Vi kan ændre ordbogsværdien ved hjælp af globals()-funktionen.
>>> globals()['a'] = 100 >>> a 100
Nu vil den nye værdi af a blive vist i de globale ordbøger.
Locals()-funktionen
Python leverer også metoden locals() svarende til globals(), men får i stedet adgang til objekter i det lokale navneområde. Lad os se følgende eksempel.
Eksempel -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Når vi kalder func(10, 20), returnerer locals() den ordbog, der repræsenterer funktionens lokale navneområde. I funktionsomfanget definerede vi den lokale variabel str1; det lokale navneområde inkluderede funktionsargumenterne, da de er lokale for func().
På trods af det, når vi kalder lokale folk()-kapacitet, virker det svarende til globals()-kapaciteten. Funktionen globals() og funktionen locals() adskiller sig lidt. Funktionen globals() definerer ikke kun yderligere variabler, men gemmer også returværdien. Ordbogen vil indeholde de nye variabler og deres værdier. Tag et kig på eksemplet nedenfor.
Eksempel -
>>> 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'} Her er glob_var er en reference til den globale navnerumsordbog. De nye opgaveerklæringer x og og dukkede op i glob_var ordbog.
Ændring af variabler uden for anvendelsesområdet
I det kaldende miljø kan funktionen ændre argumentet ved at sende en anden værdi, men nogle gange kan den ikke ændre værdien.
Et uforanderligt argument kan ikke ændres af en funktion.
Et foranderligt argument kan ændres på plads, men det kan ikke omdefineres fuldstændigt.
Lad os forstå følgende scenarie.
Eksempel -
omvendt streng java
x = 20 def func(): x = 40 print(x) func() print(x)
Produktion:
40 20
Vi definerer en global variabel x = 20 og også i funktion med samme navn. Når func() udføres, opretter den den nye lokale variabelreference til et heltalsobjekt, hvis værdi er 40. Inde i func() body, vil opgavesætningen ikke påvirke det globale objekt.
En funktion kan dog ændre et objekt af en foranderlig type uden for dets lokale omfang. Lad os forstå nedenstående eksempel.
Eksempel -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
My_list er en liste, og den kan ændres. Func() kan ændres inde i my_list, selvom den ligger uden for det lokale omfang. Men hvis vi forsøger at omtildele my_list, vil den oprette det nye lokale objekt og vil ikke ændre den globale my_list. Lad os se nedenstående eksempel.
Eksempel -
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']
Konklusion
Vi tager os af navnerummet, hvordan vi kan udnytte det og variablens grad. Adskillige forskellige objekter kan oprettes med et kort Python-program. Dette antal kan overstige tusind i et kompliceret Python-program. Python-navnerummet gør det nemmere for tolken at huske disse objekters navne.