Umfang von Variablen in Python

Wenn du dich mit Python oder einer anderen Programmiersprache auskennst, weißt du zweifellos, dass Variablen definiert werden müssen, bevor sie in deinem Programm verwendet werden können. In diesem Lernprogramm beginnst du mit der Initialisierung von Variablen. Als Nächstes wirst du dich mit den Grenzen der Variablen innerhalb eines Programms vertraut machen - dem "Scope". Anhand von Beispielen lernst du die vier verschiedenen Geltungsbereiche kennen: lokal, umschließend, global und eingebaut. Diese Bereiche bilden zusammen die Grundlage für die LEGB-Regel, die der Python-Interpreter bei der Arbeit mit Variablen verwendet. Danach wirst du einige Beispiele mit zusätzlicher Komplexität wiederholen, um den Weg für das globale Schlüsselwort und das nicht-lokale Schlüsselwort zu ebnen.

Variabel

Eine Variable ist ein Label oder ein Name, der einer bestimmten Stelle im Speicher zugewiesen wird. An diesem Ort wird der Wert gespeichert, den dein Programm später verwenden soll. Das Tolle an Python ist, dass du nicht explizit angeben musst, welchen Typ die Variable hat, die du definieren willst - sie kann von jedem Typ sein (String, Integer, Float usw.). Um eine neue Variable in Python zu erstellen, benutzt du einfach den Zuweisungsoperator (=, ein einzelnes Gleichheitszeichen) und weist ihr den gewünschten Wert zu.

first_string_var = "First String"  
first_int_var = 1
total = 1 + 2 * 3

Wenn du einer Variablen einen Anfangswert zuweist, nennt man das Initialisieren der Variablen. Du hast soeben die Variable: first_string_var mit dem String-Wert First String und die Variable first_int_var mit dem Integer- oder numerischen Wert 1 initialisiert.
Der Teil links vom Zuweisungsoperator ist der Variablenname und die rechte Seite ist ihr Wert. Die rechte Seite kann auch eine arithmetische Operation sein - in diesem Fall wird sie ausgewertet, bevor die Zuweisung erfolgt.

In Python gibt es einige Regeln, die du beim Erstellen einer Variable beachten musst...

• Er darf nur Buchstaben (Groß- oder Kleinbuchstaben), Zahlen oder das Unterstrichzeichen _ enthalten.
• Sie darf nicht mit einer Zahl beginnen.
• Es muss nicht unbedingt ein Schlüsselwort sein (du wirst später mehr über sie erfahren).

Wenn du diese Regeln nicht befolgst, bekommst du eine Fehlermeldung. Probiere es selbst aus:

# No spaces are allowed in the variable
first string value = "First string"

  File "<ipython-input-1-2a2f77c0b400>", line 2
    first string value = "First string"
               ^
SyntaxError: invalid syntax

# Cannot start with a number
1st_string_value = "First String"

  File "<ipython-input-2-79b210888e10>", line 2
    1st_string_value = "First String"
                   ^
SyntaxError: invalid syntax

# Cannot be a keyword

True = "True"

  File "<ipython-input-3-5d4d2170e79c>", line 3
    True = "True"
                 ^
SyntaxError: can't assign to keyword

Variabler Umfang

Jetzt weißt du, wie du eine Variable initialisieren kannst. Lass uns über den Umfang dieser Variablen sprechen. Nicht auf alle Variablen kann von überall in einem Programm zugegriffen werden. Der Teil eines Programms, in dem eine Variable zugänglich ist, wird als ihr Geltungsbereich bezeichnet. Es gibt vier Haupttypen von variablen Geltungsbereichen und sie sind die Grundlage für die LEGB-Regel. LEGB steht für Local -> Enclosing -> Global -> Built-in.

Wir wollen mehr über Geltungsbereiche erfahren...

Lokaler Geltungsbereich

