Python Variablen-Scope: LEGB-Regel, global & nonlocal Guide

1. Einführung: Was ist der Gültigkeitsbereich von Variablen in Python?

Beim Erlernen von Python stoßen Sie auf das Konzept des „Variablen-Gültigkeitsbereichs (Scope)“. Der Gültigkeitsbereich bezeichnet den Bereich, in dem eine Variable zugänglich ist, und wenn Sie ihn nicht richtig verstehen, kann das zu unerwarteten Fehlern oder Bugs führen.

Zum Beispiel schauen Sie sich den folgenden Code an.

def my_function():
    x = 10  # Diese Variable x ist nur innerhalb der Funktion gültig

print(x)  # NameError: Der Name 'x' ist nicht definiert

In diesem Code tritt ein Fehler auf, wenn versucht wird, die Variable x, die innerhalb der Funktion my_function definiert wurde, außerhalb der Funktion zu referenzieren. Das liegt daran, dass x zum „lokalen Gültigkeitsbereich“ gehört und daher außerhalb der Funktion als nicht existent betrachtet wird.

In diesem Artikel erklären wir detailliert vom Grundlagen des Variablen-Gültigkeitsbereichs in Python über fortgeschrittene Anwendungen bis hin zu Methoden zur Vermeidung von Fehlern. Lernen Sie, den Gültigkeitsbereich richtig zu verstehen und angemessen zu verwalten.

2. Grundlagen des Variablenbereichs

2.1 Was ist ein Variablenbereich?

Der Variablenbereich ist ein Konzept, das den gültigen Bereich einer Variable bezeichnet. In Python wird der Bereich, in dem eine Variable referenziert werden kann, durch den Ort ihrer Definition bestimmt.

Zum Beispiel kann eine in einer Funktion definierte Variable von außerhalb dieser Funktion nicht zugänglich sein. Umgekehrt kann eine auf Modul-Ebene definierte Variable im gesamten Skript verwendet werden.

2.2 Warum ist es notwendig, den Bereich zu verstehen?

Wenn der Variablenbereich nicht richtig verwaltet wird, können folgende Probleme auftreten.

• Unbeabsichtigtes Überschreiben von Variablen
  Die Verwendung desselben Namens in unterschiedlichen Bereichen kann zu unerwarteten Fehlern führen.
• Variable nicht gefunden (NameError)
  Wenn man versucht, auf eine Variable zuzugreifen, ohne ihren Bereich zu verstehen, kann ein NameError auftreten.
• Die Lesbarkeit des Codes nimmt ab
  Die übermäßige Verwendung von Variablen im globalen Bereich macht die Absicht des Codes unklar und erschwert das Debugging.

2.3 Grundlegende Regeln des Bereichs in Python

Um die Regeln des Bereichs in Python zu verstehen, sollten Sie die folgenden Punkte beachten.

1. Variablen, die in einer Funktion definiert werden, sind nur innerhalb dieser Funktion gültig (lokaler Bereich)
2. Variablen, die außerhalb einer Funktion definiert werden, können im gesamten Skript referenziert werden (globaler Bereich)
3. Python hat die „LEGB-Regel“ als Suchreihenfolge für Bereiche
4. Um eine globale Variable innerhalb einer Funktion zu ändern, verwenden Sie das global-Schlüsselwort
5. Um in einer verschachtelten Funktion eine Variable aus dem umschließenden Bereich zu ändern, verwenden Sie das nonlocal-Schlüsselwort

Auf diese Weise kann in Python durch angemessene Verwaltung des Bereichs unerwartete Fehler verhindert und Code effizienter geschrieben werden.

3. Arten von Scopes in Python und Beispiele

Python-Variablen-Scops lassen sich in vier Hauptarten unterteilen. Das Verständnis der einzelnen Scopes und die angemessene Verwaltung der Variablen sind wichtige Punkte, um fehlerfreien Code zu schreiben.

• Lokaler Scope (Local Scope)
• Umschließender Scope (Enclosing Scope)
• Globaler Scope (Global Scope)
• Built-in-Scope (Built-in Scope)

In diesem Abschnitt erklären wir jeden Scope detailliert mit konkreten Beispielen.

3.1 Lokaler Scope (Local Scope)

