Python Closures erklärt: Wie verschachtelte Funktionen Variablen erfassen

Python Closures

Entdecken Sie, wie Python Closures funktionieren, wie man sie definiert und warum sie für sauberen, effizienten Code unverzichtbar sind.

Nicht-lokale Variablen in einer verschachtelten Funktion

Bevor wir Closures erforschen, ist es entscheidend, verschachtelte Funktionen und nicht-lokale Variablen zu verstehen. Eine Funktion, die innerhalb einer anderen Funktion definiert ist, heißt verschachtelte Funktion. Solche Funktionen können Variablen aus ihrem umgebenden Scope lesen.

In Python sind diese nicht-lokalen Variablen standardmäßig schreibgeschützt. Um sie zu modifizieren, müssen Sie die Variable explizit als nonlocal innerhalb der verschachtelten Funktion deklarieren.

Unten ist ein einfaches Beispiel, das eine verschachtelte Funktion zeigt, die auf eine nicht-lokale Variable zugreift.

def print_msg(msg):
    # Äußere Funktion
    def printer():
        # Verschachtelte Funktion
        print(msg)
    printer()  # Ausführen
print_msg("Hallo")

Ausgabe

Hallo

Die verschachtelte printer()-Funktion kann auf die msg-Variable aus ihrem äußeren Scope zugreifen.

---

Eine Closure-Funktion definieren

Was wäre, wenn die äußere Funktion die verschachtelte Funktion zurückgäbe, anstatt sie aufzurufen? Der Code sähe so aus:

def print_msg(msg):
    def printer():
        print(msg)
    return printer  # Verschachtelte Funktion zurückgeben
# Zurückgegebene Funktion speichern
another = print_msg("Hallo")
another()

Ausgabe

Hallo

Beachten Sie, dass die Funktion printer sich den Wert von msg immer noch merkt, selbst nachdem print_msg die Ausführung beendet hat. Dieses Phänomen – wo eine Funktion Zugriff auf Variablen aus ihrem Definitions-Scope behält – nennt man in Python einen Closure.

Um dies weiter zu veranschaulichen, löschen Sie die ursprüngliche Funktion und sehen Sie, dass die zurückgegebene Funktion immer noch funktioniert:

>>> del print_msg
>>> another()
Hallo
>>> print_msg("Hallo")
Traceback (most recent call last):
... NameError: name 'print_msg' is not defined

Die zurückgegebene Funktion funktioniert weiterhin, weil sie die notwendigen Daten in ihrem Closure erfasst hat.

---

Wann haben wir Closures?

In Python existiert ein Closure, wenn eine verschachtelte Funktion:

• innerhalb einer anderen Funktion definiert ist.
• eine Variable aus ihrer umgebenden Funktion referenziert.
• von der äußeren Funktion zurückgegeben wird.

---

Wann Closures verwenden?

Closures bieten mehrere Vorteile:

• Sie eliminieren die Notwendigkeit globaler Variablen und verbessern die Kapselung.
• Sie bieten eine leichte Alternative zu Ein-Methode-Klassen und halten Code prägnant.
• Sie ermöglichen funktionale Muster wie Decorators, wo eine Wrapper-Funktion Zugriff auf die Argumente der ursprünglichen Funktion benötigt.

Unten ist ein häufiges Beispiel: Eine Factory, die Multiplikator-Funktionen erstellt.

def make_multiplier_of(n):
    def multiplier(x):
        return x * n
    return multiplier
# Spezifische Multiplikatoren erstellen
times3 = make_multiplier_of(3)
times5 = make_multiplier_of(5)
print(times3(9))  # 27
print(times5(3))  # 15
print(times5(times3(2)))  # 30

Ausgabe

27 15 30

Pythons Decorator-Syntax basiert stark auf Closures. Wenn Sie einen Decorator schreiben, erfasst die Wrapper-Funktion die Funktion, die sie dekoriert, und bildet einen Closure.

Um einen Closure zu inspizieren, verwenden Sie das __closure__-Attribut. Es gibt ein Tupel von Zellenobjekten zurück, die die eingeschlossenen Werte halten. Zum Beispiel:

>>> make_multiplier_of.__closure__
>>> times3.__closure__
(<cell at 0x0000000002D155B8: int object at 0x000000001E39B6E0>,)

Das cell_contents-Attribut jeder Zelle hält den tatsächlichen Wert, der vom Closure erfasst wurde:

>>> times3.__closure__[0].cell_contents
3
>>> times5.__closure__[0].cell_contents
5

Closures zu verstehen befähigt Sie, saubereren, modulareren Python-Code zu schreiben, der unnötige Globals vermeidet und funktionale Paradigmen umarmt.