decocode decocode deco    

Prozeduren und Funktionen #

► Python-Dokumentation: Function definitions

Prozeduren sind Programmteile, die nicht unmittelbar ausgeführt werden, sondern erst dann, wenn sie durch ihren Namen aufgerufen werden.

Mit ihrer Hilfe können wiederkehrende Aufgaben implementiert werden. Da sie nur ein einziges Mal notiert werden müssen, kann ein Skript auf diese Weise kürzer und übersichtlicher gehalten werden. Korrekturen an der Prozedur wirken sich so auch auf jede Stelle aus, an der diese aufgerufen wird.

Eine Prozedur wird mit der Anweisung def gefolgt von dem Prozedurnamen definiert. Für den Namen der Prozedur gelten die gleichen Regeln wie für den Namen einer Variable.

Quelltext auswählen
1
2
def meineProzedur():
    pass

► Python-Dokumentation: pass

In diesem Beispiel wird die Prozedur meineProzedur() definiert. Die Anweisung pass dient lediglich als Platzhalter für den bislang fehlenden Inhalt. Sie hat die Bedeutung ›Tue nichts spezielles, sondern gehe zum nächsten Programmschritt‹.

Eine Prozedur muss immer vor ihrem Aufruf definiert sein.

Im folgenden Beispiel wird die Prozedur konkretisiert und in einer Zählschleife aufgerufen:

Quelltext auswählen
1
2
3
4
5
def meineProzedur():
    print("Hallo Welt!")

for i in range(10):
    meineProzedur()

An Prozeduren können auch Attribute übergeben werden, die innerhalb der Prozedur verarbeitet werden. Anzahl, Position und Datentyp der übergebenen Attribute müssen in der Grundform sowohl in der Definition der Prozedur als auch in ihrem Aufruf übereinstimmen.

Quelltext auswählen
1
2
3
4
5
6
7
def vol(l, b, h):
    print("Das Volumen beträgt", float(l) * float(b) * float(h), "m³.")

laenge = input("Geben Sie die Länge in Metern ein: ")
breite = input("Geben Sie die Breite in Metern ein: ")
hoehe  = input("Geben Sie die Höhe in Metern ein: ")
vol(laenge, breite, hoehe)

Die in einer Prozedur oder Funktion verarbeiteten Attribute können auch einen Vorgabewert besitzen. Ein solcher Wert kann im Aufruf der Prozedur bzw. Funktion dann weggelassen werden:

Quelltext auswählen
1
2
3
4
5
def vol(l, b, h = 10):
    print("Das Volumen beträgt", float(l) * float(b) * float(h), "m³.")

vol(2, 4)      # Für h wird der Vorgabewert 10 verwendet.
vol(2, 4, 20)  # Für h wird der Wert 20 übergeben.

Die innerhalb einer Prozedur bzw. einer Funktion verwendeten Namen für Variablen gelten nur innerhalb dieser Prozedur oder Funktion, wie der NameError durch Zeile 6 demonstriert:

Quelltext auswählen
1
2
3
4
5
6
def vol(l, b, h):
    v = float(l) * float(b) * float(h)
    print("Das Volumen beträgt", v, "m³.")

volumen = vol(2, 4, 10)
print(v)  # Diese Variable existiert nur innerhalb der Prozedur!

Allerdings können Prozeduren oder Funktionen Variablen aufrufen, die zwar nicht innerhalb, aber außerhalb der Prozedur bzw. Funktion bereits definiert wurden. Verändern lassen sich diese Werte nicht:

Quelltext auswählen
1
2
3
4
5
6
def test():
    print(x)
    x += 1  # Der Versuch einer Operation mit x führt zu einem UnboundLocalError

x = 100
test()

Weiterhin ist zu beachten, dass die Elemente bestimmter Datentypen wie Listen und Dictionarys innerhalb einer Prozedur bzw. einer Funktion verändert werden können, auch wenn sie nicht an die Prozedur bzw. Funktion übergeben wurden und auch nicht an einen Rückgabewert gebunden sind, wie folgendes Beispiel veranschaulichen soll:

