In diesem Lernprogramm erfahren Sie mehr über den Namespace, die Zuordnung von Namen zu Objekten und den Umfang einer Variablen.
Was ist der Name in Python?
Wenn Sie jemals 'The Zen of Python' gelesen haben (geben Sie import thisden Python-Interpreter ein), heißt es in der letzten Zeile: Namespaces sind eine großartige Idee - machen wir mehr davon! Was sind diese mysteriösen Namespaces? Schauen wir uns zuerst an, wie der Name lautet.
Name (auch als Bezeichner bezeichnet) ist einfach ein Name, der Objekten gegeben wird. Alles in Python ist ein Objekt. Name ist eine Möglichkeit, auf das zugrunde liegende Objekt zuzugreifen.
Wenn wir beispielsweise die Zuweisung durchführen a = 2, 2wird ein Objekt im Speicher gespeichert und a ist der Name, mit dem wir es verknüpfen. Wir können die Adresse (im RAM) eines Objekts über die integrierte Funktion abrufen id(). Schauen wir uns an, wie man es benutzt.
# Note: You may get different values for the id a = 2 print('id(2) =', id(2)) print('id(a) =', id(a))
Ausgabe
id (2) = 9302208 id (a) = 9302208
Hier beziehen sich beide auf dasselbe Objekt 2, haben also dasselbe id(). Lassen Sie uns die Dinge etwas interessanter machen.
# Note: You may get different values for the id a = 2 print('id(a) =', id(a)) a = a+1 print('id(a) =', id(a)) print('id(3) =', id(3)) b = 2 print('id(b) =', id(b)) print('id(2) =', id(2))
Ausgabe
ID (a) = 9302208 ID (a) = 9302240 ID (3) = 9302240 ID (b) = 9302208 ID (2) = 9302208
Was passiert in der obigen Abfolge von Schritten? Lassen Sie uns dies anhand eines Diagramms erklären:
Speicherdiagramm von Variablen in Python
Zunächst wird ein Objekt 2erstellt und der Name a wird ihm zugeordnet. Wenn wir dies tun a = a+1, wird ein neues Objekt 3erstellt, und jetzt wird a diesem Objekt zugeordnet.
Beachten Sie das id(a)und id(3)haben die gleichen Werte.
Außerdem wird bei der b = 2Ausführung der neue Name b dem vorherigen Objekt zugeordnet 2.
Dies ist effizient, da Python kein neues doppeltes Objekt erstellen muss. Diese dynamische Art der Namensbindung macht Python leistungsfähig. Ein Name kann sich auf einen beliebigen Objekttyp beziehen.
>>> a = 5 >>> a = 'Hello World!' >>> a = (1,2,3)
All dies ist gültig und a bezieht sich auf drei verschiedene Arten von Objekten in verschiedenen Instanzen. Funktionen sind ebenfalls Objekte, sodass ein Name auch auf sie verweisen kann.
def printHello(): print("Hello") a = printHello a()
Ausgabe
Hallo
Der gleiche Name a kann sich auf eine Funktion beziehen, und wir können die Funktion unter diesem Namen aufrufen.
Was ist ein Namespace in Python?
Nachdem wir verstanden haben, was Namen sind, können wir zum Konzept der Namespaces übergehen.
Einfach ausgedrückt ist ein Namespace eine Sammlung von Namen.
In Python können Sie sich einen Namespace als Zuordnung jedes von Ihnen definierten Namens zu entsprechenden Objekten vorstellen.
Verschiedene Namespaces können zu einem bestimmten Zeitpunkt nebeneinander existieren, sind jedoch vollständig isoliert.
Ein Namespace mit allen integrierten Namen wird beim Starten des Python-Interpreters erstellt und ist vorhanden, solange der Interpreter ausgeführt wird.
Dies ist der Grund , die integrierten Funktionen wie id(), print()usw. sind wir aus jedem Teil des Programms immer zur Verfügung. Jedes Modul erstellt einen eigenen globalen Namespace.
Diese verschiedenen Namespaces sind isoliert. Daher kollidiert derselbe Name, der in verschiedenen Modulen vorhanden sein kann, nicht.
Module können verschiedene Funktionen und Klassen haben. Beim Aufruf einer Funktion wird ein lokaler Namespace erstellt, in dem alle Namen definiert sind. Ähnlich ist es bei der Klasse. Das folgende Diagramm kann zur Verdeutlichung dieses Konzepts beitragen.
Ein Diagramm verschiedener Namespaces in Python
Python-Variablenbereich
Obwohl verschiedene eindeutige Namespaces definiert sind, können wir möglicherweise nicht von jedem Teil des Programms auf alle zugreifen. Das Konzept des Umfangs kommt ins Spiel.
Ein Bereich ist der Teil eines Programms, von dem aus direkt ohne Präfix auf einen Namespace zugegriffen werden kann.
Zu jedem Zeitpunkt gibt es mindestens drei verschachtelte Bereiche.
- Umfang der aktuellen Funktion mit lokalen Namen
- Umfang des Moduls mit globalen Namen
- Äußerster Bereich mit integrierten Namen
Wenn innerhalb einer Funktion eine Referenz erstellt wird, wird der Name im lokalen Namespace, dann im globalen Namespace und schließlich im integrierten Namespace gesucht.
Wenn sich eine Funktion in einer anderen Funktion befindet, ist ein neuer Bereich im lokalen Bereich verschachtelt.
Beispiel für Umfang und Namespace in Python
def outer_function(): b = 20 def inner_func(): c = 30 a = 10
Here, the variable a is in the global namespace. Variable b is in the local namespace of outer_function() and c is in the nested local namespace of inner_function().
When we are in inner_function(), c is local to us, b is nonlocal and a is global. We can read as well as assign new values to c but can only read b and a from inner_function().
If we try to assign as a value to b, a new variable b is created in the local namespace which is different than the nonlocal b. The same thing happens when we assign a value to a.
However, if we declare a as global, all the reference and assignment go to the global a. Similarly, if we want to rebind the variable b, it must be declared as nonlocal. The following example will further clarify this.
def outer_function(): a = 20 def inner_function(): a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)
As you can see, the output of this program is
a = 30 a = 20 a = 10
In diesem Programm werden drei verschiedene Variablen a in separaten Namespaces definiert und entsprechend aufgerufen. Während im folgenden Programm,
def outer_function(): global a a = 20 def inner_function(): global a a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)
Die Ausgabe des Programms ist.
a = 30 a = 30 a = 30
Hier beziehen sich alle Verweise und Zuweisungen aufgrund der Verwendung von Schlüsselwörtern auf das globale a global.
