4. Funktionen

Zu diesem Kapitel siehe Abbildung .

Zu den Funktionen ist es nun nur noch ein denkbar kleiner Schritt. Wir haben eben gesehen was Anweisungsblöcke sind. Wir erinnern uns: Funktionen sind Objekte, die funktionalen Code enthalten. Wir haben uns also inzwischen von den Apfelsaftgläsern entfernt und denken bereits über einen Roboter nach, der uns diese Apfelsaftgläser in den Mund giessen kann.

Um nun eine dolche Maschine zu bauen, müssen wir ihr lediglich einen Namen geben. Wir wollen nun eine solche Maschine mit dem Namen startposition verwenden, um unser feld wieder überall auf 0 zu setzen. Den Anweisungsblock in Form einer Doppelschleife können wir schon schreiben. Aber wie geben wir dem Ganzen einen Namen? Dieses geschieht mit dem Operator def, der nichts anderes als = durchführt. Der Unterschied besteht darin, dass = Namen von Datenobjekten zuweist, während def Namen von Funktionen, also Anweisungsblöcken zuweist.

>>>def start():

...  for i in range(4):

...    for j in range(4):

...      feld[i][j]=0

Nun können wir durch Eingabe von »start()« am Python-Prompt die gewünschte Aktion ausführen. Schauen wir hinterher nach, sehen wir, dass das feld wieder überall auf 0 gesetzt wurde.

Etwas merkwürdig erscheint sicherlich die Angabe der runden Klammern, die unbedingt erfolgen muss. Runde Klammern? Das hat doch etwas mit Tupeln zu tun? Richtig! Sehen wir uns an, wozu das Ganze gut ist. Wir wollen nun eine Funktion mit dem Namen input schreiben, die nun beliebig durch Vorgabe von vier Zahlen, die nun nicht unbedingt 1, 2, 3 und 4 sein müssen, bei Bedarf das feld wieder so belegen wie vorhin. Das Ganze sieht dann so aus:

>>>def input(a,b,c,d)

...  for i in range (4):

...   feld[i]=[a,b,c,d]

Der Aufruf erfolgt nun auf die Weise

>>>input(2,4,6,8)

Es werden jetzt demzufolge gewissermassen von aussen Werte an die Funktion übergeben. Die Funktion kann also wenigstens von der Aussenwelt Informationen empfangen. Was tatsächlich übergeben wird, ist ein Tupel! Das Tupel enthält die Zahlenwerte als Objekte, auf die nun intern die Namen a, b, c und d verweisen. Jetzt also ist die Funktion flexibel geworden. Sie reagiert auf die Aussenwelt. Ist sie eine »stumme« Maschine, wie zum Beispiel die Funktion start, so müssen dennoch die Klammern angegeben werden. Auch wenn sie leer sind. Bei Datenobjekten gibt es keine Empfangstupel, bei Funktionen dagegen immer.

Aber zur Kommunikation gehört natürlich auch die Notwendigkeit, dass die Funktion etwas an die Aussenwelt zurückgibt. Wir wollen nun unsere Funktion input so abändern, dass sie die mit der Zeilennummer multiplizierten Summen der letzten beiden Zeilen an die Aussenwelt wieder zurückgibt. Diese Rückgabe erfolgt mit dem Übergabeoperator return. Und zwar wie folgt:

>>>def input(a,b,c,d)

...  suma=sumb=0

...  for i in range (4):

...    feld[i]=[a,b,c,d]

...    if i==2:

...     for j in range(4):

...       suma=suma+i*feld[i][j]

...    elif i==3:

...     for j in range(4):

...       sumb=sumb+i*feld[i][j]

...  return (suma,sumb) 

Tatsächlich gibt jetzt diese Funktion beim Aufruf

>>>input(1,2,3,4)

das Tupel (20,30) zurück, wie es sein soll. Dieses Objekt kann jetzt natürlich einem Namen wieder zugewiesen werden, so dass wir nach der Zuweisung

>>>ergebnis=input(1,2,3,4)

mit diesem Objekt »ergebnis« weiterarbeiten können.

Eine Funktion ist also quasi eine Maschine, in die wir etwas über ein Tupel hineintun können und aus der in Form irgendeines Objektes etwas herauskommt. Für das Einlesen muss immer ein Tupel herhalten. Für das Auslesen kann irgendein Objekttyp dienen.

Die einzelnen Argumente werden nach der Stellung ausgewertet, d.h. es ist klar, dass der Name a dem Objekt 1 zugewiesen wird. Sehr wohl kann die Zuweisung aber auch so erfolgen, dass ein Aufruf wie

>>>input(a=2, c=5, b=6, d=7)

erfolgt. In diesem Falle wird intern ein Dictionary erzeugt, in dem die Schlüsselworte a,b, c und d den Zahlobjekten zugewiesen werden.