Unterprogramme | Informatik W24d

Ein Unterprogramm stellt einen wiederverwendbaren Code-Block dar. Dieses kann durch übergebene Argumente mit verschiedenen Situationen umgehen. Zudem kann es einen Wert berechnen und diesen als Rückgabewert zurückliefern.

# Aufruf eines Unterprogrammes

Wir haben bereits Unterprogramme verwendet. Nämlich die Befehle der Turtle: forward(100) ruft das Unterprogramm forward mit dem Argument 100 auf. Das Unterprogramm forward übernimmt den Wert des Argumentes (es muss nicht 100 sein, irgendeine Zahl geht) und fährt die Turtle um den entsprechenden Wert vorwärts.

Im Allgemeinen ruft man ein Unterprogramm auf, indem man seinen Namen, gefolgt von runden Klammern mit – falls vorhanden – durch Kommas getrennte Argumente schreibt.

Einige Beispiele von Unterprogramme-Aufrufen der Turtle:

turtle.left(90): Die Turtle dreht sich 90 Grad gegen den Uhrzeigersinn.
turtle.left(45): Die Turtle dreht sich 45 Grad gegen den Uhrzeigersinn.
turtle.pencolor('blue'): Falls der übergebende Text einer bekannten Farbe zugewiesen werden kann, wird die Stiftfarbe entsprechend gesetzt.
turtle.penup(): Die Turtle hebt den Stift. Ab jetzt hinterlässt sie keine Linie mehr. (kein Argument)
turtle.goto(10,200): Schickt die Turtle zum durch die Argumente als Koordinaten beschriebenen Punkt.

# Argumente übergeben

Ein Unterprogramm kann kein, ein oder mehrere Argumente entgegennehmen. Damit wir ein Unterprogramm mit den korrekten Argumenten «füttern» können, müssen wir wissen was es tut und welche Argument(e) es erwartet.

# Rückgabewerte weiterverwenden

Gewisse Unterprogramme berechnen etwas und liefern den Wert zurück. Bei den Turtle-Unterprogrammen gibt es auch solche. Mit ihnen lässt sich der momentane Zustand der Turtle abfragen.

turtle.shape("classic"): setze die Form der Turtle auf ein Dreieck. Liefert keinen Wert zurück.
turtle.shape(): fragt die Turtle welche Form aktiv ist und liefert diese als Rückgabewert zurück.

turtle.shape('turtle')    # setzt den Turtle-Typ auf "turtle"
print(turtle.shape())     # gibt in der Shell "turtle" aus
turtle.shape('classic')   # setzt den Turtle-Typ auf "classic"
print(turtle.shape())     # gibt in der Shell "classic" aus

1
2
3
4

Weitere Unterprogramme mit Rückgabewert sind position() (liefert Koordinaten als Vec2D) oder heading() (liefert den momentanen Winkel der Turtle als Zahl).

# Definition eines Unterprogrammes

Man kann selbst auch Unterprogramme schreiben und diese dann beliebig oft aufrufen.

Hinweis

Durch das Definieren von Unterprogrammen und dem mehrmaligen Aufruf dieser, vermeidet man, dass Code doppelt geschrieben werden muss.

Wenn die Turtle eine Treppe zeichnen soll, dann macht sie eigentlich immer wieder dasselbe: Eine Treppe besteht ja aus Stufen. Also definieren wir ein Unterprogramm welches eine einzelne Stufe zeichnet. Wenn wir eine Treppe zeichnen wollen, rufen wir es einfach mehrmals auf:

Definition (links) und Aufruf (rechts) der Funktion stufe()

import turtle

def stufe():
    # Zeichnet eine Treppenstufe
    turtle.forward(100)
    turtle.left(90)
    turtle.forward(100)
    turtle.right(90)

stufe()
stufe()
stufe()
turtle.forward(100)

1
2
3
4
5
6
7
8
9
10
11
12
13

Der Block welcher zum Unterprogramm gehört, wird eine Ebene (1x Tabulator ⇥ oder 4 Leerschläge SPACE) eingerückt. So erkennt Python, dass dieser Teil nicht zum Hauptprogramm gehört, sondern Teil des Unterprogramms ist. Geht der Code wieder auf die vorherige Ebene zurück, dann gehört dieser Teil nicht mehr zum Unterprogramm.

Beim Starten des obigen Beispiels wird auf Zeile 3 das Unterprogramm definiert. Auf Zeile 9 kennt Python nun das Unterprogramm stuf. Die Turtle hat aber noch keinen Befehl erhalten! Erst auf Zeile 10 wird nun das Unterprogramm aufgerufen und die Turtle zeichnet eine erste Stufe.

Hinweis

Wenn wir eine Funktion definieren, dann dokumentieren wir sie gerade mit einem Kommentar. Der Kommentar kommt gleich nach nach der Definitions-Zeile und wird – wie der Rest der Funktion – eingerückt.

