Globale Variablen in Python

Globale Variablen in Python sind Variablen, die außerhalb einer Funktion deklariert werden. Sie leben während der gesamten Laufzeit des Programms und können von überall gelesen werden — um sie jedoch innerhalb einer Funktion zu ändern, ist das Schlüsselwort global erforderlich. Diese Seite erklärt, wie globale Variablen funktionieren, welche Fallstricke es zu vermeiden gilt und wann es sinnvoll ist, auf bessere Alternativen zurückzugreifen.

Was sind globale Variablen?

Eine globale Variable wird im Modul-Gültigkeitsbereich (auf oberster Ebene) erstellt — außerhalb einer Funktion oder Klasse. Jeder Code im selben Modul kann sie ohne besondere Deklaration lesen.

Python verwendet die LEGB-Regel zur Namensauflösung: Es durchsucht der Reihe nach lokale (Local), einschließende (Enclosing), globale (Global) und eingebaute (Built-in) Gültigkeitsbereiche. Eine globale Variable befindet sich auf der „G"-Ebene, sodass jede Funktion sie findet, nachdem sie ihren eigenen lokalen und einschließenden Gültigkeitsbereich durchsucht hat. Eine vollständige Erklärung aller vier Ebenen finden Sie unter Python Scope.

Globale Variablen lesen vs. ändern

Eine globale Variable lesen (funktioniert immer)

Standardmäßig kann eine Funktion jede globale Variable ohne besondere Syntax lesen:

language = "Python"

def print_language():
    print(language)  # reads the global

print_language()  # Output: Python

Das Schlüsselwort global — erforderlich zum Ändern

Wenn Sie versuchen, einer Variable innerhalb einer Funktion einen Wert zuzuweisen, erstellt Python eine neue lokale Variable, anstatt die globale zu aktualisieren. Um die globale Variable zu ändern, müssen Sie sie mit dem Schlüsselwort global deklarieren:

counter = 0

def increment():
    global counter   # tell Python we mean the global 'counter'
    counter += 1
    print("Counter:", counter)

increment()  # Output: Counter: 1
increment()  # Output: Counter: 2
print(counter)  # Output: 2

Ohne global counter würde die Zeile counter += 1 einen UnboundLocalError auslösen, da Python versuchen würde, eine lokale Variable namens counter zu lesen, bevor sie zugewiesen wurde.

Der UnboundLocalError-Fallstrick

Dies ist der häufigste Fehler bei globalen Variablen. Sobald Python innerhalb einer Funktion eine Zuweisung an einen Namen sieht, behandelt es diesen Namen als lokal in der gesamten Funktion — auch in Zeilen vor der Zuweisung:

x = 10

def broken():
    print(x)   # ERROR — Python sees the assignment below and marks x as local
    x = 20

broken()
# UnboundLocalError: local variable 'x' referenced before assignment

Beheben Sie dies, indem Sie global x am Anfang der Funktion hinzufügen, wenn Sie die globale Variable wirklich ändern müssen, oder indem Sie die lokale Variable umbenennen, wenn Sie eine unabhängige Kopie benötigen.

Variable Shadowing

Wenn Sie einer Variable innerhalb einer Funktion ohne das Schlüsselwort global einen Wert zuweisen, wird eine lokale Variable erstellt, die die globale Variable verdeckt — die globale wird nicht geändert:

count = 100

def show_count():
    count = 5   # local variable — shadows the global 'count'
    print("Inside function:", count)   # 5

show_count()
print("Outside function:", count)  # 100 — global is unchanged

Shadowing ist kein Fehler, kann aber verwirrend sein. Verwenden Sie eindeutige Namen, um die Absicht klar zu machen.

global in verschachtelten Funktionen

Wenn Sie von einer inneren (verschachtelten) Funktion auf eine globale Variable auf Modulebene zugreifen müssen, verwenden Sie global — nicht nonlocal. nonlocal erreicht nur den Gültigkeitsbereich der unmittelbar einschließenden Funktion, nicht die Modulebene:

total = 0

def outer():
    def inner():
        global total   # reaches module scope
        total += 10
    inner()

outer()
outer()
print("total:", total)  # Output: total: 20

Vergleichen Sie dies mit nonlocal, das die Variable der einschließenden Funktion ändert, aber die globale Variable auf Modulebene unverändert lässt:

x = "global"

def outer():
    x = "outer"
    def inner():
        nonlocal x   # modifies outer()'s x, not the module-level x
        x = "inner"
    inner()
    print("outer x after inner():", x)  # inner

outer()
print("global x after outer():", x)   # global — unchanged

Einen tieferen Einblick in nonlocal finden Sie unter Python Scope.

Konstanten auf Modulebene — Der sinnvolle Anwendungsfall

Die sinnvollste Verwendung von globalen Variablen auf Modulebene sind Konstanten — Werte, die einmal gesetzt und zur Laufzeit nie geändert werden. Per Konvention werden sie in UPPER_SNAKE_CASE geschrieben:

MAX_RETRIES = 3
DEFAULT_TIMEOUT = 30

def connect(host, retries=MAX_RETRIES, timeout=DEFAULT_TIMEOUT):
    print(f"Connecting to {host} with {retries} retries, timeout={timeout}s")

connect("db.example.com")
# Output: Connecting to db.example.com with 3 retries, timeout=30s

Konstanten benötigen niemals das Schlüsselwort global, da sie nur gelesen und nie neu zugewiesen werden.

Best Practices

1. Funktionsargumente und Rückgabewerte bevorzugen

Die Übergabe von Daten über Funktionssignaturen macht den Code leichter testbar und nachvollziehbarer. Diese reine Funktion ist einfacher als die Verwendung eines veränderbaren globalen counter:

def increment(counter):
    return counter + 1

counter = 0
counter = increment(counter)
counter = increment(counter)
print("counter:", counter)  # Output: counter: 2

2. Globale Variablen für echte modulweite Konstanten reservieren

Verwenden Sie globale Variablen für Werte, die für den gesamten Programmlauf wirklich unveränderlich sind (MAX_CONNECTIONS, APP_VERSION, einmalig beim Start geladene Konfiguration). Vermeiden Sie veränderbare globale Variablen, die sich im Laufe der Zeit ändern.

3. Beschreibende UPPER_SNAKE_CASE-Namen für Konstanten verwenden

Ein Name wie MAX_RETRIES ist sofort als Modulkonstante erkennbar. Ein Name wie r ist es nicht.

4. Vor der Verwendung initialisieren

Deklarieren Sie alle globalen Variablen am Anfang des Moduls, vor allen Funktionen, die sie verwenden. So wird ein NameError vermieden, wenn eine Funktion aufgerufen wird, bevor die Variable andernfalls definiert wäre.

5. Vorsicht bei Threads

Wenn mehrere Threads Funktionen aufrufen, die dieselbe globale Variable ändern, entsteht eine Race Condition. Schützen Sie gemeinsam genutzten veränderbaren Zustand mit einem threading.Lock, oder überarbeiten Sie den Code, um gemeinsamen Zustand ganz zu vermeiden. Einen umfassenderen Überblick über Variablentypen in Python finden Sie unter Python Variables.

Zusammenfassung

Übungen