Python - Closures: Ein Anfänger-Leitfaden

Hallo dort, aufstrebender Python-Programmierer! Heute werden wir eine aufregende Reise in die Welt der Closures antreten. Keine Sorge, wenn du diesen Begriff noch nie gehört hast – am Ende dieses Tutorials wirst du nicht nur verstehen, was Closures sind, sondern auch in der Lage sein, sie in deinem eigenen Code zu erstellen und zu verwenden. Also, lasst uns einsteigen!

Python - Closures

Was ist eine Closure?

Stelle dir vor, du hast eine magische Schachtel, die Dinge auch nach dem Schließen erinnern kann. Das ist essentialerweise, was eine Closure in der Programmierung ist! In Python ist eine Closure ein Funktionobjekt, das Werte im umgebenden Gültigkeitsbereich erinnert, auch wenn sie nicht im Speicher vorhanden sind.

Klingt verwirrend? Lass uns es aufbrechen:

Es ist eine Funktion innerhalb einer anderen Funktion.
Es kann Variablen aus der äußeren Funktion zugreifen.
Es erinnert sich diese Variablen, auch wenn die äußere Funktion abgeschlossen ist.

Stelle dir das als eine Möglichkeit vor, eine kleine Paketfunktion zu erstellen, die ihre eigenen privaten Daten mit sich herumträgt. Cool, nicht wahr?

Gefilterte Funktionen

Bevor wir tiefer in die Closures einsteigen, reden wir über gefilterte Funktionen. Das sind einfach Funktionen, die innerhalb anderer Funktionen definiert sind. Hier ist ein einfaches Beispiel:

def outer_function(x):
def inner_function(y):
return x + y
return inner_function

result = outer_function(10)
print(result(5))  # Ausgabe: 15

In diesem Beispiel ist inner_function in outer_function gefiltert. Die innere Funktion kann auf den Parameter x der äußeren Funktion zugreifen. Dies ist ein Schlüsselkonzept, um Closures zu verstehen.

Variablen-Gültigkeitsbereich

Um Closures wirklich zu verstehen, müssen wir den Variablen-Gültigkeitsbereich in Python verstehen. Es gibt drei Arten von Gültigkeitsbereichen:

Lokaler Gültigkeitsbereich: Variablen, die innerhalb einer Funktion definiert sind
Umfassender Gültigkeitsbereich: Variablen in der äußeren Funktion von gefilterten Funktionen
Globaler Gültigkeitsbereich: Variablen, die auf der obersten Ebene eines Moduls definiert sind

Hier ist ein Beispiel, um dies zu veranschaulichen:

x = "Ich bin global!"  # Globaler Gültigkeitsbereich

def outer():
y = "Ich komme von outer!"  # Umfassender Gültigkeitsbereich
def inner():
z = "Ich bin lokal!"  # Lokaler Gültigkeitsbereich
print(x, y, z)
inner()

outer()

Wenn du diesen Code ausführst, wirst du alle drei Variablen angezeigt bekommen. Die inner-Funktion kann auf Variablen aus allen drei Gültigkeitsbereichen zugreifen!

Eine Closure erstellen

Nun, da wir gefilterte Funktionen und den Variablen-Gültigkeitsbereich verstanden haben, erstellen wir eine Closure. Eine Closure tritt auf, wenn eine gefilterte Funktion auf einen Wert in ihrem umfassenden Gültigkeitsbereich verweist. Hier ist ein Beispiel:

def multiply_by(n):
def multiplier(x):
return x * n
return multiplier

times_two = multiply_by(2)
times_three = multiply_by(3)

print(times_two(5))   # Ausgabe: 10
print(times_three(5)) # Ausgabe: 15

In diesem Beispiel ist multiply_by unsere äußere Funktion und multiplier unsere innere Funktion. Die Magie passiert, wenn wir multiplier zurückgeben – es erinnert sich den Wert von n, auch nachdem multiply_by abgeschlossen ist. Das ist eine Closure!