Aufgabe «Treppe»

Erweitere dein Treppen-Programm vom letzten Kapitel, so dass die Treppe nun Stufe-um-Stufe mit Hilfe des obigen Unterprogramms gezeichnet wird.

Zusatzaufgabe «rauf und wieder runter»

Wie kannst du das Unterprogramm stufe verwenden um die folgende Treppe zu zeichen?

# Argumente entgegennehmen

Möchten wir eine Treppenstufe mit variabler Grösse zeichnen, so können wir dem Unterprogramm die Grösse als Zahl übergeben.

Definition (links) und Aufruf (rechts) der Funktion stufe mit einem Argument groesse

Im Unterprogramm wird diese übergebene Zahl dann verwendet und zwar beim Vorwärts-Fahren der Turtle. Der 90-Grad-Winkel bleibt natürlich immer gleich, egal wie gross die Stufe sein soll!

import turtle

def stufe(groesse):
    # Zeichnet eine Treppenstufe variabler Grösse
    turtle.forward(groesse)
    turtle.left(90)
    turtle.forward(groesse)
    turtle.right(90)

stufe(100)
stufe(75)
stufe(50)

1
2
3
4
5
6
7
8
9
10
11
12

Zeile 3: Wir definieren ein Unterprogramm stufe, welches ein einzelnes Argument entgegennimmt. Dieses Argument soll im Unterprogramm mit dem Namen groesse zur Verfügung stehen.
Zeilen 5+7: hier wird das Argument für das Zeichnen der Stufe verwendet
Zeile 10: Das Unterprogramm wird aufgerufen und zeichnet eine Stufe der Grösse 100
Zeile 11: Das Unterprogramm wird nochmals aufgerufen und zeichnet eine Stufe der Grösse 75
Zeile 12: Das Unterprogramm wird ein drittes Mal aufgerufen und zeichnet eine Stufe der Grösse 50

Aufgabe «Stern»

Wir versuchen einen 6-zackigen Stern zu zeichnen. Das Unterprogramm für eine Zacke ist gegeben:

import turtle

def zacke(groesse):
    # Zeichnet einen Sternzacken
    turtle.right(5)
    turtle.forward(groesse)
    turtle.right(170)
    turtle.forward(groesse)
    turtle.left(115)

1
2
3
4
5
6
7
8
9

Versuche den 6-zackigen Stern zu zeichnen
Verpacke den Code des Sterns in ein zweites Unterprogramm stern. Du solltest nun einfach mehrere Sterne (wenn möglich mit verschiedener Grösse) zeichnen können!

Lösung «Stern»

import turtle

def zacke(groesse):
    # Zeichnet einen Sternzacken
    turtle.right(5)
    turtle.forward(groesse)
    turtle.right(170)
    turtle.forward(groesse)
    turtle.left(115)

def stern(groesse):
    # Zeichnet einen 6-zackigen Stern
    zacke(groesse)
    zacke(groesse)
    zacke(groesse)
    zacke(groesse)
    zacke(groesse)
    zacke(groesse)

stern(200)
turtle.penup()
turtle.left(30)
turtle.forward(200)
turtle.pendown()
stern(80)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Zusatzaufgabe «Weihnachten»

Zeichne weitere Sterne. Kannst du diese ausfüllen? Vielleicht in weihnachtlichen Farben?

# Rückgabewert zurückliefern

Unsere selbst definierten Unterprogramme haben die Turtle herumfahren lassen. Häufig werden Unterprogramme aber verwendet um etwas zu Berechnen. Der berechnete Wert wird dann zurückgeliefert und kann vom aufrufenden Programm weiterverwendet werden.

Wir könnten z.B. berechnen, wie weit die Turtle von ihrem Ausgangspunkt entfernt ist. Da die Turtle beim Punkt (0,0) startet, können wir die Berechnung einfach mit Pythagoras machen. Mit den aktuellen Koordinaten der Turtle lässt sich die Distanz wie folgt berechnen:

Diesen berechneten Wert soll dann weiterverwendet werden können:

Definition (links) und Aufruf (rechts) der Funktion distanz mit Rückgabewert

Das Unterprogramm zur Berechnung der Quadratwurzel finden wir im math-Modul.

import turtle, math

def distanz():
    x,y = turtle.pos()
    d = math.sqrt(x*x + y*y)
    return d
    
turtle.left(30)
turtle.forward(100)
turtle.left(160)
turtle.forward(50)

strecke = distanz()     # Funktion aufrufen und Wert merken
print(strecke)          # Wert ausgeben

turtle.left(39)         # etwa in Richtung Start ausrichten
turtle.forward(strecke) # zum Start zurückfahren

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

← Die Sequenz Listen und Wiederholungen →