Fachkonzept - Lokale und globale Variablen

Lokale und globale Variablen

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

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

Wir betrachten als Beispiel eine Funktion zur Verdopplung einer Zahl.

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

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

Bei der Ausführung des Programms werden zwei Arten von Variablen erzeugt: Neben globalen Variablen werden hier zusätzliche lokale Variablen erzeugt, die nur während der Ausführung des Funktionsaufrufs 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 der Funktion existieren die lokalen Variablen nicht mehr.

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(x):
    x = x + x
    return x

# Test
x = 2
y = d(x)
print(y)

Bei der Ausführung des Funktionsaufrufs 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 Hauptprogramms oder der Funktionsdefinition ausgeführt wird.

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

Gültigkeitsbereich von Variablen

Eine lokale Variable ist nur innerhalb der Funktionsdefinition, in der sie eingeführt ist, gültig bzw. sichtbar.

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

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

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

# Test
x = 2
y = d()
print(y)

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.

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

Achtung: Das hier gezeigte Beispiel zeugt von keinem guten Programmierstil. Alle innerhalb einer Funktion 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 x
    global y
    y = x + x

# Test
x = 2
d()
print(y)

Hier werden innerhalb des Unterprogramms sämtliche Anweisungen mit den globalen Variablen ausgeführt.

x = 2
{x -> 2}
d()
--------------------------
Funktionsaufruf: d()
--------------------------
{x -> 2} 
    {}
    y = x + x
{x -> 2; y -> 4} 
    {}
--------------------------
{x -> 2; y -> 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.

Transparenz des Datenaustauschs bei Funktionen

Funktionen sollte man immer so konzipieren, dass sämtliche innerhalb einer Funktion verwendenden Daten über Parameter an die Funktion übergeben werden sollten.

Zudem sollten keine Seiteneffekte auftreten. Innerhalb einer Funktionsdefinition sollten nur lokale Variablen verändert werden. Ergebnisse sollten nur über die vorgesehene Funktionsrückgabe an ein Hauptprogramm weitergegeben werden.

X

Fehler melden

X

Suche