Python Academy · Lektion

nonlocal und veränderlicher Zustand

Den einschließenden Gültigkeitsbereich ändern

nonlocal und veränderlicher Zustand ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Lesen und Schreiben einschließender Variablen

Eine innere Funktion kann eine einschließende Variable problemlos lesen. Wenn sie jedoch versucht, diesem Namen einen Wert zuzuweisen, behandelt Python ihn stattdessen als neue lokale Variable. Das überrascht Anfänger häufig.

def outer():
    count = 0
    def inner():
        return count
    return inner()
print(outer())

Die Zuweisungsfalle

Wenn Sie einem einschließenden Namen einen Wert zuweisen, ohne Ihre Absicht zu deklarieren, wird er lokal. Dadurch wird die äußere Variable nie aktualisiert. Die Änderung geht hier verloren.

def outer():
    count = 0
    def bump():
        count = count + 1
    try:
        bump()
    except UnboundLocalError as e:
        print('Error:', e)
outer()

Das Schlüsselwort nonlocal

nonlocal deklariert, dass sich ein Name auf eine Variable im nächstgelegenen einschließenden Funktions-Gültigkeitsbereich bezieht. Dadurch aktualisieren Zuweisungen diese äußere Variable, anstatt eine lokale zu erstellen.

def outer():
    count = 0
    def bump():
        nonlocal count
        count += 1
    bump()
    bump()
    return count
print(outer())

Eine Counter-Closure

Mit nonlocal können Sie einen zustandsbehafteten Zähler erstellen. Jeder Aufruf verändert die erfasste Variable und merkt sich den bisherigen Stand.

def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment
c = make_counter()
print(c())
print(c())
print(c())

Unabhängige Zähler

Jeder Zähler behält seinen eigenen Zustand, weil jede Closure eine eigene Variable erfasst.

def make_counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc
a = make_counter()
b = make_counter()
print(a(), a(), b())

nonlocal und global im Vergleich

nonlocal bezieht sich auf den einschließenden Funktions-Gültigkeitsbereich, während global auf die Modulebene verweist. Verwenden Sie nonlocal für Closures und global für modulweiten Zustand.

total = 0
def add_global(n):
    global total
    total += n
add_global(5)
add_global(3)
print(total)

Veränderlicher Zustand ohne nonlocal

Wenn der einschließende Wert ein veränderliches Objekt wie eine Liste oder ein dict ist, können Sie es ohne nonlocal direkt verändern, weil Sie den Namen nicht neu binden.

def make_logger():
    history = []
    def log(msg):
        history.append(msg)
        return history
    return log
log = make_logger()
log('start')
print(log('stop'))

Ein Akkumulator

Durch die Kombination von nonlocal und einer Closure entsteht ein fortlaufender Akkumulator, der jeden Wert zu einer gespeicherten Summe addiert.

def make_accumulator():
    total = 0
    def add(n):
        nonlocal total
        total += n
        return total
    return add
acc = make_accumulator()
print(acc(10))
print(acc(5))
print(acc(100))

Ein einfacher Umschalter

nonlocal macht es einfach, einen booleschen Zustand zwischen Aufrufen umzuschalten.

def make_toggle():
    on = False
    def toggle():
        nonlocal on
        on = not on
        return on
    return toggle
t = make_toggle()
print(t(), t(), t())

Zustand zurücksetzen

Sie können mehrere innere Funktionen bereitstellen, die denselben einschließenden Zustand teilen, beispielsweise eine zum Addieren und eine zum Zurücksetzen.

def make_bank():
    balance = 0
    def deposit(n):
        nonlocal balance
        balance += n
        return balance
    def reset():
        nonlocal balance
        balance = 0
        return balance
    return deposit, reset
deposit, reset = make_bank()
print(deposit(50))
print(reset())

nonlocal benötigt eine vorhandene Variable

nonlocal setzt voraus, dass der Name bereits in einem einschließenden Gültigkeitsbereich existiert. Andernfalls löst Python zum Zeitpunkt der Definition einen SyntaxError aus. Das Schlüsselwort kann keine neue äußere Variable erstellen.

def outer():
    value = 'set'
    def inner():
        nonlocal value
        value = 'changed'
    inner()
    return value
print(outer())

Wissenscheck

Sie möchten innerhalb einer verschachtelten Funktion eine Variable der einschließenden Funktion neu zuweisen. Welches Schlüsselwort verwenden Sie?

Rückblick: nonlocal und veränderlicher Zustand

Zusammenfassung:

Eine Zuweisung an einen einschließenden Namen erstellt normalerweise eine neue lokale Variable. nonlocal verhindert dies.
nonlocal bezieht sich auf den einschließenden Funktions-Gültigkeitsbereich, global auf das Modul.
Das direkte Verändern eines veränderlichen Objekts benötigt keine Deklaration.
Closures mit nonlocal erstellen Zähler, Akkumulatoren und Umschalter, die ihren Zustand speichern.

def make_counter():
    n = 0
    def inc():
        nonlocal n
        n += 1
        return n
    return inc
c = make_counter()
print(c(), c())

Häufig gestellte Fragen

Ist die Lektion „nonlocal und veränderlicher Zustand“ kostenlos?

Ja — der vollständige Text von „nonlocal und veränderlicher Zustand“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „nonlocal und veränderlicher Zustand“?

Den einschließenden Gültigkeitsbereich ändern Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „nonlocal und veränderlicher Zustand“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy