12    Die Schildkröte – ein grafischer Roboter

Du weißt jetzt sehr viel darüber, wie man in Python programmiert. Nun soll es auch darum gehen, was man mit Python alles steuern und programmieren kann. Immer nur Buchstaben und Zahlen auf einer Konsole ein- und auszugeben, wird irgendwann öde. Darum lernst du jetzt eine Methode kennen, mit Python Grafik auf dem Bildschirm auszugeben und zu steuern.

Was man genau alles mit Python auf den verschiedensten Gebieten erreichen kann, hängt am Ende immer von den Modulen ab, die man einbindet. Module können nicht nur zusätzliche Befehle und Funktionen bereitstellen, sondern sie können uns ganze Oberflächen und Ausgabefenster bescheren, samt Figuren und grafischen Mustern, die wir darauf erzeugen können. Jetzt zeigt Python auch mal ein optisch schönes Gesicht.

Das Modul, mit dem du in diesem Kapitel arbeiten wirst, heißt gturtle.

gturtle ist ein Turtle-Grafik-Modul (das heißt auf Deutsch Schildkröten-Grafik). Das heißt, das Modul enthält Befehle und Funktionen, mit denen man ein Zeichenfenster erstellen kann, darauf eine Figur steuern kann (in der Regel eine Schildkröte, aber man kann sie auch ändern) und mit dieser Figur auch Spuren hinterlassen, das heißt, zeichnen kann.

gturtle gibt uns also so etwas wie einen kleinen Malroboter in einem Fenster – und diesen Roboter steuerst du mit Python.

Als Erstes muss das Modul gturtle importiert werden. Du kannst das mit

import gturtle 

machen, aber dann musst du gturtle und einen Punkt vor jeden weiteren Befehl dieses Moduls schreiben (wie wir es bei random auch immer gemacht haben). Da wir hier aber sehr viele gturtle-Befehle verwenden werden, erleichtern wir uns die Arbeit und importieren einfach alle Befehle aus gturtle direkt in unsere Python-Engine.

from gturtle import *

Jetzt können wir alle Befehle dieses Moduls ohne vorangestelltes gturtle verwenden.

Die Schildkröte steuern

Der erste Turtle-Befehl, den du kennenlernst, ist

makeTurtle()

Auf Deutsch: »Erstelle Schildkröte.« Mit diesem Befehl wird das Grafikfenster samt der Schildkröte erstellt. Diesen Befehl brauchst du immer als Erstes, weil du erst danach ein Ausgabefenster und eine Schildkröte zum Steuern hast.

Probiere es einfach mal aus:

from gturtle import *
makeTurtle()

Wenn du das Programm startest, erscheint sofort der Turtle Playground (»Schildkrötenspielplatz«):

Das Standardfenster von gturtle mit der Schildkröte in der Mitte. Die Größe ist 800 Pixel Breite, 600 Pixel Höhe, wenn nichts anderes definiert wurde.

Abbildung 12.1    Das Standardfenster von gturtle mit der Schildkröte in der Mitte. Die Größe ist 800 Pixel Breite, 600 Pixel Höhe, wenn nichts anderes definiert wurde.

Soll die Schildkröte eine andere Farbe haben? Dann kannst du die Farbe auf Englisch dem makeTurtle-Befehl in Klammern mitgeben:

makeTurtle("red") oder makeTurtle("brown")

Was auch immer dir am besten gefällt. Ich mag die Schildkröte gern in neutralem Grau:

makeTurtle("gray")

Du kannst auch die Form der Schildkröte oder die Größe des Grafikfensters ändern. Aber wir lassen das jetzt erst einmal auf Standard, und beschäftigen wir uns später mit den Feinheiten. Jetzt soll es erst mal losgehen. Wir wollen die Schildkröte in Bewegung setzen. Dafür stellt uns das Modul gturtle zahlreiche Bewegungsbefehle zur Verfügung, die du in Python nutzen kannst.

Der erste Befehl lautet

forward(weite)