Der lokale Scope ist der Scope einer in einer Funktion definierten Variable. Variablen im lokalen Scope sind nur innerhalb dieser Funktion gültig und können von außerhalb der Funktion nicht erreicht werden.

Beispiel für lokalen Scope

def my_function():
    x = 10  # x ist eine lokale Variable dieser Funktion
    print(x)  # Dies funktioniert einwandfrei

my_function()
print(x)  # NameError: 'x' ist nicht definiert

Erklärung: Die in der Funktion my_function definierte Variable x ist nur während der Ausführung der Funktion gültig. Wenn von außerhalb der Funktion auf x zugegriffen wird, tritt ein NameError auf.

3.2 Umschließender Scope (Enclosing Scope)

Der umschließende Scope bezieht sich auf den Scope der äußeren Funktion bei verschachtelten (nichtierten) Funktionen. Die innere Funktion (Unterfunktion) kann auf die Variablen der äußeren Funktion (Überfunktion) zugreifen.

Beispiel für umschließenden Scope

def outer_function():
    y = 20  # Variable im Scope der Überfunktion

    def inner_function():
        print(y)  # Kann in der Unterfunktion auf die Variable der Überfunktion zugreifen

    inner_function()

outer_function()

Erklärung:Innerhalb von inner_function kann auf die Variable y von outer_function zugegriffen werden.

3.3 Globaler Scope (Global Scope)

Der globale Scope ist der Scope von Variablen, die im gesamten Skript (im gesamten Modul) gültig sind. Variablen, die außerhalb von Funktionen definiert werden, können von überall im Skript referenziert werden.

Beispiel für globalen Scope

z = 30  # Globale Variable

def my_function():
    print(z)  # Zugriff auf globale Variable möglich

my_function()
print(z)  # Von überall referenzierbar

3.4 Built-in-Scope (Built-in Scope)

Der Built-in-Scope umfasst den Scope der von Python von vornherein bereitgestellten eingebauten Funktionen und Variablen. Funktionen wie print() oder len() fallen darunter.

Beispiel für Built-in-Scope

print(len([1, 2, 3]))  # Ausgabe: 3

Erklärung:print und len sind eingebaute Python-Funktionen und können von jedem Scope aus genutzt werden.

3.5 Zusammenfassung der vier Scopes

4. Die Suchreihenfolge für Variablen-Scope (LEGB-Regel)

Python sucht beim Referenzieren einer Variable nach einer bestimmten Regel. Diese Regel heißt LEGB (Local, Enclosing, Global, Built-in) Regel und durchsucht die Variablen in folgender Reihenfolge.

1. L (Local) Lokaler Scope – Variablen, die in der aktuellen Funktion definiert wurden
2. E (Enclosing) Enclosing-Scope – Variablen der äußeren Funktion (verschachtelte Funktionen)
3. G (Global) Globaler Scope – Variablen, die auf Modul-Ebene definiert wurden
4. B (Built-in) Built-in-Scope – Eingebauten Funktionen und Variablen, die Python von Anfang an bereitstellt

Durch das Verständnis dieser Regel können Sie vorhersagen, wie Python Variablen auflöst, und Fehler leichter vermeiden.

4.1 Konkretes Beispiel für die LEGB-Regel

x = "Globale Variable"  # G (Global)

def outer_function():
    x = "Enclosing-Variable"  # E (Enclosing)

    def inner_function():
        x = "Lokale Variable"  # L (Local)
        print(x)  # Durch die LEGB-Regel wird die innerste x referenziert

    inner_function()

outer_function()
print(x)  # Referenziert die x im globalen Scope

Ausführungsresultat

Lokale Variable
Globale Variable

4.2 Der Einfluss des globalen Scopes

Beim Versuch, eine globale Variable im lokalen Scope zu ändern, kann aufgrund der LEGB-Regel ein UnboundLocalError auftreten.

Fehler beim Versuch, eine globale Variable lokal zu ändern

x = 10  # Globale Variable

def update_x():
    x += 1  # Fehler tritt auf
    print(x)

update_x()

Fehlerinhalt

UnboundLocalError: local variable 'x' referenced before assignment

Lösung: Verwenden des global-Schlüsselworts

x = 10  # Globale Variable

def update_x():
    global x  # Explizite Angabe der globalen Variable
    x += 1
    print(x)

update_x()  # Ausgabe: 11

4.3 Änderung des Scopes mit nonlocal

