In deze tutorial leren we over de naamruimte in Python, de structuur die wordt gebruikt om de symbolische namen te ordenen die aan objecten in een Python-programma zijn toegewezen, waarom naamruimte belangrijk is en hoe we deze in ons Python-programma kunnen gebruiken. Laten we een korte introductie geven over een naamruimte.
Wat is naamruimte?
In Python kun je elk object een unieke naam geven via een naamruimte. Variabelen en methoden zijn voorbeelden van objecten in Python. Anders gezegd: het is een verzameling van de bekende symbolische namen en de details over datgene waarnaar elke naam verwijst. Een naam kan worden gezien als een sleutel in een woordenboek, en objecten zijn de waarden in een naamruimte. We zouden het moeten uitzoeken met een echt model: een naamruimte lijkt op een achternaam. Als er meerdere 'Peter'-namen in de klas zijn, kan het moeilijk zijn om een 'Peter'-naam te vinden; Als we echter specifiek om 'Peter Warner' of 'Peter Cummins' vragen, is het in een klas misschien niet gebruikelijk dat meerdere leerlingen dezelfde voor- en achternaam hebben.
Dankzij de naamruimte kan de Python-interpreter een beter begrip krijgen van de exacte methode of variabele in de code. Als gevolg hiervan bevat de naam aanvullende informatie, waaronder Spatie (gerelateerd aan bereik) en Naam, die een unieke ID aanduidt.
In Python zijn er vier soorten naamruimten, die hieronder worden gegeven.
- Ingebouwd
- Globaal
- Omsluitend
- Lokaal
Omdat deze verschillende naamruimten een levensduur hebben, creëert de Python-interpreter naamruimten als dat nodig is en verwijdert deze wanneer ze niet langer nodig zijn.
substringmethode java
Laten we de verschillende soorten naamruimte in Python begrijpen.
De ingebouwde naamruimte
Zoals de naam al doet vermoeden, bevat het vooraf gedefinieerde namen van alle ingebouwde objecten van Python die al beschikbaar zijn in Python. Laten we deze namen vermelden met de volgende opdracht.
Open de Python-terminal en typ de volgende opdracht.
Commando -
dir(__builtins__)
Uitgang:
['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']
De ingebouwde naamruimte wordt aangemaakt door de Python-interpreter wanneer deze opstart. Deze worden beëindigd wanneer de Python-interpreter wordt beëindigd.
De globale naamruimte
De globale naamruimte bestaat uit alle namen in Python op elk niveau van het hoofdprogramma. Het wordt gemaakt wanneer het hoofdgedeelte wordt uitgevoerd en blijft bestaan totdat de tolk eindigt.
De Python-interpreter creëert een globale naamruimte voor elke module die onze Python laadt met de import-instructie. Bezoek onze Python-module voor meer informatie.
De lokale en omsluitende naamruimten
De lokale naamruimten worden gebruikt door de functie; Wanneer de functie wordt uitgevoerd, maakt de Python-interpreter een nieuwe naamruimte. De lokale naamruimten blijven bestaan nadat de functie is uitgevoerd. Het vermogen kan eveneens uit een ander vermogen bestaan. Zoals hieronder weergegeven, kunnen we de ene functie binnen de andere definiëren.
Voorbeeld -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
In het bovenstaande model wordt de mogelijkheid g() gekarakteriseerd binnen de verzameling f(). We hebben de functie g() binnen de functie f() en de hoofdfunctie f() genoemd. Laten we eens kijken hoe de bovenstaande functie werkt:
- Python maakt een nieuwe naamruimte voor f() wanneer we deze aanroepen.
- Op dezelfde manier roept f() g() aan, g() krijgt zijn eigen andere naamruimte.
- De lokale naamruimte g() is gemaakt voor de omsluitende naamruimte f().
Elk van deze naamruimten wordt beëindigd wanneer de functie wordt beëindigd.
Reikwijdte van het object/de variabele
De term 'scope' specificeert welk codeergebied van een bepaald Python-object toegankelijk is. Elk object en elke variabele heeft een bereik in het programma van waaruit we toegang hebben tot die variabele. Een functievariabele is bijvoorbeeld alleen toegankelijk binnen de functie. Laten we de volgende illustratie bekijken:
Voorbeeld -
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()
Uitgang:
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-naamruimtewoordenboeken
In de vorige tutorial hebben we besproken hoe naamruimten op woordenboeken lijken, met sleutels die objectnamen vertegenwoordigen en waarden die daadwerkelijke objecten vertegenwoordigen. Als woordenboeken gebruikt Python zowel globale als lokale naamruimten. Toegang tot globale en lokale naamruimtewoordenboeken wordt mogelijk gemaakt door de methoden globals() en locals() van Python.
De globals()-methode
De methode globals() retourneert een verwijzing naar het huidige globale naamruimtewoordenboek. We kunnen het gebruiken om toegang te krijgen tot de objecten in de globale naamruimte. Laten we het onderstaande voorbeeld bekijken.
abstracte klasse Java
Voorbeeld -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Zoals we kunnen zien, zijn er veel ingebouwde vermeldingen in globalen() methode. Afhankelijk van uw besturingssysteem en Python-versie kan dit verschillen. Laten we nu de globale variabele definiëren en de verschillen observeren.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Na de toewijzing van a = 20 wordt een nieuwe globale variabele toegewezen aan het globale naamruimtewoordenboek. We hebben toegang tot de waarden zoals we toegang hebben tot de woordenboeken. Laten we het onderstaande voorbeeld bekijken.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 We kunnen de woordenboekwaarde wijzigen met behulp van de functie globals().
invoegsorteer java
>>> globals()['a'] = 100 >>> a 100
Nu zal de nieuwe waarde van a in de mondiale woordenboeken verschijnen.
De locals()-functie
Python biedt ook de locals()-methode, vergelijkbaar met globals(), maar heeft in plaats daarvan toegang tot objecten in de lokale naamruimte. Laten we het volgende voorbeeld bekijken.
Voorbeeld -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Wanneer we func(10, 20) aanroepen, retourneert locals() het woordenboek dat de lokale naamruimte van de functie vertegenwoordigt. In het functiebereik hebben we de lokale variabele str1 gedefinieerd; de lokale naamruimte bevatte de functieargumenten omdat deze lokaal zijn voor de func().
Niettemin, als we de mogelijkheid local people() noemen, werkt deze gelijkwaardig aan de mogelijkheid globals(). De functie globals() en de functie locals() verschillen enigszins. De functie globals() definieert niet alleen aanvullende variabelen, maar slaat ook de geretourneerde waarde op. Het woordenboek bevat de nieuwe variabelen en hun waarden. Kijk eens naar het onderstaande voorbeeld.
Voorbeeld -
>>> 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'} Hier de glob_var is een verwijzing naar het globale naamruimtewoordenboek. De nieuwe toewijzingsverklaringen X En En verscheen in de glob_var woordenboek.
Variabelen wijzigen buiten bereik
In de aanroepende omgeving kan de functie het argument wijzigen door een andere waarde door te geven, maar soms kan de functie de waarde niet wijzigen.
Een onveranderlijk argument kan niet door een functie worden gewijzigd.
Een veranderlijk argument kan op zijn plaats worden gewijzigd, maar kan niet volledig opnieuw worden gedefinieerd.
Laten we het volgende scenario begrijpen.
Voorbeeld -
x = 20 def func(): x = 40 print(x) func() print(x)
Uitgang:
40 20
We definiëren een globale variabele x = 20 en ook in functie met dezelfde naam. Wanneer func() wordt uitgevoerd, wordt er een nieuwe lokale variabele gemaakt die verwijst naar een geheel getalobject waarvan de waarde 40 is. func() body, heeft de opdrachtinstructie geen invloed op het globale object.
Een functie kan echter een object van een veranderlijk type buiten zijn lokale bereik wijzigen. Laten we het onderstaande voorbeeld begrijpen.
wat is structuur in datastructuur
Voorbeeld -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
De my_list is een lijst en is van het veranderlijke type. De func() kan binnen my_list worden gewijzigd, ook al valt deze buiten het lokale bereik. Maar als we proberen de my_list opnieuw toe te wijzen, wordt het nieuwe lokale object gemaakt en wordt de globale my_list niet gewijzigd. Laten we het onderstaande voorbeeld bekijken.
Voorbeeld -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Uitgang:
['A', 'B', 'C', 'D', 'E']
Conclusie
Wij zorgen voor de naamruimte, hoe we deze kunnen gebruiken en de graad van de variabele. Met een kort Python-programma kunnen talloze afzonderlijke objecten worden gemaakt. In een ingewikkeld Python-programma kan dit aantal de duizend overschrijden. De Python-naamruimte maakt het voor de tolk gemakkelijker om de namen van deze objecten te onthouden.