Python Namespaces & Variablen-Gültigkeitsbereich: Namen, Bindings & Scopes verstehen

Python Namespaces & Variablen-Gültigkeitsbereich

Erforschen Sie, wie Namen, Namespaces und Variablen-Gültigkeitsbereiche in Python funktionieren, mit klaren Beispielen und Best Practices.

Was ist ein Name in Python?

In „The Zen of Python“ (import this) lautet die letzte Zeile: „Namespaces are one honking great idea -- let's do more of those!“ Was sind also diese Namespaces? Zuerst definieren wir einen Namen.

Ein Name, oder Bezeichner, ist ein Label, das ein Objekt referenziert. Alles in Python ist ein Objekt, und ein Name bietet eine bequeme Möglichkeit, darauf zuzugreifen.

Zum Beispiel, wenn wir a = 2 ausführen, wird die Ganzzahl 2 im Speicher gespeichert und a wird zu ihrer Referenz. Die eingebaute id()-Funktion gibt die Speicheradresse eines Objekts zurück.

# Hinweis: Ihre id-Werte können abweichen
a = 2
print('id(2) =', id(2))
print('id(a) =', id(a))

Ausgabe

id(2) = 9302208
id(a) = 9302208

Beide Namen zeigen auf dasselbe Objekt, daher stimmen ihre id()-Werte überein. Sehen wir, was passiert, wenn wir a neu binden:

# Hinweis: Ihre id-Werte können abweichen
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

Wenn a = a + 1 ausgeführt wird, wird ein neues Objekt 3 erstellt, und a referenziert nun dieses. Beachten Sie, dass id(a) und id(3) identisch sind. Die anschließende Zuweisung b = 2 bindet b einfach an das existierende 2-Objekt, wodurch doppelte Speicherung vermieden wird.

Diese dynamische Namensbindung macht Python flexibel: Ein einzelner Bezeichner kann auf Werte jedes Typs verweisen – einschließlich Funktionen.

def printHello():
    print("Hello")
a = printHello
a()

Ausgabe

Hello

Der Bezeichner a referenziert nun die Funktion printHello, die wir direkt aufrufen können.

---

Was ist ein Namespace?

Ein Namespace ist eine Abbildung von Namen zu Objekten. Denken Sie an ihn als Dictionary, das jeden definierten Bezeichner zusammen mit seinem assoziierten Objekt hält.

Python unterstützt mehrere Namespaces gleichzeitig, die voneinander isoliert sind. Der Interpreter erstellt einen globalen Namespace, der alle eingebauten Namen enthält und für die Dauer der Sitzung besteht. Jedes Modul erhält seinen eigenen globalen Namespace, und jede Funktions- oder Klassendefinition führt einen neuen lokalen Namespace ein.

---

Variablen-Gültigkeitsbereich in Python

Während Namespaces existieren, bestimmt der Scope, wo ein Name ohne Qualifizierung zugegriffen werden kann.

Zu jedem Zeitpunkt hat ein Programm mindestens drei verschachtelte Scopes:

1. Der lokale Scope der aktuell ausgeführten Funktion.
2. Der globale Scope des Moduls.
3. Der eingebaute Scope, der immer verfügbar ist.

Wenn ein Name innerhalb einer Funktion referenziert wird, sucht Python zuerst im lokalen Namespace, dann im globalen und schließlich im eingebauten Namespace. Enthält eine Funktion eine weitere Funktion, führt die innere einen neuen, verschachtelten Scope ein.

---

Beispiel: Scope und Namespace-Interaktion

Betrachten Sie den folgenden Code:

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

Hier lebt a im globalen Namespace des Moduls. Die Variable b ist lokal zu outer_function, und c gehört zum verschachtelten lokalen Namespace von inner_func.

Innerhalb von inner_func ist c lokal, b ist non-local, und a ist global. Sie können c lesen und schreiben, aber b und a nur lesen, es sei denn, Sie deklarieren sie explizit mit global oder nonlocal.

Hier ist eine konkretere Illustration:

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)

Die Ausgabe demonstriert drei distincte a-Bindings:

a = 30
a = 20
a = 10

Um alle Zuweisungen auf das globale a zu erzwingen, verwenden Sie das global-Schlüsselwort:

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 spiegelt nun ein einzelnes, globales a wider:

a = 30
a = 30
a = 30

Diese Beispiele veranschaulichen, wie Pythons Namespace- und Scope-Regeln die Sichtbarkeit und Mutation von Variablen regeln.