Um eine Variable im E (Enclosing) Enclosing-Scope zu ändern, verwenden Sie das nonlocal-Schlüsselwort.

Konkretes Beispiel für nonlocal

def outer_function():
    count = 0  # Variable der äußeren Funktion

    def inner_function():
        nonlocal count  # Referenz auf die Variable der äußeren Funktion
        count += 1
        print(count)

    inner_function()
    print(f"Endgültiger Zähler: {count}")

outer_function()

Ausführungsresultat

1
Endgültiger Zähler: 1

4.4 Suche im Built-in-Scope (Eingebauter Scope)

Python verfügt über eingebaute Funktionen wie print() oder len(), die zum äußersten Scope (Built-in) gehören.

Beispiel für das Überschreiben einer eingebauten Funktion

sum = 100  # `sum()` ist eine eingebaute Funktion, wird aber als Variable überschrieben

print(sum([1, 2, 3]))  # TypeError: 'int' object is not callable

Lösung: Eingebauten Funktionen nicht überschreiben

del sum  # Überschreibung aufheben
print(sum([1, 2, 3]))  # Funktioniert normal

4.5 Zusammenfassung der LEGB-Regel

Durch das Verständnis der LEGB-Regel können Sie den Mechanismus des Variablen-Scopes in Python tiefer verstehen und Fehler vermeiden.

5. Der Einsatz von globalen und lokalen Variablen

In Python ist es wichtig, Variablen angemessen im globalen Scope zu platzieren oder auf den lokalen Scope zu beschränken. Der Missbrauch globaler Variablen führt zu einer geringeren Lesbarkeit des Codes und erhöht die Wahrscheinlichkeit von Fehlern.

In diesem Abschnitt erklären wir detailliert den Unterschied zwischen globalen und lokalen Variablen zu verstehen und wie man sie angemessen einsetzt.

5.1 Was ist eine globale Variable?

Globale Variable (Global Variable) ist eine Variable, die außerhalb der Funktion definiert wird und im gesamten Skript referenziert werden kann.

Beispiel für eine globale Variable

count = 0  # Globale Variable

def increment():
    global count  # Globale Variable verwenden
    count += 1

increment()
print(count)  # Ausgabe: 1

5.2 Was ist eine lokale Variable?

Lokale Variable (Local Variable) ist eine Variable, die innerhalb der Funktion definiert wird und nur in dieser Funktion gültig ist.

Beispiel für eine lokale Variable

def my_function():
    x = 10  # Lokale Variable
    print(x)

my_function()
print(x)  # NameError: name 'x' is not defined

5.3 Fälle, in denen das global-Schlüsselwort verwendet werden sollte

Normalerweise sollte die Verwendung globaler Variablen auf ein Minimum beschränkt werden, aber in bestimmten Fällen ist es angemessen, das global-Schlüsselwort zu verwenden.

Angemessene Fälle

• Beim Verwalten von Konfigurationswerten oder Konstanten
• Wenn mehrere Funktionen dieselbe Variable teilen müssen

Beispiel: Verwalten von Konfigurationswerten

MAX_USERS = 100  # Globale Variable (als Konstante behandeln)

def print_max_users():
    print(f"Maximale Benutzeranzahl: {MAX_USERS}")

print_max_users()  # Ausgabe: Maximale Benutzeranzahl: 100

5.4 Methode zum Verwalten von Variablen ohne global

Anstatt globale Variablen zu verwenden, können Sie Daten sicherer verwalten, indem Sie Funktionsargumente und Rückgabewerte nutzen.

Verwendung von Funktionsargumenten und Rückgabewerten

def increment(value):
    return value + 1

counter = 0
counter = increment(counter)  # Rückgabewert der Funktion zuweisen
print(counter)  # Ausgabe: 1

5.5 Zusammenfassung des Einsatzes von globalen und lokalen Variablen

✅Die Verwendung globaler Variablen minimieren und lokale Variablen nutzen ist die Best Practice.✅Beim Übergeben von Daten zwischen Funktionen ist die Nutzung von Funktionsargumenten und -rückgabewerten vorzuziehen.

6. Verschachtelte Funktionen und das nonlocal-Schlüsselwort

In Python können Sie eine Funktion innerhalb einer anderen Funktion definieren. Dies wird als verschachtelte (eingebettete) Funktion bezeichnet. Durch den angemessenen Einsatz verschachtelter Funktionen können Sie die Code-Struktur organisieren und den Scope genauer verwalten.