forward bedeutet »vorwärts« – die Weite wird in Pixeln angegeben. 1 Pixel ist ein Punkt auf dem Bildschirm.

Also probiere mal aus:

from gturtle import *
makeTurtle("gray")
forward(100)
Die Schildkröte bewegt sich 100 Pixel nach oben und zieht dabei eine Linie.

Abbildung 12.2    Die Schildkröte bewegt sich 100 Pixel nach oben und zieht dabei eine Linie.

Wie du siehst: Mit dem forward-Befehl bewegt die Schildkröte sich vorwärts – also in die Richtung, in die ihr Kopf gerade zeigt. Das ist in diesem Fall nach oben. Sie zieht dabei eine Spur hinter sich her. Mit der Schildkröte kann man zeichnen!

Der Befehl back(weite) macht das Gegenteil – die Schildkröte läuft rückwärts. Probiere es mal aus:

from gturtle import *
makeTurtle("gray")
forward(100)
back(100)

Jetzt soll die Schildkröte natürlich nicht nur auf einer Linie nach oben und unten laufen können. Damit man mit ihr sinnvoll zeichnen kann, muss sie sich natürlich auch drehen können. Dafür gibt es zwei Befehle. Nämlich:

left(Winkel) Drehung nach links
right(Winkel) Drehung nach rechts

Die Winkel sind dabei immer von der aktuellen Richtung der Schildkröte abhängig. Also 0 Grad bedeutet, die Schildkröte dreht sich gar nicht, bei 180 Grad dreht sie sich um in die Gegenrichtung. 90 Grad ist genau der rechte Winkel, also im rechten Winkel nach rechts oder links.

Mit dem rechten Winkel kann man doch gleich mal ein schönes Quadrat zeichnen.

from gturtle import *
makeTurtle("gray")
forward(100)
right(90)
forward(100)
right(90)
forward(100)
right(90)
forward(100)
right(90)
Vier mal 100 Pixel weit gelaufen und dann 90 Grad nach rechts gedreht. Fertig ist das Quadrat.

Abbildung 12.3    Vier mal 100 Pixel weit gelaufen und dann 90 Grad nach rechts gedreht. Fertig ist das Quadrat.

Aber halt! Du bist ja kein Python-Anfänger mehr. Dieses Programm macht vier Mal dasselbe – es schickt die Schildkröte 100 Pixel vorwärts und dreht sie dann 90 Grad nach rechts. Da verwenden wir doch … natürlich … eine Schleife.

from gturtle import *
makeTurtle("gray")
repeat 4:
forward(100)
right(90)

Und schon ist das Programm kürzer und macht dasselbe.

Und mit deinen Programmierkenntnissen steht dir jetzt schon eine Menge zur Verfügung, was du mit der Schildkröte machen kannst.

Probiere mal folgendes Programm aus:

from gturtle import *
makeTurtle("gray")
weite = 10
repeat 50:
forward(weite)
right(90)
weite = weite + 10

Schau es dir zuerst genau an, und überlege, was es macht, bevor du es startest. weite wird auf 10 gesetzt. Dann macht die Turtle 50 Mal dasselbe: Geht vorwärts – und zwar so viele Pixel, wie in weite steht, also erst mal 10, dann biegt sie 90 Grad nach rechts ab, dann wird weite vergrößert, um zehn. Die nächste Linie ist also 20 Pixel lang, dann wieder abbiegen, dann 30 Pixel weit vorwärts … was für ein Gebilde entsteht da?

Eine coole rechteckige Spirale!

Abbildung 12.4    Eine coole rechteckige Spirale!

So kann man mit nur wenigen Zeilen Python-Code interessante Figuren zeichnen, alles durch vielfache Wiederholung, bei der sich jedes Mal ein Wert ändert.

