Sichtbarkeitsbereiche von Variablen

10.1 Lokale Variablen in Funktionen

In Python ist eine Variable zugänglich (kann verwendet werden) ab dem Moment ihrer Erstellung bis zum Ende ihres Sichtbarkeitsbereichs – meist ist das die Funktion, in der sie deklariert wurde. Wenn die Variable außerhalb von Funktionen deklariert wurde, wird sie als global bezeichnet.

In Python bestimmen Sichtbarkeitsbereiche den Kontext, in dem Variablen verwendet werden können. Sichtbarkeitsbereiche helfen, Namenskonflikte zu vermeiden und den Zugriff auf Daten zu verwalten. Die Haupttypen von Sichtbarkeitsbereichen in Python sind:

Lokaler Sichtbarkeitsbereich: Variablen, die innerhalb einer Funktion erstellt werden, existieren im lokalen Sichtbarkeitsbereich dieser Funktion und sind nur innerhalb dieser Funktion zugänglich.

Sichtbarkeitsbereich verschachtelter Funktionen: Wenn eine Funktion innerhalb einer anderen Funktion definiert ist, sind ihre Variablen nur innerhalb dieser verschachtelten Funktion zugänglich.

Globaler Sichtbarkeitsbereich: Variablen, die auf Skript- oder Modulebene definiert sind, gelten als global und sind in jedem Teil des Codes im selben Modul zugänglich.

Eingebauter Sichtbarkeitsbereich: Dies ist ein spezieller Sichtbarkeitsbereich, der alle eingebauten Objekte und Funktionen von Python umfasst, die standardmäßig verfügbar sind (zum Beispiel print() und len()).

LEGB-Regel

Um Variablen aufzulösen, verwendet Python die LEGB-Regel, die die Reihenfolge bestimmt, in der der Interpreter nach Variablen sucht:

• L (Local) — Zuerst wird im lokalen Sichtbarkeitsbereich gesucht.
• E (Enclosed) — Dann in den Sichtbarkeitsbereichen aller verschachtelten Funktionen, von der nächstgelegenen zur äußeren.
• G (Global) — Danach im globalen Sichtbarkeitsbereich.
• B (Built-in) — Schließlich im eingebauten Sichtbarkeitsbereich.

Verwendungsbeispiele

x = "global"  # Globale Variable

def outer():
    y = "outer local"  # Lokale Variable der äußeren Funktion
    def inner():
        z = "inner local"  # Lokale Variable der verschachtelten Funktion
        print(x)  # Gibt "global" aus
        print(y)  # Gibt "outer local" aus
        print(z)  # Gibt "inner local" aus
    inner()

outer()

Variable z ist nur innerhalb der Funktion inner() verfügbar.

Variable y ist innerhalb der Funktion outer() und in allen darin deklarierten Funktionen verfügbar.

Variable x ist überall in der aktuellen Datei (Modul) verfügbar.

10.2 Zugriff auf globale Variablen: global x

Eine interessante Eigenschaft der Python-Sprache ist, dass Variablen aus äußeren Sichtbarkeitsbereichen (in denen der aktuelle Bereich verschachtelt ist) nur gelesen werden können.

Bei dem Versuch, etwas in eine äußere Variable zu schreiben, wird eine lokale Variable mit demselben Namen erstellt, und der Zugriff auf die äußere Variable geht verloren.

Beispiel:

x = 10

def change_global():
    print(x)  # Dies wird einen Fehler verursachen, da x als lokale Variable nach der Zuweisung betrachtet wird
    x = 20  # Hier wird eine lokale Variable x erstellt
    print(x)  # Gibt 20 aus (es wird auf die lokale Variable x zugegriffen)
        
change_global()
print(x)  # Gibt 10 aus

Dieses Beispiel funktioniert nicht und wird einen Fehler UnboundLocalError auslösen, weil der Python-Interpreter zuerst die Zuweisung x = 20 sieht und annimmt, dass x eine lokale Variable ist. Wenn der Interpreter die Zeile print(x) erreicht, findet er keine lokale Variable x, da sie noch nicht definiert wurde.

Dies wird aus Sicherheitsgründen gemacht, um zu verhindern, dass lokale Variablen versehentlich globale Variablen ändern.

Der global-Operator

Wenn du den Wert einer globalen Variablen bewusst innerhalb einer Funktion ändern musst, kannst du den global-Operator verwenden. Dieser Operator erlaubt es, ausdrücklich anzugeben, dass die Änderung an der globalen Variablen und nicht an einer lokalen erfolgen soll.

Um den Wert einer globalen Variablen innerhalb einer Funktion zu ändern, muss diese Variable am Anfang der Funktion mit global deklariert werden. Dies gibt der Funktion Schreibzugriff auf die Variable:

x = 10

def change_global():
    global x  # Deklariert x als globale Variable
    print(x)  # Gibt 10 aus (es wird auf die globale Variable x zugegriffen)
    x = 20  # Hier wird der globale Variable x ein neuer Wert zugewiesen
    print(x)  # Gibt 20 aus (es wird auf die globale Variable x zugegriffen)

change_global()
print(x)  # Gibt 20 aus

Die Verwendung des global-Operators erlaubt es, Fehler zu vermeiden und globale Variablen korrekt zu verwalten.

Globale Variablen können das Programm weniger vorhersehbar und schwerer verständlich machen, da ihre Werte an jeder Stelle des Programms geändert werden können. Dies ist besonders kritisch, wenn das Programm groß ist und von einer Gruppe von Programmierern entwickelt wird.

Auch wenn manchmal die Verwendung globaler Variablen unvermeidlich ist, ist es besser, deren Verwendung zu minimieren. Statt globaler Variablen kannst du über die Verwendung von Funktionsparametern, Rückgabewerten und Klassen zur Speicherung von Zuständen nachdenken.

Die Verwendung globaler Variablen kann zu unerwarteten Nebeneffekten führen, das Debuggen und Testen des Codes erschweren und dessen Wiederverwendbarkeit reduzieren. Daher wird empfohlen, globale Variablen mit Vorsicht und nur dann zu verwenden, wenn es wirklich notwendig ist.

10.3 Zugriff auf nicht-lokale Variablen: nonlocal

Neben globalen und lokalen Variablen gibt es in Python auch Variablen aus Zwischenbereichen. Zum Beispiel, wenn eine Funktion in eine andere Funktion eingebettet ist. Für die Arbeit mit solchen Variablen wird der nonlocal-Operator verwendet.

Der nonlocal-Operator erlaubt es, mit Variablen in verschachtelten Funktionen zu arbeiten, indem er ihre Werte im nächsten sichtbaren Bereich ändert, abgesehen von globalen Variablen.

Der nonlocal-Operator hilft, die Erstellung einer neuen lokalen Variablen in einer verschachtelten Funktion zu vermeiden, wenn man eine Variable ändern muss, die in einer äußeren Funktion definiert ist. Ohne Verwendung von nonlocal betreffen die Änderungen nur die lokale Variable der inneren Funktion, ohne die Variable in der äußeren Funktion zu beeinflussen.

Beispiel:

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        return count

    return inner

counter = outer()
print(counter())  # Gibt 1 aus

Hier ist ein praktischeres Beispiel für die Verwendung von nonlocal zur Erstellung eines Zählers:

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

counter = create_counter()
print(counter())  # Gibt 1 aus
print(counter())  # Gibt 2 aus
print(counter())  # Gibt 3 aus

Dieses Beispiel zeigt, wie nonlocal in realen Szenarien verwendet werden kann, um eine Funktion zu erstellen, die ihren Zustand zwischen den Aufrufen beibehält.