Zusätzlich müssen Sie das nonlocal-Schlüsselwort verwenden, wenn Sie in einer verschachtelten Funktion eine Variable der äußeren Funktion ändern möchten. In diesem Abschnitt erklären wir detailliert die Rolle und die Verwendung von nonlocal.

6.1 Was sind verschachtelte Funktionen?

Verschachtelte Funktion (Nested Function) bezeichnet das Definieren einer Funktion innerhalb einer anderen Funktion.

Ein konkretes Beispiel für eine verschachtelte Funktion

def outer_function():
    def inner_function():
        print("Dies ist die innere Funktion")

    inner_function()  # Innere Funktion in der äußeren Funktion aufrufen

outer_function()  # Ausgabe: Dies ist die innere Funktion

6.2 nonlocal zum Ändern einer Variable der äußeren Funktion

Normalerweise tritt ein Fehler auf, wenn Sie aus der inneren Funktion eine Variable der äußeren Funktion ändern möchten.

Beispiel, bei dem ein Fehler auftritt

def outer_function():
    count = 0  # Variable der äußeren Funktion

    def inner_function():
        count += 1  # Fehler tritt auf
        print(count)

    inner_function()

outer_function()

Lösung: Verwenden des nonlocal-Schlüsselworts

def outer_function():
    count = 0  # Variable der äußeren Funktion

    def inner_function():
        nonlocal count  # Variable der äußeren Funktion referenzieren
        count += 1
        print(count)

    inner_function()
    print(count)  # Die in `inner_function` geänderte count wird widergespiegelt

outer_function()

Ausführungsresultat

1
1

6.3 Der Unterschied zwischen global und nonlocal

Beispiel mit global

count = 0  # Globale Variable

def increment():
    global count  # Globale Variable ändern
    count += 1

increment()
print(count)  # Ausgabe: 1

Beispiel mit nonlocal

def outer():
    count = 0  # Variable des Enclosing Scopes

    def inner():
        nonlocal count  # Variable der äußeren Funktion ändern
        count += 1

    inner()
    print(count)  # Ausgabe: 1

outer()

✅Verwenden Sie global, um globale Variablen aus einer Funktion zu ändern.✅Verwenden Sie nonlocal, um in einer verschachtelten Funktion eine äußere Variable zu ändern.

7. Häufige Fehler bezüglich des Scopes und deren Behebung

Wenn Sie den Scope in Python nicht richtig verstehen, können „Variable nicht gefunden“, „Unerwartete Änderung des Werts“, „Fehler durch Fehlanwendung des Scopes“ und ähnliche Probleme auftreten.

In diesem Abschnitt erklären wir die Ursachen gängiger Fehler im Zusammenhang mit dem Scope und deren Behebung.

7.1 UnboundLocalError: Referenzierung vor der Zuweisung

Beispiel für den Fehler

count = 0  # Globale Variable

def increment():
    count += 1  # Hier tritt der Fehler auf
    print(count)

increment()

Fehlerinhalt

UnboundLocalError: local variable 'count' referenced before assignment

Lösung ①: Verwendung des global-Schlüsselworts

count = 0  # Globale Variable

def increment():
    global count  # Globale Variable explizit angeben
    count += 1
    print(count)

increment()  # Ausgabe: 1

Lösung ②: Verwendung von Funktionsargumenten

def increment(count):
    return count + 1

count = 0
count = increment(count)
print(count)  # Ausgabe: 1

7.2 NameError: Variable ist nicht definiert

Beispiel für den Fehler

def print_message():
    print(message)  # Hier tritt der Fehler auf

print_message()

Fehlerinhalt

NameError: name 'message' is not defined

Lösung

Definieren Sie die Variable innerhalb der Funktion oder verwenden Sie sie als Argument.

def print_message(message):
    print(message)

print_message("Hallo")  # Ausgabe: Hallo

7.3 TypeError: Variable mit demselben Namen wie eine eingebaute Funktion

Wenn Sie in Python eine Variable mit demselben Namen wie eine eingebaute Funktion definieren, kann beim Aufruf der Funktion ein TypeError auftreten.

Beispiel für den Fehler

sum = 100  # Variable mit demselben Namen wie die eingebaute Funktion `sum()`

