Python-Namespace und -Bereich

In diesem Tutorial lernen Sie Namensräume, die Zuordnung von Namen zu Objekten und den Geltungsbereich einer Variablen kennen.

Was ist Name in Python?

Wenn Sie jemals „The Zen of Python“ gelesen haben (geben Sie import this ein im Python-Interpreter), heißt es in der letzten Zeile:Namespaces sind eine tolle Idee – machen wir mehr davon! Was sind also diese mysteriösen Namespaces? Schauen wir uns zuerst an, was Name ist.

Name (auch Bezeichner genannt) 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.

Zum Beispiel, wenn wir die Aufgabe a = 2 machen , 2 ist ein im Speicher gespeichertes Objekt und a ist der Name, mit dem wir es verbinden. Wir können die Adresse (im RAM) eines Objekts durch die eingebaute Funktion id() erhalten . 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 , also haben sie denselben id() . Lassen Sie uns die Dinge ein wenig 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 Schrittfolge? Lassen Sie uns ein Diagramm verwenden, um dies zu erklären:

Zunächst ein Objekt 2 erstellt und der Name a ist damit verbunden, wenn wir a = a+1 machen , ein neues Objekt 3 erstellt und jetzt a ist diesem Objekt zugeordnet.

Beachten Sie, dass id(a) und id(3) dieselben Werte haben.

Außerdem, wenn b = 2 ausgeführt wird, der neue Name b wird mit dem vorherigen Objekt 2 verknüpft .

Dies ist effizient, da Python kein neues doppeltes Objekt erstellen muss. Diese dynamische Art der Namensbindung macht Python mächtig; ein Name kann sich auf jede Art von Objekt beziehen.

>>> a = 5
>>> a = 'Hello World!'
>>> a = [1,2,3]

Alle diese sind gültig und a bezieht sich auf drei verschiedene Arten von Objekten in verschiedenen Instanzen. Funktionen sind ebenfalls Objekte, daher kann sich ein Name auch auf sie beziehen.

def printHello():
    print("Hello")


a = printHello

a()

Ausgabe

Hello

Derselbe Name a kann auf eine Funktion verweisen und wir können die Funktion unter diesem Namen aufrufen.

Was ist ein Namespace in Python?

Nachdem wir nun verstanden haben, was Namen sind, können wir zum Konzept der Namespaces übergehen.

Einfach ausgedrückt ist ein Namensraum eine Sammlung von Namen.

In Python können Sie sich einen Namensraum als Zuordnung jedes von Ihnen definierten Namens zu entsprechenden Objekten vorstellen.

Verschiedene Namespaces können zu einem bestimmten Zeitpunkt nebeneinander existieren, sind aber vollständig isoliert.

Ein Namensraum, der alle eingebauten Namen enthält, wird erstellt, wenn wir den Python-Interpreter starten, und existiert, solange der Interpreter läuft.

Das ist der Grund dafür, dass eingebaute Funktionen wie id() , print() etc. stehen uns aus jedem Teil des Programms immer zur Verfügung. Jedes Modul erstellt seinen eigenen globalen Namensraum.

Diese unterschiedlichen 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 Namensraum erstellt, in dem alle Namen definiert sind. Ähnlich verhält es sich mit der Klasse. Das folgende Diagramm kann helfen, dieses Konzept zu verdeutlichen.

Python-Variablenbereich

Obwohl verschiedene eindeutige Namespaces definiert sind, können wir möglicherweise nicht von jedem Teil des Programms aus auf alle zugreifen. Das Konzept des Geltungsbereichs kommt ins Spiel.

Ein Gültigkeitsbereich ist der Teil eines Programms, von dem aus direkt ohne Präfix auf einen Namensraum zugegriffen werden kann.

Zu jedem Zeitpunkt gibt es mindestens drei verschachtelte Bereiche.

Geltungsbereich der aktuellen Funktion, die lokale Namen hat
Geltungsbereich des Moduls mit globalen Namen
Äußerster Geltungsbereich mit integrierten Namen

Wenn eine Referenz innerhalb einer Funktion gemacht wird, wird der Name im lokalen Namensraum gesucht, dann im globalen Namensraum und schließlich im eingebauten Namensraum.

Wenn es eine Funktion innerhalb einer anderen Funktion gibt, wird ein neuer Gültigkeitsbereich innerhalb des lokalen Gültigkeitsbereichs verschachtelt.

Beispiel für Geltungsbereich und Namespace in Python

def outer_function():
    b = 20
    def inner_func():
        c = 30

a = 10

Hier die Variable a befindet sich im globalen Namensraum. Variable b befindet sich im lokalen Namespace von outer_function() und c befindet sich im verschachtelten lokalen Namespace von inner_function() .

Wenn wir in inner_function() sind , c ist für uns lokal, b ist nichtlokal und a ist global. Wir können c sowohl lesen als auch neue Werte zuweisen kann aber nur b lesen und ein ab inner_function() .

Wenn wir versuchen, b als Wert zuzuweisen , eine neue Variable b wird im lokalen Namensraum erstellt, der sich vom nichtlokalen b unterscheidet . Dasselbe passiert, wenn wir a einen Wert zuweisen .

Wenn wir jedoch a als global gehen alle Verweise und Zuweisungen auf das globale a . Ebenso, wenn wir die Variable b neu binden wollen , muss es als nichtlokal deklariert werden. Das folgende Beispiel soll dies weiter verdeutlichen.

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)

Wie Sie sehen können, ist die Ausgabe dieses Programms

a = 30
a = 20
a = 10

In diesem Programm werden drei verschiedene Variablen a werden in separaten Namespaces definiert und entsprechend aufgerufen. Während Sie sich im folgenden Programm befinden,

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 auf das globale a aufgrund der Verwendung des Schlüsselworts global .

Python-Operatoren Python if...else-Anweisung

Python