DigitechAG 22.5. Python Turtle Unterprogramme

Letzte Woche haben wir zum ersten mal eigene Unterprogramme im der Programmiersprache Python definiert. Diese Unterprogramme ermöglichen es, Befehlsfolgen mehrfach wieder zu verwenden und dabei über Parameter anzupassen.

Wir schreiben die gewünschte Länge der Linie in eine Variable namens laenge. Hier zum Beispiel den Wert 100.

Unsere Schildkröte soll ein Drittel der gewünschten Länge nach vorne laufen, dann nach rechts drehen, ein Drittel laufen, in die entgegen gesetzte Richtung nach links drehen, ein Drittel laufen, zurück in die ursprüngliche Richtung nach rechts drehen und nochmal ein Drittel der Länge laufen.

Nun kannst Du ausprobieren, wie sich die Linie verändert, wenn Du zum Beispiel andere Werte in der Zeile laenge = 100 einträgst. Du kannst auch andere Winkel anstelle der 60 Grad ausprobieren. Wie kannst Du dann den passenden Winkel anstelle der 120 Grad Linksdrehung berechnen? Natürlich so, dass die Schildkröte dann wieder in der ursprünglichen Richtung läuft.

Wenn Du willst, kannst Du die 60 Grad ebenfalls durch eine Variable winkel ersetzen.

import turtle as t
t.shape("turtle")
t.speed(10)

# Variable "laenge" und dem Wert 200
laenge = 100

# horizontal
t.forward(laenge/3)
t.right(60)
# zick
t.forward(laenge/3)
t.left(120)
# zack
t.forward(laenge/3)
t.right(60)
# horizontal
t.forward(laenge/3)

import turtle as t
t.shape("turtle")
t.speed(10)

# Unterprogramm mit Namen "zickzack"
# Parameter "laenge"
def zickzack(laenge):
    t.forward(laenge/3)
    t.right(60)
    t.forward(laenge/3)
    t.left(2*60)
    t.forward(laenge/3)
    t.right(60)
    t.forward(laenge/3)

# das Unterprogramm drei mal benutzen
zickzack(10)
zickzack(50)
zickzack(100)

Um die Befehlsfolge für die Zick-Zack Linie wiederverwenden zu können, gibt es Unterprogramme. Du kannst also dem Python eigene Befehle beibringen und dann benutzen.

Unser Unterprogramm beginnt mit
def zickzack(laenge):
Das def sagt dem Python, dass hier ein Unterprogramm definiert wird. Das zickzack ist der Name des Unterprogramms. In den Klammern stehen die Variablennamen für Parameter. Und der Doppelpunkt sagt, dass in den nächsten Zeilen ein Befehlsblock kommt. Der Befehlsblock sind alle Zeilen, die eingerückt sind.

Benutzen kannst Du dein Unterprogramm nun wie alle anderen Befehle auch mit name(parameter1, parameter2, ...). Am Ende des Beispiels siehst Du, wie wir es drei mal benutzen, um eine Zickzack-Linie mit Länge 10, 50 und 100 zu zeichnen.

Nun wird es spannend: Wir wollen in die Teilstrecken unserer ZickZack Linie nochmals kleinere Zacken einbauen. Dies erreichen wir, indem wir ein zweites Unterprogramm namens zickzack1 definieren. Dieses sieht im Prinzip genauso aus wie das Unterprogramm zickzack. Aber anstelle der Schildkröten-Bewegung t.forward(...) benutzten wir nun unser erstes Unterprogramm zickzack(...).

import turtle as t
t.shape("turtle")
t.speed(100)

# Unterprogramm mit Namen "zickzack"
# Parameter: Variable "laenge"
def zickzack(laenge):
    t.forward(laenge/3)
    t.right(60)
    t.forward(laenge/3)
    t.left(2*60)
    t.forward(laenge/3)
    t.right(60)
    t.forward(laenge/3)

def zickzack1(laenge):
    zickzack(laenge/3)
    t.right(60)
    zickzack(laenge/3)
    t.left(2*60)
    zickzack(laenge/3)
    t.right(60)
    zickzack(laenge/3)    

zickzack1(300)
t.left(120)
zickzack1(300)
t.left(120)
zickzack1(300)
t.left(120)

Nun kannst Du diese Idee selber fortsetzen. Definiere ein weiteres Unterprogramm namens zickzack2. Dieses soll nun das zickzack1 zum Zeichnen der „Linien“ verwenden.

Zum Ausfüllen der Fläche kannst Du fillcolor, begin_fill und end_fill verwenden, wie im Beispiel.

t.fillcolor("#A0A0FF")
t.begin_fill()
zickzack2(300)
t.left(120)
zickzack2(300)
t.left(120)
zickzack2(300)
t.left(120)
t.end_fill()

Zum Ende wird es nun noch verrückter: Wir wollen beliebig viele Zacken in die Zacken in den Zacken und so weiter einsetzen. Damit wir dafür nicht noch mehr Unterprogramme schreiben müssen, benutzen wir eine andere Taktik.

Unser Unterprogramm zickzack bekommt einen zweiten Parameter namens tiefe. Diesen benutzen wir, um die Verschach­telungstiefe zu zählen.

Ist tiefe == 0 dann zeichnen wir nur eine gerade Linie mit t.forward(laenge).

Ansonsten, also wenn die Tiefe größer 0 ist, zeichnen wir unsere Zick-Zack Linie und benutzen wieder das selbe Unterprogramm zickzack. Als Parameter übergeben wir ein Drittel der Länge und unsere aktuelle Tiefe minus 1.

Das hat folgende Konsequenzen: Wenn wir zickzack(300,4) benutzen, dann benutzt dies intern zickzack(300/2,4-1), also mit Länge 150 und Tiefe 3. Dieses wiederum benutzt zickzack(150/2,3-1), jenes zickzack(75/2, 2-1) und jenes zickzack(37.5/2, 1-1), also mit Länge 18.75 und Tiefe 0. Das letzte Zickzack malt dann also endlich mal tatsächlich eine Linie.

import turtle as t
t.shape("turtle")
t.speed(100)

# Unterprogramm mit Namen "zickzack"
def zickzack(laenge, tiefe):
    if tiefe == 0:
        t.forward(laenge)
    else:
        zickzack(laenge/3, tiefe-1)
        t.right(60)
        zickzack(laenge/3, tiefe-1)
        t.left(2*60)
        zickzack(laenge/3, tiefe-1)
        t.right(60)
        zickzack(laenge/3, tiefe-1)

t.fillcolor("#A000FF")
t.begin_fill()
zickzack(300,4)
t.left(120)
zickzack(300,4)
t.left(120)
zickzack(300,4)
t.left(120)
t.end_fill()