Python 3 - Lernen und professionell anwenden

161

6.4

Ausführung von Funktionen

Erläuterung:

#1: Gefundene Primzahlen werden in der Liste prim gesammelt. Sie ist anfangs leer.

#2: Hier wird die Liste prim um das Element i (Primzahl) verlängert. Genauer gesagt wird

an die vorhandene Liste eine neue Liste mit dem alleinigen Element

i gehängt.

#3: Das Komma hinter zahl bewirkt, dass alle Elemente der Liste hintereinander geschrie-

ben werden und nicht untereinander.

Programmlauf:

6.4 Ausführung von Funktionen

6.4.1 Globale und lokale Namen

Testen Sie das folgende kleine Skript:

def verarbeitung(intervall):

prim = [] #1

for i in range(intervall[0], intervall[1]+1):

if primzahl(i):

prim += [i] #2

return prim

def ausgabe(primzahlen):

print("Primzahlen:")

for zahl in primzahlen:

print(zahl, end=" ") #3

# Hauptprogramm

intervall = eingabe()

primzahlListe = verarbeitung(intervall)

ausgabe(primzahlListe)

Ich ermittle alle Primzahlen in einem Intervall

Untere Intervallgrenze: 100

Obere Intervallgrenze: 200

Primzahlen:

101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191

193 197 199

def f():

x=2 #1

Kapitel 6

Funktionen

162

Programmlauf:

Das Skript enthält zwei völlig identische

print()-Aufrufe. Jedes Mal wird der Wert der Vari-

ablen

x ausgegeben. Allerdings handelt es sich um zwei unterschiedliche Werte, obwohl

dazwischen keine Veränderung der Variableninhalte vorgenommen wurde.

Wie ist das zu erklären? Nun, offenbar gibt es im Hauptprogramm und im Funktionskörper

zwei verschiedene Variablen mit unterschiedlichen Inhalten, die beide den Namen

x tragen,

aber ansonsten nichts miteinander zu tun haben. Man sagt, die Variablen sind lokal.

쐽 In der Zeile #1 wird die lokale Variable x der Funktion f() erzeugt und mit dem Wert 2

belegt. Diese Zuweisung hat keinen Einfluss auf die lokale Variable x des Hauptpro-

gramms. Bei der folgenden

print()-Anweisung wird der Inhalt dieser lokalen Varia-

blen

x ausgegeben.

쐽 In der Zeile #2 wird die lokale Variable x des Hauptprogramms erzeugt und mit dem Wert

1 belegt. Beim nächsten print()-Aufruf (#3) wird auf diese lokale Variable zugegriffen

und ihr Wert ausgegeben.

Lokale Variablen im Anweisungsblock einer Funktion sind nur dort sichtbar. Vom Haupt-

programm aus oder im Anweisungsblock einer anderen Funktion kann man nicht auf sie

zugreifen. Sie sind sozusagen von der Außenwelt abgeschirmt.

Beim Aufruf einer Funktion erzeugt der Python-Interpreter für die Funktion eine Umge-

bung (environment) aus einem globalen und einem lokalen Namensraum. Darin ist zu

jedem verwendeten Namen das zugehörige Objekt aufgeführt.

Die Funktionen

globals() und locals() liefern die Namensräume in der Form eines Dic-

tionarys. Im folgenden Skript werden die globalen und lokalen Namensräume des Haupt-

programms und der Funktion

f() ausgegeben.

Skript:

print("x:", x)

# Hauptprogramm

x=1 #2

f()

print("x:", x) #3

x: 2

x: 1

# Funktionsdefinition

def f():

x=2

print("Globaler Namensraum von f:", globals())

print("Lokaler Namensraum von f: ",locals())

163

6.4

Ausführung von Funktionen

Programmlauf:

Die Ausgabe des Skripts ist leider etwas unübersichtlich. Sie können aber Folgendes erkennen:

쐽 Beim Hauptprogramm sind lokaler und globaler Namensraum völlig gleich. Das ist bei

Hauptprogrammen immer so.

쐽 Der lokale (und globale) Namensraum des Hauptprogramms enthält folgende Namen-

zuordnungen:

쐽 Der lokale Namensraum der Funktion f() enthält allein die Belegung der (einzigen)

lokalen Variablen

x. Sie hat den Wert 2.

쐽 Der globale Namensraum der Funktion f() ist gleich dem Namensraum des Hauptpro-

gramms. Alle Funktionen, die innerhalb der gleichen Datei definiert sind, haben den

gleichen globalen Namensraum.

# Hauptprogramm

x=1

f()

print("Globaler Namensraum des Hauptprogramms:", globals())

print("Lokaler Namensraum des Hauptprogramms:",locals())

Globaler Namensraum von f: {'f': <function f at 0x02C1A6F0>,

'__builtins__': <module 'builtins' (built-in)>, '__package__': None, 'x':

1, '__name__': '__main__', '__doc__': None}

Lokaler Namensraum von f: {'x': 2}

Globaler Namensraum des Hauptprogramms: {'f': <function f at 0x02C1A6F0>,

'__builtins__': <module 'builtins' (built-in)>, '__package__': None, 'x':

1, '__name__': '__main__', '__doc__': None}

Lokaler Namensraum des Hauptprogramms: {'f': <function f at 0x02C1A6F0>,

'__builtins__': <module 'builtins' (built-in)>, '__package__': None, 'x':

1, '__name__': '__main__', '__doc__': None}

Name Objekt

__builtins__

Das Modul __builtin__. Es enthält zum Beispiel die Standardfunktio-

nen, die immer verfügbar sind.

__name__

Name des aktuellen Moduls, in diesem Fall lautet der Name __main__,

da es sich um ein ausführbares Skript handelt.

f

Unsere selbst definierte Funktion f()

__doc__

Docstring (siehe Abschnitt 6.14.4). Er kann eine Beschreibung des

Moduls enthalten. Da wir keinen Docstring definiert haben, ist es hier

das Objekt

None.

x

Die Zahl 1

Kapitel 6

Funktionen

164

Abbildung 6.3 zeigt die (auf das Wesentliche reduzierten) Umgebungen des Hauptpro-

gramms und der Funktion

f(). Es handelt sich gewissermaßen um einen Schnappschuss,

der den Zustand der Programmausführung zu einem bestimmten Zeitpunkt wiedergibt.

Denn die Belegungen der Variablen

x können sich ja während des Programmlaufs ändern.

Abb. 6.3: Namensräume des Hauptprogramms und der Funktion f()

Das folgende Skript verhält sich etwas anders:

Programmlauf:

Hier wird in der Funktion

g() keine lokale Variable definiert; denn es gibt keine Zuweisung

mit dem Namen

x auf der linken Seite. Der lokale Namensraum (siehe Abbildung 6.4) ent-

hält nicht den Namen

x. Bei der print()-Anweisung wird deshalb der Name x des globalen

Namensraumes verwendet.

def g():

print(x) # x ist nicht im Funktionskörper definiert

x=1

g()

1

Hauptprogramm

globaler Namensraum:

x: 1

f: Funktion

lokaler Namensraum:

x: 1

f: Funktion

f()

globaler Namensraum:

x: 1

f: Funktion

lokaler Namensraum:

x: 2