Fachkonzept - lokale / globale Variablen

Globale und lokale Variablen

Wir betrachten als Beispiel die Verdopplung einer Zahl mit Hilfe einer Verdopplungsfunktion.

def d(x):
    y = x + x
    return y

# Test
a = 2
print(a)
b = d(a)
print(b)

Bei der Ausführung des Programms werden zwei Arten von Variablen erzeugt: Neben einer globalen Variablen werden hier lokale Variablen erzeugt, die nur während der Ausführung des Unterprogramms existieren.

a = 2
{a -> 2}
b = d(a)
--------------------------
Funktionsaufruf: d(a)
--------------------------
{a -> 2} 
    {x -> 2}
    y = x + x
    {x -> 2, y -> 4}
    return y
--------------------------
Ergebnis: 4
--------------------------
{a -> 2; b -> 4}

Das Ablaufprotokoll zeigt die Zustände der jeweils existierenden Variablen. Nach Abarbeitung der Anweisungen des Unterprogramms existieren die lokalen Variablen nicht mehr.

Eine globale Variable ist (vereinfacht gesagt) eine Variable, die im Hauptprogramm eingeführt wird. Eine lokale Variable ist (vereinfacht gesagt) eine Variable, die nur innerhalb eines Unterprogramms benutzt wird. Beachte, dass die (formalen) Parameter eines Unterprogramms auch zu diesen lokalen Variablen zählen.

Sämtliche im Hauptprogramm definierten Namen (von Variablen, Funktionen, ...) bilden den sog. globalen Namensraum. Entsprechend bilden sämtliche in einem Unterprogramm definierten Namen (von Variablen, Funktionen, ...) den sog. lokalen Namensraum.

Namenskonflikte

Das folgende Beispiel zur Verdopplung einer Zahl mit Hilfe einer Verdopplungsfunktion zeigt, dass es gleichnamige globale und lokale Variablen geben kann, ohne dass es dabei zu einem Namenskonflikt kommt.

def d(a):
    a = a + a
    return a

# Test
a = 2
print(a)
a = d(a)
print(a)

Bei der Ausführung des Unterprogramms werden Variablen immer erst im lokalen Namensraum gesucht. Werden sie hier gefunden, so werden diese lokalen Namen zur Verwaltung der berechneten Daten benutzt. Das folgende Ablaufprotokoll zeigt, dass es hier zwei verschiedene, aber gleichnamige Variablen gibt. Welche jeweils benutzt wird, hängt davon ab, ob eine Anweisung des Haupt- oder Unterprogramms ausgeführt wird.

a = 2
{a -> 2}
a = d(a)
--------------------------
Funktionsaufruf: d(a)
--------------------------
{a -> 2} 
    {a -> 2}
    a = a + a
    {x -> 4}
    return y
--------------------------
Ergebnis: 4
--------------------------
{a -> 4}

Gültigkeitsbereich von Variablen

Eine lokale Variable ist nur innerhalb des Unterprogramms, in dem sie eingeführt ist, gültig bzw. sichtbar.

Beachte, dass lokale Variablen nach der Ausführung eines Unterprogramms nicht mehr existieren. Auf eine lokale Variable eines Unterprogramms kann man im Hauptprogramm also nicht zugreifen.

Anders verhält es sich bei globalen Variablen. Auf eine globale Variable kann man innerhalb eines Unterprogramms lesend zugreifen - sofern dort nicht eine gleichlautende Variable eingeführt ist.

def d():
    b = a + a
    return b

# Test
a = 2
print(a)
a = d()
print(a)

Wird eine Variable nicht im lokalen Namensraum gefunden, so wird sie im globalen Namensraum gesucht. Das folgende Ablaufprotokoll zeigt, wie sich hier die Variablenzustände entwickeln.

a = 2
{a -> 2}
d()
--------------------------
Funktionsaufruf: d()
--------------------------
{a -> 2}
    {}
    b = a + a
    {b -> 4}}
    return y
--------------------------
Ergebnis: 4
--------------------------
{a -> 4}

Achtung: Das hier gezeigte Beispiel zeugt von keinem guten Programmiestil. Alle innerhalb eines Unterprogramms zu verwendenden Daten sollten stets über Parameter an das Unterprogramm übergeben werden.

Seiteneffekte

Will man den Wert einer globalen Variablen innerhalb eines Unterprogramms verändern, so muss gewährleistet sein, dass die benutzte Variable zum globalen Namensraum gehört.

def d():
    global a
    a = a + a

# Test
a = 2
print(a)
d()
print(a)

Hier werden innerhalb des Unterprogramms sämtliche die Variable a betreffenden Anweisungen mit der globalen Variablen a ausgeführt.

a = 2
{a -> 2}
d()
--------------------------
Funktionsaufruf: d()
--------------------------
{a -> 2}
    {}
    a = a + a
{a -> 4}
--------------------------
keine Rückgabe
--------------------------
{a -> 4}

Verändert man innerhalb einer Prozedur den Wert einer globalen Variablen, so spricht man auch von einem Seiteneffekt.

Seiteneffekte sind in der Regel nicht erwünscht. Seiteneffekte können die Ursache für schwer auffindbare Fehler sein, da sie Veränderungen von Variablen in Programmteilen bewirken können, die mit dem für den Seiteneffekt verursachenden Unterprogramm nichts zu tun haben.

X

Fehler melden

X

Suche