Warum dauert das Zeichnen mit der Schildkröte eigentlich so lange? Ist Python wirklich so langsam? Natürlich nicht. Die Geschwindigkeit der Turtle ist als Standard auf langsam gestellt, damit man gut mitverfolgen kann, was passiert. Mit der Funktion speed(geschwindigkeit) kannst du die Geschwindigkeit der Turtle beim Vorwärtsgehen ändern. 1 ist extrem langsam (1 Pixel pro Sekunde), 1.000 wäre recht schnell.

Füge also mal

speed(1000)

vor der repeat-Schleife ein, dann wird die Turtle schneller.

Am schnellsten aber geht es, wenn die Turtle gar nicht mehr angezeigt wird. Mit dem Befehl

hideTurtle()

kannst du die Turtle unsichtbar machen, und das Zeichnen geht nun blitzschnell. Ersetze den speed(1000)-Befehl durch den Befehl hideTurtle().

Die Spirale erscheint jetzt sofort, in Sekundenbruchteilen.

Wieder sichtbar macht man die Schildkröte übrigens mit

showTurtle()
Aufgabe

Lass die Turtle ein Dreieck zeichnen.

Wie gehst du vor? Beim Quadrat musstest du vier Linien zeichnen und dazwischen jedes Mal 90 Grad nach rechts. Klar, 4 × 90 ergibt 360 – damit ist man einmal rum. Beim Dreieck ist es ähnlich. Nur musst du nur drei Linien zeichnen (zum Beispiel mit der Länge 200) und dazwischen jeweils 120 Grad drehen, denn 3 × 120 ist wieder 360 – und das muss für eine geschlossene Figur am Ende immer herauskommen.

from gturtle import *
makeTurtle("gray")
repeat 3:
forward(200)
right(120)
So geht ein Dreieck. Drei Linien und dazwischen um 120 Grad drehen.

Abbildung 12.5    So geht ein Dreieck. Drei Linien und dazwischen um 120 Grad drehen.

Und ein Sechseck? Kannst du das Programm selbst so ändern, dass ein sauberes Sechseck entsteht? Logisch, oder?

from gturtle import *
makeTurtle("gray")
repeat 6:
forward(100)
right(60)

Statt drei Mal wird sechs Mal gezeichnet, die Länge dabei nur 100, damit die Figur nicht zu groß wird, und der Winkel natürlich 360 geteilt durch 6, also 60.

Daraus kannst du jetzt ein universelles Programm machen. Der Benutzer gibt ein, wie viele Ecken die Figur haben soll, und das Programm zeichnet darauf ein gleichseitiges 3-, 5-, 7-, 9-, 10- oder n-Eck.

Zu beachten ist dabei Folgendes: Die Schrittweite der Turtle muss umso kleiner sein, je mehr Ecken gewünscht sind. Am besten etwa 600 geteilt durch Eckenanzahl. Die Anzahl der Ecken entspricht natürlich der Anzahl der Linien. Der Winkel nach dem Zeichnen der Linie ist immer 360 geteilt durch Anzahl der Ecken.

Kriegst du so ein Programm hin? Versuche es einmal! Anschließend kannst du es mit der Version hier vergleichen:

from gturtle import *
makeTurtle("gray")
ecken = input("Wie viele Ecken?")
weite = 600 / ecken
repeat ecken:
forward(weite)
right(360 / ecken)

Teste das Programm mit verschiedenen Werten. Was beobachtest du?

Ein 36-Eck sieht einem Kreis schon ganz schön ähnlich.

Abbildung 12.6    Ein 36-Eck sieht einem Kreis schon ganz schön ähnlich.

Genau: Je mehr Ecken du zeichnen lässt, desto mehr ähnelt das gleichseitige n-Eck einem Kreis. Der perfekte Kreis wäre somit ein gleichseitiges n-Eck mit unendlichen vielen Ecken … aber aufgrund der begrenzten Auflösung eines Computerbildschirms reichen 36 Ecken fast aus, um einen schönen Kreis zu zeichnen.

Aufgabe

Schreibe ein Turtle-Programm, das ein Zickzackmuster und/oder eine Treppe zeichnet. Verwende dabei Wiederholungen (repeat).