print(sum([1, 2, 3]))  # Hier tritt der Fehler auf

Fehlerinhalt

TypeError: 'int' object is not callable

Lösung

1. Den Variablennamen ändern

total = 100  # `total` anstelle von `sum` verwenden
print(sum([1, 2, 3]))  # Funktioniert normal

2. Falls die eingebaute Funktion überschrieben wurde, löschen

sum = 100
del sum  # Überschreibung aufheben

print(sum([1, 2, 3]))  # Funktioniert normal

7.4 Best Practices zur Vermeidung von Scope-bezogenen Fehlern

✅Möglichst lokale Variablen verwenden（Durch Begrenzung des Scopes unerwartete Änderungen verhindern）
✅Globale Variablen innerhalb von Funktionen nicht ändern（global nach Möglichkeit vermeiden und mit Argumenten und Rückgabewerten verwalten）
✅Überprüfen, ob Variablen mit demselben Namen wie eingebaute Funktionen verwendet werden✅Den Scope der Variablen beachten und den geeigneten Scope wählen

8. Tipps zur angemessenen Verwaltung des Scopes

Die angemessene Verwaltung des Scopes in Python ist zur Verbesserung der Lesbarkeit des Codes und zur Vermeidung von Bugs äußerst wichtig. Insbesondere kann der Mißbrauch globaler Variablen oder unangemessene Scope-Verwaltung zu unerwartetem Verhalten und Schwierigkeiten beim Debuggen führen.

In diesem Abschnitt stellen wir praktische Tipps zur angemessenen Verwaltung des Scopes vor.

8.1 Globale Variablen so weit wie möglich reduzieren

Da globale Variablen von überall zugänglich sind, können unbeabsichtigte Änderungen der Werte leicht auftreten. Daher wird empfohlen, den Einsatz globaler Variablen auf das Minimum zu beschränken.

Schlechtes Beispiel (Mißbrauch globaler Variablen)

counter = 0  # Globale Variable

 def increment():
     global counter  # Globale Variable ändern
     counter += 1

 increment()
 print(counter)  # Ausgabe: 1

Gutes Beispiel (Nutzung von Funktionsparametern und Rückgabewerten)

def increment(value):
     return value + 1

 counter = 0
 counter = increment(counter)
 print(counter)  # Ausgabe: 1

8.2 Den Scope der Funktion klar definieren

Durch angemessene Verwaltung des Scopes einer Funktion kann man den Einflussbereich der Variablen begrenzen und unbeabsichtigte Änderungen verhindern.

Gutes Beispiel (Nutzung des lokalen Scopes)

def calculate_square(number):
     result = number ** 2  # Lokale Variable
     return result

 print(calculate_square(4))  # Ausgabe: 16

8.3 Angemessene Verwendung von global und nonlocal

Fälle, in denen global verwendet werden sollte

• Beim Verwalten von Konfigurationswerten oder Konstanten
• Variablen, die Zustände halten (z. B. Singleton-Muster)

MAX_USERS = 100  # Globale Variable (als Konstante behandeln)

 def get_max_users():
     return MAX_USERS

 print(get_max_users())  # Ausgabe: 100

Fälle, in denen nonlocal verwendet werden sollte

• Beim Ändern einer äußeren Variable in einer verschachtelten Funktion

def outer():
     count = 0  # Variable der äußeren Funktion

     def inner():
         nonlocal count  # Äußere Variable ändern
         count += 1
         print(count)

     inner()

 outer()  # Ausgabe: 1

8.4 Checkliste für die Scope-Verwaltung

✅Werden Variablen, die innerhalb der Funktion abgeschlossen sind, als lokale Variablen ohne globale Variablen verwendet?✅Beim Einsatz globaler Variablen, handelt es sich wirklich um notwendige Fälle? (z. B. Konfigurationswerte oder Konstanten)✅Beim Übergeben von Daten zwischen Funktionen, werden Parameter und Rückgabewerte statt globaler Variablen verwendet?✅Ist die Verwendung von global oder nonlocal angemessen? (Nicht unnötig verwendet?)✅Werden keine Variablen mit demselben Namen wie eingebaute Funktionen verwendet?✅Wird der Code unter Berücksichtigung des Scopes der Variablen gestaltet?Durch die Nutzung dieser Checkliste können Scope-Probleme im Voraus verhindert werden, und man kann sichereren und wartungsfreundlicheren Code schreiben.