Lass uns Schritt für Schritt auseinandernehmen:

Wir definieren multiply_by, der einen Parameter n nimmt.
Innerhalb von multiply_by definieren wir multiplier, der einen Parameter x nimmt.
multiplier verwendet sowohl x (sein eigenes Parameter) als auch n (aus der äußeren Funktion).
Wir geben multiplier von multiply_by zurück.
Wenn wir multiply_by(2) aufrufen, gibt es eine Funktion zurück, die immer ihr Eingangszahl verdoppelt.
Ähnlich gibt multiply_by(3) eine Funktion zurück, die immer ihr Eingangszahl verdreifacht.

Das ist die Kraft der Closures – sie können spezialisierte Funktionen spontan erstellen!

Das `nonlocal` Schlüsselwort

Manchmal möchtest du vielleicht eine Variable aus dem umfassenden Gültigkeitsbereich innerhalb deiner inneren Funktion ändern. Python bietet das Schlüsselwort nonlocal für diesen Zweck. Hier ist ein Beispiel:

def counter():
count = 0
def increment():
nonlocal count
count += 1
return count
return increment

my_counter = counter()
print(my_counter())  # Ausgabe: 1
print(my_counter())  # Ausgabe: 2
print(my_counter())  # Ausgabe: 3

In diesem Beispiel ist increment eine Closure, die den Wert der Variablen count aus ihrem umfassenden Gültigkeitsbereich erinnert und verändert. Das Schlüsselwort nonlocal teilt Python mit, dass count keine lokale Variable ist, sondern aus dem umfassenden Gültigkeitsbereich stammt.

Praktische Anwendungen von Closures

Closures sind nicht nur ein cooles Trick – sie haben praktische Anwendungen! Hier sind einige:

Datenverbergen und Kapselung
Erstellung von Funktionsfabriken
Implementierung von Dekoratoren

Sehen wir uns ein reales Weltbeispiel an. Stelle dir vor, du erstellst ein Rabattsystem für einen Online-Shop:

def create_price_adjuster(discount):
def adjust_price(price):
return price * (1 - discount)
return adjust_price

black_friday_sale = create_price_adjuster(0.2)  # 20% Rabatt
cyber_monday_sale = create_price_adjuster(0.15)  # 15% Rabatt

original_price = 100
print(f"Black Friday Preis: ${black_friday_sale(original_price)}")
print(f"Cyber Monday Preis: ${cyber_monday_sale(original_price)}")

Dieser Code erstellt verschiedene Preisfunktionen für verschiedene Verkaufsveranstaltungen, alle verwenden die gleiche Basisfunktion. Das ist die Kraft der Closures!

Zusammenfassung

Herzlichen Glückwunsch! Du hast gerade eines der fortgeschrittenen Merkmale von Python gelernt. Lass uns den Überblick über das, was wir abgedeckt haben:

Konzept	Beschreibung
Closure	Eine Funktion, die Werte im umfassenden Gültigkeitsbereich erinnert
Gefilterte Funktion	Eine Funktion, die innerhalb einer anderen Funktion definiert ist
Variablen-Gültigkeitsbereich	Die Sichtbarkeit von Variablen (lokal, umfassend, global)
`nonlocal`	Schlüsselwort, um Variablen im umfassenden Gültigkeitsbereich zu ändern

Denke daran, wie jeder mächtige Werkzeug, sollten Closures mit Bedacht verwendet werden. Sie sind großartig für bestimmte Aufgaben, aber ihre übermäßige Verwendung kann deinen Code schwerer zu verstehen machen. Übe, experimentiere, und bald wirst du Closures wie ein Python-Profi schwingen!

Happy coding, und denke daran – in Python, wie im Leben, zählt es, was auf der Innenseite (Funktion) ist!

Credits: Image by storyset