I denne opplæringen vil vi lære om navneområdet i Python, strukturen som brukes til å organisere de symbolske navnene som er tildelt objekter i et Python-program, hvorfor navneområdet er viktig, og hvordan vi kan bruke dem i vårt Python-program. La oss få en kort introduksjon til et navneområde.
Hva er navneområde?
I Python er en måte å gi hvert objekt et unikt navn på gjennom et navneområde. Variabler og metoder er eksempler på objekter i Python. For å si det på en annen måte, det er en samling av de kjente symbolske navnene og detaljene om tingen som hvert navn refererer til. Et navn kan betraktes som en nøkkel i en ordbok, og objekter er verdiene i et navneområde. Vi bør finne ut av det med en ekte modell - Et navneområde ligner et etternavn. Hvis det er flere 'Peter'-navn i klassen, kan det være vanskelig å finne et 'Peter'-navn; Men når vi spesifikt ber om 'Peter Warner' eller 'Peter Cummins,' i en klasse, er det kanskje ikke vanlig at flere elever har samme for- og etternavn.
Python-tolken kan få en bedre forståelse av den eksakte metoden eller variabelen i koden takket være navneområdet. Som et resultat inneholder navnet tilleggsinformasjon, inkludert mellomrom (relatert til omfang) og navn, som angir en unik identifikator.
I Python er det fire typer navneområder som er gitt nedenfor.
- Innebygd
- Global
- Omsluttende
- Lokalt
Siden disse forskjellige navneområdene har levetid, oppretter Python-tolker navneområder etter behov og sletter dem når de ikke lenger er nødvendige.
La oss forstå de ulike typene navnerom i Python.
Det innebygde navneområdet
Som navnet antyder, inneholder den forhåndsdefinerte navn på alle Pythons innebygde objekter som allerede er tilgjengelige i Python. La oss liste disse navnene med følgende kommando.
Åpne Python-terminalen og skriv inn følgende kommando.
Kommando -
dir(__builtins__)
Produksjon:
['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 innebygde navnerommet opprettes av Python-tolken når det starter opp. Disse avsluttes når Python-tolken avsluttes.
Det globale navneområdet
Det globale navnerommet består av alle navn i Python på alle nivåer i hovedprogrammet. Det opprettes når hovedorganet utfører og forblir i eksistens til tolken avsluttes.
Python-tolken oppretter et globalt navneområde for enhver modul som Python-en vår laster med importsetningen. For å få mer informasjon, besøk vår Python-modul.
De lokale og omsluttende navnerommene
De lokale navnerommene brukes av funksjonen; Når funksjonen kjøres, oppretter Python-tolken et nytt navneområde. De lokale navneområdene fortsetter å eksistere etter at funksjonen er ferdig kjørt. Evnen kan likeledes bestå av en annen evne. Som vist nedenfor kan vi definere en funksjon i en annen.
Eksempel -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
I modellen ovenfor er evnen g() karakterisert inne i samlingen av f(). Vi kalte funksjonen g() innenfor f() og hovedfunksjonen f(). La oss se på hvordan funksjonen ovenfor fungerer:
- Python oppretter et nytt navneområde for f() når vi kaller det.
- På samme måte kaller f() g(), g() får sitt eget forskjellige navneområde.
- Det lokale navnerommet g() ble opprettet for det omsluttende navnerommet, f().
Hvert av disse navneområdene avsluttes når funksjonen avsluttes.
Omfanget av objektet/variabelen
Begrepet 'omfang' spesifiserer hvilken koderegion for et bestemt Python-objekt som kan nås. Hvert objekt og variabel har et omfang i programmet som vi kan få tilgang til den variabelen fra. For eksempel kan en funksjonsvariabel bare nås innenfor funksjonen. La oss undersøke følgende illustrasjon:
Eksempel -
10 ml til unser
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()
Produksjon:
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 forrige opplæringen snakket vi om hvordan navnerom er som ordbøker, med nøkler som representerer objektnavn og verdier som representerer faktiske objekter. Som ordbøker bruker Python både globale og lokale navnerom. Tilgang til globale og lokale navneromsordbøker er muliggjort av Pythons globals() og locals() metoder.
Globals()-metoden
Globals()-metoden returnerer en referanse til gjeldende globale navneromsordbok. Vi kan bruke den til å få tilgang til objektene i det globale navnerommet. La oss se eksemplet nedenfor.
Eksempel -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Som vi kan se det, er det mange innebygde oppføringer i globals() metode. Det kan variere avhengig av operativsystemet og Python-versjonen. La oss nå definere den globale variabelen og observere forskjellene.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Etter tilordningen av a = 20, tilordnes en ny global variabel til den globale navneromsordboken. Vi kan få tilgang til verdiene slik vi får tilgang til i ordbøkene. La oss se eksemplet nedenfor.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Vi kan endre ordbokverdien ved å bruke funksjonen globals().
>>> globals()['a'] = 100 >>> a 100
Nå vil den nye verdien av a vises i de globale ordbøkene.
Locals()-funksjonen
Python gir også locals()-metoden som ligner på globals(), men får tilgang til objekter i det lokale navneområdet i stedet. La oss 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 kaller func(10, 20), returnerer locals() ordboken som representerer funksjonens lokale navneområde. I funksjonsomfanget definerte vi den lokale variabelen str1; det lokale navnerommet inkluderte funksjonsargumentene siden de er lokale for func().
Til tross for at når vi kaller lokalbefolkning()-kapasitet, fungerer den tilsvarende globals()-evnen. Globals()-funksjonen og locals()-funksjonen er litt forskjellige. Globals()-funksjonen definerer ikke bare tilleggsvariabler, men lagrer også returverdien. Ordboken vil inneholde de nye variablene og deres verdier. Ta en titt 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 referanse til den globale navneromsordboken. De nye oppdragserklæringene x og og dukket opp i glob_var ordbok.
Endring av variabler utenfor omfanget
I anropsmiljøet kan funksjonen endre argumentet ved å sende en annen verdi, men noen ganger kan den ikke endre verdien.
Et uforanderlig argument kan ikke endres av en funksjon.
Et foranderlig argument kan endres på plass, men det kan ikke omdefineres fullstendig.
La oss forstå følgende scenario.
Eksempel -
shreya ghoshal
x = 20 def func(): x = 40 print(x) func() print(x)
Produksjon:
40 20
Vi definerer en global variabel x = 20 og også i funksjon med samme navn. Når func() kjøres, oppretter den den nye lokale variabelreferansen til et heltallsobjekt hvis verdi er 40. Inne i func() body, vil ikke oppdragssetningen påvirke det globale objektet.
Imidlertid kan en funksjon endre et objekt av en mutbar type utenfor dets lokale omfang. La oss forstå eksemplet nedenfor.
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 endres. Func() kan endres inne i my_list selv om den er utenfor det lokale omfanget. Men hvis vi prøver å tilordne my_list på nytt, vil den opprette det nye lokale objektet og vil ikke endre den globale my_list. La oss se eksemplet nedenfor.
Eksempel -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Produksjon:
['A', 'B', 'C', 'D', 'E']
Konklusjon
Vi tar oss av navnerommet, hvordan vi kan utnytte det, og variabelens grad. Tallrike distinkte objekter kan opprettes med et kort Python-program. Dette tallet kan overstige tusen i et komplisert Python-program. Python-navneområdet gjør det lettere for tolken å huske disse objektenes navn.