Eigene Funktionen schreiben

Es gibt unzählige Funktionen in den Python-Modulen, die du jederzeit verwenden kannst. Damit du aber richtig verstehst, was Funktionen genau sind, ist es sinnvoll, dass du eigene Funktionen schreibst, die du dann auch verwenden kannst. Später wird das ohnehin ein ganz selbstverständlicher Teil des Programmierens sein.

Fangen wir ganz einfach an: Wir möchten eine Funktion mit dem Namen »verdoppeln« schreiben, die einen Zahlenwert ganz einfach verdoppelt. Wie definieren wir nun diese Funktion?

Dazu gibt es einen Python-Befehl, der heißt

def Funktionsname(Variablen):

Mit def definiert man eine Funktion, der Doppelpunkt am Ende weist darauf hin, dass danach ein eingerückter Block steht, der zur Funktion gehört.

def verdoppeln(wert):

So definierst du eine neue Funktion mit dem Namen verdoppeln, die eine Variable mit den Namen wert erhält. Man nennt die Werte, die man einer Funktion übergibt, auch »Übergabeparameter« bzw. »Parameter« oder »Argument«. Hier haben wir also einen Parameter, der der Funktion als Variable »wert« übergeben wird.

Danach folgt das, was die Funktion macht. Was macht sie? Sie nimmt die Variable wert mal 2 und liefert diesen doppelten Wert dann zurück. Das war’s.

So sieht das in Python zum Beispiel aus:

Mit def wird die Funktion also definiert, mit return wird das Ergebnis der Funktion zurückgegeben.

Sobald du diese Funktionsdefinition eingegeben hast, kannst du die Funktion verdoppeln wie einen Befehl in Python verwenden. An jeder Stelle in deinem Programm und beliebig oft.

Das kann zum Beispiel so aussehen:

def verdoppeln(wert):
    doppelwert = wert*2
    return doppelwert
x = input("Bitte Wert eingeben")
msgDlg(verdoppeln(x))

Alles klar? Es wird ein Wert eingegeben und in x gespeichert, dann wird das Doppelte ausgegeben, indem die neue Funktion verdoppeln für x verwendet wird.

Wie gesagt kann eine Funktion auch mit mehreren Parametern (also übergebenen Werten) arbeiten, wenn sie so definiert wird. Schreibe eine Funktion summe, die zwei Werte erhält, die sie dann addiert und die Summe zurückgibt. Schaffst du das selber?

Hier der mögliche Code für die Funktion:

def summe(wert1,wert2):
    zusammen = wert1+wert2
    return zusammen

Und im ganzen Programm wäre es dann so verwendbar:

def summe(wert1,wert2):
    zusammen = wert1+wert2
    return zusammen
x = input("Bitte Wert 1 eingeben")
y = input("Bitte Wert 2 eingeben")
msgDlg(summe(x,y))

Das ist verständlich, oder?

Eine einfache Funktion, die keinen Wert braucht, könnte man zum Beispiel so schreiben:

def warnung():
    msgDlg("Achtung, hier ist ein falscher Wert eingegeben worden!")
    
x = input("Bitte Zahl unter 10 eingeben")
if x<10:
    print "Danke"
else:
    warnung()

In diesem Programm haben wir uns also am Anfang einen neuen Befehl definiert: die Funktion warnung().

Diese Funktion braucht keinen Wert, und sie liefert auch keinen zurück. Alles, was sie macht, ist die Ausgabe eines Warntextes.

Wozu brauchen wir also Funktionen?

Funktionen sind aus mehreren Gründen sehr sinnvoll beim Programmieren. Zum einen machen sie Programme viel übersichtlicher. Eine Funktion kann viele Befehle und Berechnungen nacheinander enthalten – und sie wird im Programm dann nur mit einem einzigen Befehl aufgerufen. Wenn der Funktionsname deutlich genug ist, sind die Programme viel einfacher zu lesen.

Beispiel:

if antwort == richtig:
    zeige_smiley()
else:
    spiele_falschsound()

Dieses Programm versteht man sofort, weil es zwei klar benannte Funktionen enthält: zeige_smiley() und spiele_falschsound()

Jede dieser beiden Funktionsdefinitionen (die hier nicht mit aufgeführt sind) ist vielleicht selbst lang und kompliziert – es wird möglicherweise ein Smiley aus mehreren Elementen auf eine Fläche gezeichnet, es wird ein Klang berechnet und abgespielt – aber das braucht uns nicht mehr zu interessieren, wenn die Funktionen erst mal geschrieben sind. Danach werden sie nur noch wie neue Befehle verwendet, die genau das machen, was wir festgelegt haben.

Der andere große Vorteil von Funktionen ist, dass man sie in einem Programm immer wieder aufrufen kann, an unterschiedlichsten Stellen. Man muss also einen Programmcode für eine bestimmte Aufgabe nur einmal schreiben und kann ihn dann als Funktionsbefehl überall immer wieder einsetzen. Das macht Programme natürlich auch kürzer und viel einfacher.

[+]  Funktionen in eigenem Modul speichern

Jede selbst definierte Funktion (oder auch eine ganze Liste von definierten Funktionen) kann man selbst als Modul in einer Datei speichern. Diese Datei muss man dann nur noch mit dem import-Befehl in sein Programm laden und kann alle Funktionen, die darinstehen, dann sofort verwenden. Wir haben das ja schon öfter gemacht, indem wir die mitgelieferten Module random, math oder gturtle importiert haben. Ebenso geht es auch mit eigenen, selbst erfundenen Modulen.