Quelltext auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def test():
    nm = 200
    st = "Welt!"
    li1[0] = "Affe"
    li2 = ["Apfel", "Birne", "Orange"]
    di1["Einwohner"] = 125000
    di2 = {"Land":"Spanien", "Stadt":"Madrid", "Einwohner":3200000}

nm = 100
st = "Hallo"
li1 = ["Hund", "Katze", "Maus"]
li2 = ["Baum", "Blatt", "Blüte"]
di1 = {"Land":"Schweiz", "Stadt":"Bern", "Einwohner":126000}
di2 = {"Land":"Italien", "Stadt":"Rom", "Einwohner":2800000}

test()

print(nm)   # Numerische Variablen bleiben unverändert
print(st)   # Strings bleiben unverändert
print(li1)  # Listen können verändert werden
print(li2)  # aber nicht komplett neu
print(di1)  # Dictionarys können verändert werden
print(di2)  # aber nicht komplett neu

Funktionen #

► Python-Dokumentation: Function definitions

Funktionen können als Sonderform der Prozeduren betrachtet werden, da eine Funktion mindestens einen Rückgabewert besitzt, der üblicherweise das Ergebnis der Verarbeitung der übergebenen Attribute enthält. Dieser Wert wird mit der Anweisung return zurückgegeben und kann so im weiteren Verlauf verarbeitet werden.

Quelltext auswählen
1
2
3
4
5
6
7
8
9
def vol(l, b, h):
    v = float(l) * float(b) * float(h)
    return v

laenge = input("Geben Sie die Länge in Metern ein: ")
breite = input("Geben Sie die Breite in Metern ein: ")
hoehe  = input("Geben Sie die Höhe in Metern ein: ")
volumen = vol(laenge, breite, hoehe)
print("Das Volumen beträgt", volumen, "m³.")

Wie eine Funktion mit mehreren Rückgabewerten aufgerufen wird, soll folgendes Beispiel veranschaulichen:

Quelltext auswählen
1
2
3
4
5
6
7
8
def berechnung(x):
    a = 1 * x
    b = 2 * x
    c = 3 * x
    return a, b, c

e, f, g = berechnung(8)
print(e, f, g)

Mit Prozeduren und Funktionen lassen sich Skripte auch übersichtlich gestalten, so dass zusammenhängende Prozesse dicht beieinander liegen und durch den Namen klar erkennbar sind. So lässt sich beispielsweise der Ablauf eines Programms bereits zu Beginn seiner Entwicklung festlegen, auch wenn die konkreten Inhalte noch nicht implementiert worden sind:

Quelltext auswählen
1
2
3
4
5
6
7
8
9
10
11
12
def eingabe():
    return True

def verarbeitung(data):
    return True

def ausgabe(data):
    pass

i = eingabe()
o = verarbeitung(i)
ausgabe(o)

Rekursive Funktionen #

Rekursive Funktionen sind Funktionen, die sich selbst aufrufen. Ebenso wie bei Schleifen muss hier sichergestellt werden, dass es eine Abbruchbedingung gibt, die das Verlassen der Funktion auslöst, da die Rekursion nicht beliebig oft durchgeführt werden kann.

Quelltext auswählen
1
2
3
4
5
6
def hochzaehlen(x):
    if x < 20:
        print(x)
        hochzaehlen(x + 1)

hochzaehlen(3)

Wie oft rekursiert werden kann, lässt sich folgendermaßen bestimmen. Der letzte ausgegebene Wert entspricht der maximalen Tiefe der Rekursion:

Quelltext auswählen
1
2
3
4
5
6
7
8
def hochzaehlen(x):
    print(x)
    try:
        hochzaehlen(x + 1)
    except:
        return

hochzaehlen(0)