Wenn du eine Variable innerhalb einer Funktion definierst, liegt ihr Geltungsbereich NUR innerhalb der Funktion. Sie ist von dem Punkt, an dem sie definiert wird, bis zum Ende der Funktion zugänglich und existiert so lange, wie die Funktion ausgeführt wird(Quelle). Das bedeutet, dass sein Wert nicht geändert werden kann und auch nicht von außerhalb der Funktion zugänglich ist. Lass uns ein einfaches Beispiel nehmen:

def print_number():
    first_num = 1
    # Print statement 1
    print("The first number defined is: ", first_num)

print_number()
# Print statement 2
print("The first number defined is: ", first_num)

The first number defined is:  1



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-10-17d580e01222> in <module>
      6 print_number()
      7 # Print statement 2
----> 8 print("The first number defined is: ", first_num)


NameError: name 'first_num' is not defined

Wir konnten die Variable first_num ausdrucken, indem wir die Funktion print_number() aufgerufen haben (# Druckanweisung 1). Wenn ich jedoch versuche, auf dieselbe Variable von außerhalb der Funktion zuzugreifen und sie dann zu drucken (# Druckanweisung 2), wird eine NameError ausgegeben. Das liegt daran, dass first_num "lokal" für die Funktion ist - es kann also nicht von außerhalb des Funktionskörpers erreicht werden.

Umfassender Geltungsbereich

Was ist, wenn wir eine verschachtelte Funktion haben (eine Funktion, die innerhalb einer anderen Funktion definiert ist)? Wie verändert sich der Geltungsbereich? Das wollen wir anhand eines Beispiels sehen.

def outer():
    first_num = 1
    def inner():
        second_num = 2
        # Print statement 1 - Scope: Inner
        print("first_num from outer: ", first_num)
        # Print statement 2 - Scope: Inner
        print("second_num from inner: ", second_num)
    inner()
    # Print statement 3 - Scope: Outer
    print("second_num from inner: ", second_num)

outer()

first_num from outer:  1
second_num from inner:  2



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-4-13943a1eb01e> in <module>
     11     print("second_num from inner: ", second_num)
     12
---> 13 outer()


<ipython-input-4-13943a1eb01e> in outer()
      9     inner()
     10     # Print statement 3 - Scope: Outer
---> 11     print("second_num from inner: ", second_num)
     12
     13 outer()


NameError: name 'second_num' is not defined

Hast du einen Fehler? Das liegt daran, dass du von outer() aus nicht auf second_num zugreifen kannst (# Druckanweisung 3). Sie wird nicht innerhalb dieser Funktion definiert. Du kannst jedoch von inner() aus auf first_num zugreifen (# Druckanweisung 1), denn der Geltungsbereich von first_num ist größer, er liegt innerhalb von outer().
Dies ist ein einschließender Bereich. Die Variablen von Outer haben einen größeren Bereich und können von der eingeschlossenen Funktion inner() aus aufgerufen werden.

Globaler Geltungsbereich

Das ist vielleicht der am leichtesten zu verstehende Bereich. Immer wenn eine Variable außerhalb einer Funktion definiert wird, wird sie zu einer globalen Variable und ihr Geltungsbereich ist überall im Programm. Das bedeutet, dass sie von jeder Funktion verwendet werden kann.

greeting = "Hello"

def greeting_world():
    world = "World"
    print(greeting, world)

def greeting_name(name):
    print(greeting, name)

greeting_world()
greeting_name("Samuel")

Hello World
Hello Samuel

Eingebauter Umfang

Das ist der größte Spielraum, den es gibt! Alle speziellen reservierten Schlüsselwörter fallen in diesen Bereich. Wir können die Schlüsselwörter überall in unserem Programm aufrufen, ohne sie vor der Verwendung definieren zu müssen.

Schlüsselwörter sind einfach spezielle reservierte Wörter. Sie werden für bestimmte Zwecke aufbewahrt und können nicht für andere Zwecke im Programm verwendet werden.
Dies sind die Schlüsselwörter in Python:

LEGB-Regel

LEGB (Local -> Enclosing -> Global -> Built-in) ist die Logik, der ein Python-Interpreter folgt, wenn er dein Programm ausführt.

Nehmen wir an, du rufst print(x) innerhalb von inner() auf, das eine in outer() verschachtelte Funktion ist. Dann schaut Python zuerst, ob "x" lokal in inner() definiert wurde. Wenn nicht, wird die in outer() definierte Variable verwendet. Dies ist die einschließende Funktion. Wenn sie auch dort nicht definiert wurde, geht der Python-Interpreter eine Ebene höher - in den globalen Bereich. Darüber findest du nur den eingebauten Bereich, der spezielle Variablen enthält, die für Python selbst reserviert sind.

So weit, so gut!

Als Nächstes wollen wir einige Beispiele von früher wiederholen, um zu sehen, ob sie Probleme verursachen können, wenn der Anwendungsfall etwas komplexer wird.

Szenario 1: Globaler Geltungsbereich

Erinnerst du dich an die Funktion greeting_world() von vorhin? Angenommen, du möchtest die globale Variable greeting("Hello") ändern, um einen neuen Wert ("Hi") für die Begrüßung zu setzen, so dass greeting_world() "Hi World" ausgibt

greeting = "Hello"

def change_greeting(new_greeting):
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hello World

Nun... das lief nicht wie gewünscht! Und warum?

Denn als wir den Wert von greeting auf "Hi" gesetzt haben, wurde eine neue lokale Variable greeting im Bereich von change_greeting() erstellt. Für die globale greeting hat sich dadurch nichts geändert. An dieser Stelle kommt das globale Schlüsselwort ins Spiel.

Globales Schlüsselwort

Mit global sagst du Python, dass es die global definierte Variable verwenden soll, anstatt sie lokal zu erstellen. Um das Schlüsselwort zu verwenden, gibst du einfach "global" ein, gefolgt von dem Variablennamen. Sehen wir uns das bei Szenario 1 in Aktion an.

greeting = "Hello"

def change_greeting(new_greeting):
    global greeting
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hi World

Das hat geklappt! Gehen wir zum nächsten Szenario über...

Szenario 2: Umfassender Geltungsbereich

Hier werfen wir einen Blick auf die verschachtelten Funktionen outer() und inner() aus dem Enclosing Scope Beispiel. Versuchen wir nun, den Wert von first_num in inner() von 1 auf 0 zu ändern.

def outer():
    first_num = 1
    def inner():
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  1

Es ist nicht immer so einfach, oder? Für solche Zwecke verwenden wir das Schlüsselwort nonlocal in Python.

Nicht-lokales Schlüsselwort

Dies ist ein weiteres praktisches Schlüsselwort, mit dem wir flexibler und ordentlicher mit variablen Bereichen arbeiten können. Das Schlüsselwort nonlocal ist in verschachtelten Funktionen nützlich. Sie bewirkt, dass die Variable auf die zuvor gebundene Variable im nächstgelegenen umschließenden Bereich verweist. Mit anderen Worten: Es verhindert, dass die Variable versucht, zuerst lokal zu binden, und zwingt sie, eine Ebene "höher" zu gehen. Die Syntax ist ähnlich wie bei dem globalen Schlüsselwort.

def outer():
    first_num = 1
    def inner():
        nonlocal first_num
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  0

Und da hast du es!

Fazit

Du kennst jetzt den Geltungsbereich von Variablen in Python, die LEGB-Regel und weißt, wie du die globalen und nicht-lokalen Schlüsselwörter verwenden solltest. So kannst du problemlos Variablen in verschachtelten Funktionen manipulieren. Wenn du mehr über die Programmierung in Python erfahren möchtest, solltest du dir unbedingt den Kurs "Einführung in Python für Data Science" von DataCamp ansehen. Es ist ein interaktiver Kurs, der alle Grundlagen abdeckt: von Variablen und Berechnungen bis hin zu Listen, Funktionen und Paketen.