9. FAQ (Häufig gestellte Fragen und Antworten)

In diesem Abschnitt haben wir häufig gestellte Fragen zum Variablen-Scope in Python zusammengefasst. Es wird in Q&A-Form erklärt, um Missverständnisse über Scopes aufzuklären und ein praktischeres Verständnis zu vertiefen.

9.1 Wie verwaltet man globale Variablen ohne global zu verwenden?

A: Durch die Verwendung von Funktionsargumenten und Rückgabewerten kann man globale Variablen vermeiden zu ändern.

def increment(value):
    return value + 1

count = 10
count = increment(count)
print(count)  # Ausgabe: 11

✅Durch diese Methode werden Funktionen unabhängig und die Wiederverwendbarkeit verbessert.

9.2 Was ist der Unterschied zwischen nonlocal und global?

A: nonlocal dient dazu, Variablen im Enclosing-Scope zu ändern.

Beispiel für die Verwendung von nonlocal

def outer():
    count = 0  # Variable der äußeren Funktion

    def inner():
        nonlocal count  # Ändert die äußere Variable
        count += 1

    inner()
    print(count)  # Ausgabe: 1

outer()

9.3 Was ist die LEGB-Regel?

A: Es handelt sich um eine Regel, die die Suchreihenfolge für Variablen angibt.

1. L (Local): In der Funktion definierte Variable
2. E (Enclosing): Variable außerhalb der verschachtelten Funktion
3. G (Global): Variable im globalen Scope
4. B (Built-in): Eingebauten Funktionen von Python

Beispiel für die LEGB-Regel

x = "Globale Variable"  # G

def outer():
    x = "Enclosing-Variable"  # E

    def inner():
        x = "Lokale Variable"  # L
        print(x)  # Bezieht sich auf die innerste x durch die LEGB-Regel

    inner()

outer()
print(x)  # Bezieht sich auf die globale Variable

✅Durch das Verständnis der LEGB-Regel versteht man den Mechanismus des Variablen-Scope in Python.

10. Zusammenfassung

In diesem Artikel haben wir den Variablen-Scope in Python detailliert erklärt. Durch das Verständnis und die angemessene Verwaltung des Scopes ist es möglich, Bugs zu vermeiden und lesbaren Code zu schreiben.

10.1 Grundlagen des Scopes in Python

✅Was ist ein Scope?

• Die Regel, die den Bereich festlegt, in dem eine Variable zugänglich ist.
• Lokaler Scope (innerhalb einer Funktion) und globaler Scope (außerhalb einer Funktion) sind die Grundlagen.

✅Warum ist es notwendig, den Scope zu verstehen?

• Unbeabsichtigtes Überschreiben von Variablen verhindern.
• Fehler wie NameError vermeiden, wenn Variablen nicht gefunden werden.
• Die Lesbarkeit des Codes verbessern und das Debugging erleichtern.

10.2 Arten des Scopes in Python

In Python gibt es 4 Arten von Scopes, und Variablen werden basierend auf der LEGB-Regel gesucht.

10.3 Korrekte Verwendung von global und nonlocal

✅Fälle, in denen global verwendet werden sollte

• Beim Management von Konstanten oder Konfigurationswerten
• Beim Verwenden einer gemeinsamen Variable in mehreren Funktionen

✅Fälle, in denen nonlocal verwendet werden sollte

• Wenn in einer geschachtelten Funktion eine äußere Variable geändert werden soll

10.4 Best Practices für das Scope-Management

✅Die Verwendung globaler Variablen minimieren und lokale Variablen priorisieren.✅Beim Teilen von Daten zwischen Funktionen ist es Best Practice, Argumente und Rückgabewerte zu verwenden.✅Die Scope-Regeln (LEGB) verstehen und die Suchreihenfolge der Variablen beachten.

10.5 Zum Schluss

Das richtige Verständnis und Management des Scopes ist unerlässlich, um die Python-Programmierfähigkeiten zu verbessern. Insbesondere, wenn man „globale Variablen nicht missbrauchen“ und „den Scope der Funktionen klar machen“ beachtet, kann man besseren Code schreiben.

Meistere den Scope in Python und ziele darauf ab, sichereren und wartungsfreundlicheren Code zu schreiben!🚀