In diesem Tutorial erfahren wir mehr über den Namespace in Python, die Struktur, die zum Organisieren der symbolischen Namen verwendet wird, die Objekten in einem Python-Programm zugewiesen werden, warum Namespace wichtig ist und wie wir sie in unserem Python-Programm verwenden können. Lassen Sie uns eine kurze Einführung in einen Namespace geben.
Was ist Namespace?
In Python besteht die Möglichkeit, jedem Objekt einen eindeutigen Namen zu geben, in einem Namespace. Variablen und Methoden sind Beispiele für Objekte in Python. Anders ausgedrückt handelt es sich um eine Sammlung bekannter symbolischer Namen und der Details zu der Sache, auf die sich jeder Name bezieht. Ein Name kann als Schlüssel in einem Wörterbuch betrachtet werden, und Objekte sind die Werte in einem Namespace. Wir sollten es mit einem echten Modell herausfinden: Ein Namespace ähnelt einem Nachnamen. Wenn es in der Klasse mehrere „Peter“-Namen gibt, kann es schwierig sein, einen „Peter“-Namen zu finden; Wenn wir jedoch in einer Klasse ausdrücklich nach „Peter Warner“ oder „Peter Cummins“ fragen, ist es möglicherweise nicht üblich, dass mehrere Schüler denselben Vor- und Nachnamen haben.
Dank des Namespace kann der Python-Interpreter die genaue Methode oder Variable im Code besser verstehen. Daher enthält sein Name zusätzliche Informationen, einschließlich Leerzeichen (bezogen auf den Bereich) und Name, der eine eindeutige Kennung bezeichnet.
In Python gibt es vier Arten von Namespaces, die unten aufgeführt sind.
- Eingebaut
- Global
- Einschließen
- Lokal
Da diese verschiedenen Namespaces eine Lebensdauer haben, erstellt der Python-Interpreter bei Bedarf Namespaces und löscht sie, wenn sie nicht mehr benötigt werden.
Lassen Sie uns die verschiedenen Arten von Namespaces in Python verstehen.
Der integrierte Namespace
Wie der Name schon sagt, enthält es vordefinierte Namen aller integrierten Python-Objekte, die bereits in Python verfügbar sind. Lassen Sie uns diese Namen mit dem folgenden Befehl auflisten.
Öffnen Sie das Python-Terminal und geben Sie den folgenden Befehl ein.
Befehl -
dir(__builtins__)
Ausgabe:
['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']
Der integrierte Namespace wird vom Python-Interpreter beim Start erstellt. Diese werden beendet, wenn der Python-Interpreter beendet wird.
Der globale Namespace
Der globale Namespace besteht aus beliebigen Namen in Python auf jeder Ebene des Hauptprogramms. Es wird erstellt, wenn der Hauptteil ausgeführt wird, und bleibt bestehen, bis der Interpreter beendet wird.
Der Python-Interpreter erstellt einen globalen Namensraum für jedes Modul, das unser Python mit der Import-Anweisung lädt. Weitere Informationen finden Sie in unserem Python-Modul.
Scanner Java
Die lokalen und umschließenden Namespaces
Die lokalen Namespaces werden von der Funktion verwendet; Wenn die Funktion ausgeführt wird, erstellt der Python-Interpreter einen neuen Namespace. Die lokalen Namespaces bleiben bestehen, nachdem die Funktion ausgeführt wurde. Die Fähigkeit kann auch eine andere Fähigkeit umfassen. Wie unten gezeigt, können wir eine Funktion innerhalb einer anderen definieren.
Beispiel -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
Im obigen Modell wird die Fähigkeit g() innerhalb der Sammlung von f() charakterisiert. Wir haben die Funktion g() innerhalb der Funktion f() und der Hauptfunktion f() aufgerufen. Schauen wir uns an, wie die obige Funktion funktioniert:
- Python erstellt einen neuen Namespace für f(), wenn wir es aufrufen.
- Ebenso erhält f() einen eigenen Namensraum, wenn g() aufgerufen wird.
- Der lokale Namensraum g() wurde für den umschließenden Namensraum f() erstellt.
Jeder dieser Namespaces wird beendet, wenn die Funktion beendet wird.
Umfang des Objekts/der Variablen
Der Begriff „Bereich“ gibt an, auf welchen Codierungsbereich eines bestimmten Python-Objekts zugegriffen werden kann. Jedes Objekt und jede Variable hat einen Bereich im Programm, von dem aus wir auf diese Variable zugreifen können. Beispielsweise kann auf eine Funktionsvariable nur innerhalb der Funktion zugegriffen werden. Sehen wir uns die folgende Abbildung an:
Beispiel -
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()
Ausgabe:
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-Wörterbücher
Im vorherigen Tutorial haben wir darüber gesprochen, dass Namespaces wie Wörterbücher sind, wobei Schlüssel Objektnamen und Werte tatsächliche Objekte darstellen. Als Wörterbücher verwendet Python sowohl globale als auch lokale Namensräume. Der Zugriff auf globale und lokale Namespace-Wörterbücher wird durch die Methoden globals() und locals() von Python ermöglicht.
Die globals()-Methode
Die Methode globals() gibt einen Verweis auf das aktuelle globale Namespace-Wörterbuch zurück. Wir können damit auf die Objekte im globalen Namensraum zugreifen. Sehen wir uns das folgende Beispiel an.
Beispiel -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Wie wir sehen können, gibt es viele integrierte Einträge globals() Methode. Dies kann je nach Betriebssystem und Python-Version unterschiedlich sein. Definieren wir nun die globale Variable und beobachten wir die Unterschiede.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Nach der Zuweisung von a = 20 wird eine neue globale Variable dem globalen Namespace-Wörterbuch zugewiesen. Wir können auf die Werte zugreifen, wie wir in den Wörterbüchern darauf zugreifen. Sehen wir uns das folgende Beispiel an.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Wir können den Wörterbuchwert mit der Funktion globals() ändern.
>>> globals()['a'] = 100 >>> a 100
Jetzt wird der neue Wert von a in den globalen Wörterbüchern angezeigt.
Die Funktion locals()
Python bietet auch die Methode locals() ähnlich wie globals() an, greift jedoch stattdessen auf Objekte im lokalen Namespace zu. Sehen wir uns das folgende Beispiel an.
Mission Impossible alle Filme
Beispiel -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Wenn wir func(10, 20) aufrufen, gibt locals() das Wörterbuch zurück, das den lokalen Namespace der Funktion darstellt. Im Funktionsumfang haben wir die lokale Variable str1 definiert; Der lokale Namespace enthielt die Funktionsargumente, da sie lokal für func() sind.
Wenn wir jedoch die Funktion „local people()“ aufrufen, verhält sie sich gleichbedeutend mit der Funktion „globals()“. Die Funktion globals() und die Funktion locals() unterscheiden sich geringfügig. Die Funktion globals() definiert nicht nur zusätzliche Variablen, sondern speichert auch den Rückgabewert. Das Wörterbuch enthält die neuen Variablen und ihre Werte. Schauen Sie sich das Beispiel unten an.
Beispiel -
>>> 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 das glob_var ist ein Verweis auf das globale Namespace-Wörterbuch. Die neuen Zuweisungsanweisungen X Und Und erschien in der glob_var Wörterbuch.
Ändern von Variablen außerhalb des Gültigkeitsbereichs
In der aufrufenden Umgebung kann die Funktion das Argument ändern, indem sie einen anderen Wert übergibt, aber manchmal kann sie den Wert nicht ändern.
Ein unveränderliches Argument kann nicht durch eine Funktion geändert werden.
Ein veränderliches Argument kann an Ort und Stelle geändert, aber nicht vollständig neu definiert werden.
Lassen Sie uns das folgende Szenario verstehen.
Beispiel -
x = 20 def func(): x = 40 print(x) func() print(x)
Ausgabe:
Betriebssystem
40 20
Wir definieren eine globale Variable x = 20 und auch eine gleichnamige Funktion. Wenn func() ausgeführt wird, erstellt es die neue lokale Variablenreferenz auf ein ganzzahliges Objekt, dessen Wert 40 ist. Innerhalb der func() body hat die Zuweisungsanweisung keinen Einfluss auf das globale Objekt.
Eine Funktion kann jedoch ein Objekt eines veränderlichen Typs außerhalb seines lokalen Gültigkeitsbereichs ändern. Lassen Sie uns das folgende Beispiel verstehen.
Beispiel -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
Die my_list ist eine Liste und vom veränderlichen Typ. Die Funktion func() kann innerhalb von my_list geändert werden, auch wenn sie außerhalb des lokalen Bereichs liegt. Wenn wir jedoch versuchen, die my_list neu zuzuweisen, wird das neue lokale Objekt erstellt und die globale my_list nicht geändert. Sehen wir uns das folgende Beispiel an.
Beispiel -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Ausgabe:
['A', 'B', 'C', 'D', 'E']
Abschluss
Wir kümmern uns um den Namensraum, wie wir ihn nutzen können und den Grad der Variablen. Mit einem kurzen Python-Programm können zahlreiche unterschiedliche Objekte erstellt werden. In einem komplizierten Python-Programm kann diese Zahl eintausend überschreiten. Der Python-Namespace erleichtert es dem Interpreter, sich die Namen dieser Objekte zu merken.