Kapitel III - Eine Schildkröte zum Zeichnen

Übersicht

Nach einer kurzen Erläuterung der sogenannten objektorientierten Programmierung werden wir ein erstes "virtuelles" Objekt kennenlernen. Dies ist ein sog. Turtle-Objekt und ermöglicht uns u.a. Zeichnungen auf dem Bildschirm bzw. einer speziellen Zeichenfläche anzufertigen.
An ersten Programmen, die die Turtle-Objekte benutzen, wirst du nochmal anschaulich sehen, dass sich Programme aus einzelnen Anweisungen, die der Computer versteht, zusammensetzen.
Wir werden aber nicht nur die Programme an sich schreiben, sondern uns auch im Vorfeld in einer Planungsphase mit dem Entwurf eines solchen Programmes beschäftigen. Da wir sehr viel zeichnen wollen, werden wir den Entwurf des Programmes auf einem Blatt Papier vornehmen. Dies hilft uns, die notwendigen Bewegungen der Turtle zu ermitteln und zu verstehen.
Auch wenn es später nicht mehr explizit erwähnt sein wird, dass du eine Skizze o.ä. anfertigen sollst, ist dies selbstverständlich noch immer hilfreich und teilweise auch zum Lösen der Aufgabe notwendig.

Lernziele
Am Ende dieses Kapitels kannst du

die Grundidee der objektorientierten Programmierung erläutern.
den Bauplan der Klasse Turtle laden und ein zugehöriges Objekt erzeugen.
Variablen nutzen, um einem erstellten Turtle-Objekt einen Namen zu geben und später gezielt ansprechen zu können.
ein Objekt der Klasse Turtle bewegen und drehen.
Programme, die einfache geometrische Figuren zeichnen, planen und programmieren.
mittels Skizzen Bewegungen und Drehungen der Turtle-Objekte planen.
benennen, was man unter den jeweiligen Betriebssystemen beachten muss, wenn man die Turtle erfolgreich nutzen will.

Achtung

Bevor du das Kapitel bearbeiten kannst, musst du, sofern nicht bereits gesehen, eine wichtige Einstellung in PyScripter (unter Windows!) vornehmen. Bitte prüfe, ob unter "Run -> Python Engine" die Einstellung "Remote (Tk)" ausgewählt ist. Wenn nicht, ändere dies bitte, da sonst die Programme aus diesem und den folgenden Kapitel leider nicht laufen werden.

Screenshot der zu ändernden Einstellung

Leider scheint es so, als würde PyScripter sich diese Einstellung, beispielsweise bedingt durch einen Absturz, nicht merken. Es kann also sinnvoll sein, diese bei Problemen zu kontrollieren. Du kannst auch nach dem Start in der Shell ablesen, welche Engine ausgewählt ist.

Unter Linux (bzw. an den Schulcomputern) musst du in Geany unter "Erstellen" und dann unter "Kommandos zum Erstellen konfigurieren" noch die zu verwendende Python-Version einstellen:

Screenshot der zu ändernden Einstellung

Ändere bitte unter "Befehle zum Ausführen" bei "Execute" python in python3!

Was du zusätzlich noch unter Linux beachten musst, erfährst du bei Aufgabe 2.

Objektorientierte Programmierung

Unter der objektorientierten Programmierung versteht man eine grundlegende Art der Programmierung. Die grundlegende Idee, die zur Objektorientierung geführt hat, ist, dass man versuchen wollte, die Realität möglichst exakt in den Programmen bzw. in den Planungen zur Programmentwicklung umzusetzen. Wie dies genau zu verstehen ist, wollen wir uns jetzt kurz einmal genauer ansehen.

In der realen Welt haben wir es mit unterschiedlichen Objekten zu tun: dein Lieblingsbuch, das Auto, in dem du zuletzt drin gesessen hast, der Bus, mit dem du zur Schule gefahren bist, dein Fahrrad, der Stuhl, auf dem du gerade sitzt ...

Gleiche bzw. ähnliche Objekte kann man zu einer Klasse zusammengefasst: So kann man u.a. dein Lieblingsbuch, dein Mathematikbuch, das Deutschbuch des letzten Schuljahres, den Comic, den du gerade gelesen hast, zu einer Klasse "Buch" zusammenfassen. Sicherlich ist die Zusammenfassung sehr grob. Man kann sicherlich noch eine genauere Unterteilung finden, beispielsweise "Kinderbuch" oder "Schulbuch" etc. Zu dieser genaueren Unterteilung macht man sich im Vorfeld der Programmierung, im sog. Modellierungsprozess sehr viele Gedanken.

Alle Objekte, die zu dieser Klasse gehören, haben bestimmte Eigenschaften. So hat jedes Buch einen Autor, einen Titel, einen Verlag, eine Seitenanzahl, ein Titelbild ... Diese Eigenschaften haben auch alle anderen Objekte der Klasse "Buch". Man fasst quasi die grundlegenden Gemeinsamkeiten, die ein jedes Objekt der Klasse haben muss, in einer "Klassenbeschreibung" oder anders ausgedrückt, in einem Bauplan zusammen. In diesem Fall umfasst die Klasse "Buch" die grundlegenden Gemeinsamkeiten Titel, Autor, Verlag etc. Um nun ein neues Objekt der Klasse "zu erzeugen", muss jemand ein Buch schreiben. Diese Person wird dann entsprechend der Autor dieses konkreten Buches. Er gibt seinem Buch einen Titel. Es werden also sukzessive alle grundlegenden Gemeinsamkeiten mit konkreten Werten ausgefüllt.

Neben einer Vielzahl von Eigenschaften haben alle Objekte einer bestimmten Klasse gemeinsame Fähigkeiten. Betrachten wir als nächstes Beispiel ein Reitpferd. Ein Objekt der Klasse "Reitpferd" hat u.a. folgende Eigenschaften: eine bestimmte Farbe, ein bestimmtes Geschlecht, ein Gewicht und einen Besitzer. Alle diese Eigenschaften haben die anderen Reitpferde auch. Daher kann man diese in den Bauplan zur Klasse "Reitpferd" aufnehmen. Zusätzlich hat ein jedes solcher Pferde-Objekte noch bestimmte Fähigkeiten: Ein jedes Reitpferd kann laufen, springen, wiehern, galoppieren, den Reiter abwerfen. Daher nehmen wir diese in unsere Klassenbeschreibung auf. Tabellarisch zusammengefasst erhalten wir für unsere Klassenbeschreibung bzw. unseren Bauplan "Reitpferd":

Bauplan der Klasse "Reitpferd"

Aufgabe 1

Überlege dir Eigenschaften und Fähigkeiten eines PKW und erstelle darüber eine tabellarische Übersicht.

Mögliche Lösung:
Abbildung

Tipp um deine Lösung zu prüfen: Überlege nochmals, ob wirklich jedes Auto diese Eigenschaft bzw. Fähigkeit hat. Die Fähigkeit, einen Anhänger zu ziehen haben sicherlich nicht alle Autos. Dazu benötigen sie nämlich eine Anhängerkupplung. Diese ist aber nicht "standardmäßig" eingebaut.
Ähnlich verhält es sich mit einer Eigenschaft "Kühlerfigur". Nicht jedes Auto besitzt eine solche. Nur bestimmte Hersteller verbauen diese bei einigen Modellen. Du solltest also deine Lösung nun nochmal sehr genau reflektieren. Wenn du unsicher bist, dann nutze die Möglichkeit, mit einem Mitschüler darüber zu diskutieren.

Auch bei diesem Beispiel aus der Aufgabe werden beim Bau eines Objektes des Klasse "PKW" wieder alle Eigenschaften konkret mit Werten belegt. Das Auto bekommt eine Farbe, einen bestimmten Motor (PS) eingebaut, eine Anzahl von Sitzen und Türen eingebaut ... So entsteht schließlich in vielen Arbeitsschritten das Auto deiner Eltern oder deines Lehrers.

Die Autos der beiden Brüder Ralf und Michael Schumacher gehören zwar beide zur Klasse "PKW", da sie die entsprechenden Eigenschaften und Fähigkeiten haben, sind aber dennoch verschiedene Objekte: Das eine Auto ist vielleicht rot, das andere womöglich silbern. Das eine Auto hat ein anderes Kennzeichen als das andere Auto. Beide Autos haben unterschiedliche Besitzer.

Die hier dargestellte Sichtweise auf die reale Welt wird in den sog. objektorientierten Sprachen umgesetzt. Die Objekte der realen Welt werden auf Basis ihrer Klassenbeschreibung "virtuell" repräsentiert. Alle Eigenschaften der Klasse bezeichnet man in der Informatik als "Attribute" und alle Fähigkeiten als "Methoden".

Innerhalb eines Programmes kann man nun anhand der Klassenbeschreibung ein solches virtuelles Objekt erschaffen und (später) wieder zerstören. Jedes dieser Objekte hat dann die durch die Klassenbeschreibung festgelegten Attribute (Eigenschaften) und stellt ferner die festgelegten Methoden (Fähigkeiten) zur Verfügung. So können wir ein virtuelles Auto erschaffen und damit - beispielsweise in einem Autorennspiel - über den Bildschirm fahren. Je nach Anwendungszweck sind anderen Attribute und Methoden wichtig. Vergleiche dazu ruhig das Autorennbeispiel mit einem "virtuellen Autoobjekt" in der Datenbank einer Autoversicherung. Eine Methode "beschleunigen" würde hier nicht gebraucht. Wichtiger wäre hier eine Methode "Versicherungsschaden begleichen" o.ä., auch wenn dieser - leider - manchmal in engem Zusammenhang zu einer rasanten Beschleunigung steht.

Die bisher getätigten Überlegungen wollen wir nun konkretisieren und an einem Beispiel verdeutlichen.

Die Klasse "Turtle"

Abbildung: Reales Objekt der
Klasse "Turtle"

Die erste (echte) Klasse, die wir kennenlernen werden, trägt den Namen "Turtle". Unter der Klasse "Turtle" werden "Softwaretiere" mit ihren Attributen und Methoden zusammengefasst. Jedes dieser Tiere besitzt einen Stift, mit dem es malen kann. Zu den Attributen der Klasse "Turtle" gehören beispielsweise die Dicke oder Farbe des Stiftes. Neben den Attributen stellen Objekte der Klasse unterschiedliche Methoden bereit. So kann man ein solches Turtle-Objekt über den Bildschirm jagen und dabei malen lassen. Die Objekte haben aber auch die Fähigkeit, den Stift ggf. vorher anzuheben. Diese und weitere Methoden und Attribute werden wir jetzt bzw. später noch genauer kennenlernen.

Bevor wir ein Objekt der Klasse Turtle erzeugen können, müssen wir zuerst den Bauplan laden. Dies hat einen einfachen Grund. Python lädt nicht von Anfang an alle möglichen Baupläne, denn die wenigsten davon werden in jedem Programm gebraucht. Es ist Aufgabe des Programmierers, dafür zu sorgen, dass alle benötigten Baupläne bzw. Klassenbeschreibungen geladen werden. Würde man von vorneherein immer alle Klassenbeschreibungen laden, würden unsere Programme viel Speicherplatz benötigen und lange zum Starten brauchen. Du kannst dir das ungefähr so vorstellen, als wenn du beim Skifahren auch noch deine komplette Strandausrüstung mitschleppen würdest, weil du diese ja unter Umständen brauchen könntest. Diesen unnötigen Ballast kann man sich (offensichtlich) sparen. Daher packst du nur die Sachen ein, die du wirklich brauchst. Ähnlich verhält es sich auch mit dem Importieren von Klassenbeschreibungen. Wir laden immer nur das, was wir wirklich brauchen!

Um die Klassenbeschreibung der Klasse "Turtle" zu laden, muss man folgenden Befehl in der Python-Shell eingeben. Da wir gleich mit PyScripter weiterarbeiten, solltest du ruhig die hier vorliegende Shell mit dem Titel "Python Interpreter" benutzen.

from turtle import Turtle

Zur Erklärung: Der vorliegende Befehl weißt Python an, aus (from) dem Modul turtle den Bauplan (Turtle) zu laden (import). Achte auch hier auf Groß- und Kleinschreibung. In dem Modul turtle finden sich alle relevanten Informationen zur Klasse Turtle, die Python benötigt. Wir merken, dass der Computer kurz lädt. Anschließend ist die Python-Shell wieder einsatzbereit.

Wir können also nun weitermachen und ein Objekt der Klasse "Turtle" erzeugen, d.h. nach dem hinterlegten Bauplan zusammenbauen lassen. Dazu schreibt man den Klassennamen gefolgt von Klammern (), in diesem Fall also Turtle(). Du kennst diese Schreibweise bereits von Funktionsaufrufen, beispielsweise der print()-Funktion. Das Ergebnis des Aufrufes ist ein neues Turtle Objekt. In der Python-Shell erscheint:

Turtle()
<turtle.Turtle object at 0x02BB6DB0>

Zusätzlich erscheint ein weiteres Fenster mit dem Titel "Python Turtle Graphics". Sollte es im Folgenden Probleme geben, prüfe bitte, ob du den Hinweis zu Beginn des Kapitels berücksichtigt hast!

Abbildung: Ein Objekt der Klasse "Turtle" in der Ausgangsposition.

Die Ausgabe

<turtle.Turtle object at 0x02BB6DB0>

informiert uns darüber, dass ein Objekt der im Modul turtle definierten Klasse Turtle erfolgreich erstellt wurde. Es wurde im Speicher abgelegt und ist dort unter der Adresse "0x02BB6DB0" zu finden. Diese Adresse muss nicht mit der Adresse übereinstimmen, in der das von dir erzeugte Objekt gespeichert wurde. Wir haben jetzt zwar das Objekt erzeugt und speichern lassen, leider können wir aber noch nicht (ohne weiteres) darauf zugreifen und damit arbeiten. Bitte schließe das Fenster mit dem Titel "Python Turtle Graphics" wieder. Bitte achte auch in Zukunft darauf, dass du das Fenster nach dem Programmende bzw. vor dem Starten eines neuen oder korrigierten Programmes schließt. Es kommt sonst zu unerwünschten Nebeneffekten.

Um einen umständlichen Zugriff über die Adresse im Speicher zu vermeiden, gibt es in allen Programmiersprachen eine einfache Technik. Du kennst diese im Prinzip schon aus der Mathematik. Ein kleiner Hinweis am Rande: Auch wenn hier öfter ein Bezug zur Mathematik hergestellt wird, heißt das nicht, dass man gut in Mathematik sein muss, um ein guter Programmierer zu werden!

Namen für Objekte: Variablen

Um mit einfachen Mitteln auf das bzw. ein Objekt zugreifen zu können, kann man in allen Programmiersprachen Namen dafür vergeben, man sagt dann: "Name zeigt auf das Objekt". Beispielsweise kann man meineTurtle oder schildkroete als Namen wählen. Bei der Namenswahl gibt es allerdings einige Regeln zu beachten:

Namen dürfen nur aus Buchstaben (ohne ä,ö,ü oder ß), Ziffern oder einem Unterstrich (_) bestehen. Das erste Zeichen darf allerdings KEINE Ziffer sein.
Es dürfen einige reservierte Wörter nicht als Namen benutzt werden. Wir werden diese noch kennenlernen.
Nach Möglichkeit soll der Name für ein Objekt mit einem Kleinbuchstaben beginnen.

Da die Objekte, auf die ein Name zeigt, wechseln können, bezeichnet man diese Namen auch als Variablennamen oder Variable. Der Begriff "variabel" meint nichts anderes als veränderlich. Den Begriff hast du bestimmt schon in der Mathematik kennengelernt. Wie vergibt man nun Namen? Hier kommt der sogenannte Zuweisungsoperator (=) zum Zuge. Zuerst wählt man also einen gültigen Namen, beispielsweise myTurtle. Dann gibt man den gewünschten Namen in die Python-Shell gefolgt von einem Gleichheitszeichen, das für den Zuweisungsoperator steht, ein. Was soll unserem Namen jetzt zugewiesen werden? Na klar, unser neu erzeugtes Turtle-Objekt. Fertig sieht die Anweisung wie folgt aus:

 myTurtle = Turtle()

Ob das ganze geklappt hat, erkennst du daran, dass wieder das Fenster mit der Turtle aufgeht. Geben wir nun

 myTurtle

in der Shell ein, so liefert uns Python eine bekannte Ausgabe:

<turtle.Turtle object at 0x02BDDFF0>

Unser Turtle-Objekt wurde also wieder erstellt. Nur diesmal können wir es ganz leicht ansprechen, weil ein Name auf es zeigt.

Wir haben bereits besprochen, dass alle Objekte Eigenschaften und Fähigkeiten haben. Die Turtle besitzt beispielsweise verschiedene Kostüme und hat die Fähigkeit, diese zu wechseln. Dazu stellen alle Turtle-Objekte eine Methode shape() (engl. für Gestalt) bereit. Als Argument benötigt diese Methode das neue Kostüm als String oder Zeichenkette. Wir möchten, dass unsere Turtle wie eine Turtle aussieht. Als müssen wir die Methode shape() mit dem Argument "turtle" aufrufen, also shape("turtle"). Damit sich aber unsere Turtle angesprochen fühlt, müssen wir diese Turtle über ihren Namen ansprechen. Dies geschieht mit dem folgenden Befehl:

 myTurtle.shape("turtle")

Wir geben also den Namen des Objektes gefolgt von einem Punkt und der Methode sowie ihren Argumenten ein. Das angesprochene Objekt sollte nun ihr Kostüm wechseln und aussehen wie eine Schildkröte.

Aufgabe 2

Schreibe ein Programm, dass ein Turtle-Objekt erzeugt. Der Name des Objektes soll "secondTurtle" lauten. Anschließend soll das Turtle-Objekt ihr Schildkrötenkostüm anziehen. Speichere die Datei unter dem Namen "secondTurtle.py" ab.
Beachte unter Linux: Die letzte Anweisung in deinem Programm muss - im Fall, dass dein Turtle-Objekt "secondTurtle" heißt - wie folgt lauten:

 secondTurtle.screen._root.mainloop()

Gewöhne dir ab sofort an, diese Anweisung, ggf. hinsichtlich des Objektnames angepasst, in deine Programme zu integrieren. Auch wenn du unter Windows arbeitest - hier kann die Anweisung nicht "schaden".

Lösung:
Ein Programm schreiben heißt in diesem Fall, dass wir den Editor von PyScripter bzw. Geany verwenden und nicht mehr die Python-Shell. Achte auch auf die Angabe eines Kopfkommentares.

 # # Autor(en)
 # Christian Graf 
 # # Datum 
 # 01.03.2011 
 # # letzte Aenderung
 # 01.03.2011
 # # Beschreibung
 # Turtle-Objekt mit Namen secondTurtle erzeugen und 
 # Schildkroetenkostuem anziehen. 
 from turtle import Turtle 
 secondTurtle = Turtle() 
 secondTurtle.shape("turtle") 
 # Fenster geoeffnet lassen - fuer Linux
 secondTurtle.screen._root.mainloop()

Achte darauf, dass du das Laden des Moduls nicht vergisst und die angepasste Anweisung für das geöffnete Fenster unter Linux ergänzt wird!

Weitere Fähigkeiten von Objekten der Klasse "Turtle"

Zu allen Fähigkeiten der Turtle-Objekte gibt es eine passende Methode, die das zugehörige Turtle-Objekt anweist, die Fähigkeit umzusetzen oder anzuwenden. Die Methode für den Kostümwechsel kennen wir bereits. Eine weitere Fähigkeit, die die Turtle-Objekte besitzen, ist, dass sie über den Bildschirm laufen kann und ihren Weg dabei mit einem Stift markieren kann. Dazu muss man die Methode forward() des Objektes aufrufen. Als Argument muss man die Anzahl der Bildpunkte, die sie vorgehen soll, übergeben. Achtung: Dieser Wert gehört nicht in Anführungszeichen. Dabei handelt es sich um eine Zahl und nicht um eine Zeichenkette. Wie bekannt gibt es einen Unterschied zwischen 2 und "2". Wir müssen hier also peinlichst genau darauf achten, den richtigen Wert bzw. die richtige "Sorte" von Wert zu übergeben.

Aufgabe 3

Gib den Befehl an, mit dem man das Turtle-Objekt, auf das der Name secondTurtle zeigt, 100 Bildpunkte vorwärts laufen lassen kann.

Lösung:
Wir geben wieder den Namen gefolgt von einem Punkt und der Methode mit ihrem Argument als Befehl ein:

 secondTurtle.forward(100)

Aufgabe 4

Erweitere das Programm "secondTurtle.py" zum Programm "secondTurtleMove.py". Zusätzlich soll sich das Turtle-Objekt noch ein bisschen nach vorne bewegen. Experimentiere mit verschiedenen Werten, um ein Gespür für die Entfernungen auf dem Bildschirm zu erlangen.

Lösung:
Wir erweitern unser Programm mit der Zeile 01 aus der letzten Aufgabe und speichern es unter dem neuen Dateinamen. Anpassen bzw. Erweitern des Kopfkommentares nicht vergessen. Bei einem Wert von 100 geht die jeweilige Turtle ungefähr zwei Daumenbreiten nach vorne.

Aufgabe 5

Der folgende Quelltext stammt aus einem umfangreicheren Programm.

aTurtle.shape("turtle") 
aTurtle.forward(100) 
aTurtle.forward(250)

Kannst du den Ausschnitt vereinfachen? Gib auch an, welche Voraussetzungen notwendig sind, damit das Programm ausgeführt werden kann.

Lösung:
Wir können die Zeilen 02 und 03 zusammenfassen. Es ist egal, ob wir diese Turtle zuerst 100 Schritte und dann nochmal 250 Schritte laufen lassen oder direkt 350 Schritte laufen lassen. Damit erhalten wir:

aTurtle.shape("turtle") 
aTurtle.forward(350)

Es muss im Vorfeld die Klasenbeschreibung geladen werden sowie ein Turtle-Objekt erzeugt worden sein. Dieses muss auch unter dem referenzierten Namen gespeichert worden sein, damit die hier vorgestellten Anweisungen ausgeführt werden können.

Nach dem Gehen kommt das Drehen ...

Die zweite zentrale Fähigkeit der Turtle-Objekte ist es, dass sie sich drehen können. Durch Aufruf der Methode left() können wir das Objekt anweisen, sich zu drehen. Als Argument müssen wir einen Winkel übergeben, um den sich das Turtle-Objekt drehen soll. In der Abbildung wird die entsprechende Drehung um 90° nach links dargestellt. Die roten Striche und Kreise dienen der Veranschaulichung.

Abbildung: Drehung eines Turtle-Objektes um 90° nach links.

Aufgabe 6

Die Turtle mit dem Namen "drehTurtle" soll sich um

45°
135°
180°

nach links drehen. Gib den zugehörigen Quelltext an und verdeutliche den Drehwinkel an einer (handschriftlichen) Skizze.

Lösung:

```
drehTurtle.left(45) 
```
```
drehTurtle.left(135) 
```
```
drehTurtle.left(180) 
```

Skizze:

Zeichnen eines Quadrates

Damit haben wir die beiden Befehle kennengelernt, die es uns ermöglichen, ein Objekt der Klasse Turtle ein Quadrat zeichnen zu lassen.

Aufgabe 7

Ein erzeugtes Objekt der Klasse Turtle soll nun ein Quadrat mit einer Seitenlänge von 100 Bildpunkten zeichnen.
Fertige einen entsprechenden Entwurf auf Papier an und gib umgangssprachlich an, wie sich das Objekt dafür über den Bildschirm bewegen muss. Die erzeugte Turtle soll am Ende wieder in die ursprüngliche Richtung schauen.

Lösung:

Beachte, dass eine Drehung immer in die gleiche Richtung erfolgen muss, da ansonsten kein Quadrat entsteht.

Aufgabe 8

Setze die Vorüberlegungen nun in ein Programm um.
Gib sowohl dem Turtle-Objekt als auch der Programmdatei einen sinnvollen Namen.

Lösung:
Ein sinnvoller Dateiname wäre "Quadrat100px.py", entsprechend könnte das zugehörige Turtle-Objekt den Namen "quadratTurtle" tragen.

# # Autor(en) 
# Christian Graf 
# # Datum 
# 04.03.2011 
# # letzte Aenderung 
# 04.03.2011 
# # Beschreibung 
# Zeichnen eines Quadrates mit 100 px Seitenlaenge 
from turtle import Turtle 
quadratTurtle = Turtle("turtle") 
quadratTurtle.forward(100) 
quadratTurtle.left(90) 
quadratTurtle.forward(100) 
quadratTurtle.left(90) 
quadratTurtle.forward(100) 
quadratTurtle.left(90) 
quadratTurtle.forward(100) 
quadratTurtle.left(90) 
 # Fenster geoeffnet lassen - fuer Linux
 quadratTurtle.screen._root.mainloop()

Du erkennst sicherlich, dass die Befehle

quadratTurtle = Turtle() 
quadratTurtle.shape("turtle")

zu einem Befehl kombiniert wurden:

quadratTurtle = Turtle("turtle")

Diese Anweisung erstellt direkt eine neues Turtle-Objekt mit dem Kostüm "turtle".
Am einfachsten ist es, wenn du deine Lösung ausführst und dann das entstandene Bild mit einem Quadrat vergleichst.

Aufgabe 9

Verändere das Programm so, dass ein Rechteck gezeichnet wird. Die eine Seite soll 50 und die andere Seite 200 Bildpunkte lang sein.
Gehe dabei wieder in zwei Schritten vor: Fertige zuerst einen Entwurf auf Papier an und schreibe anschließend das zugehörige Programm.

Lösung:
Ein sinnvoller Dateiname wäre "Rechteck200px50px.py", entsprechend könnte die zugehörige Turtle den Namen "rechteckTurtle" tragen.

# # Autor(en) 
# Christian Graf 
# # Datum 
# 04.03.2011 
# # letzte Aenderung 
# 04.03.2011 
# # Beschreibung 
# Zeichnen eines Rechteckes mit 200 px bzw. 50 px Seitenlaenge 
from turtle import Turtle 
rechteckTurtle = Turtle("turtle") 
rechteckTurtle.forward(50) 
rechteckTurtle.left(90) 
rechteckTurtle.forward(200) 
rechteckTurtle.left(90) 
rechteckTurtle.forward(50) 
rechteckTurtle.left(90) 
rechteckTurtle.forward(200) 
rechteckTurtle.left(90) 
 # Fenster geoeffnet lassen - fuer Linux
 rechteckTurtle.screen._root.mainloop()

Auch hier hilft ein einfacher Test, ob dein Programm korrekt ist oder nicht.

Rückwärtsbewegung und Rechtsdrehung

Bisher können wir die Turtle-Objekte vorwärts bewegen und sich nach links drehen lassen. Ist es mit diesen Methoden nun auch möglich, dass sich die Turtle-Objekte rechts herum drehen und rückwärts gehen

Aufgabe 10

Fertige eine weitere Skizze des bereits gezeichneten Rechteckes und des Quadrates an. Verdeutliche mit einer zweiten Farbe die Drehung des Turtle-Objektes um 90° nach links.

Lösung:

Aufgabe 11

Das Turtle-Objekt soll sich nun auch rückwärts bewegen können. Überlege, wie dies mit einer Hintereinanderausführung der beiden bereits bekannten Methoden möglich ist.

Lösung:
Zuerst dreht sich das Turtle-Objekt um 180° nach links. Es steht dann mit dem Rücken zur ursprünglichen Laufrichtung. Es kann nun vorwärts gehen. Damit das Objekt wieder in die ursprüngliche Richtung guckt, muss es sich nochmals um 180° nach links drehen. Am Ende sieht es so aus, als sei das Turtle-Objekt rückwärts gelaufen.

Probiere diese Art des "umständlichen" Rückwärtslaufens ruhig innerhalb der Shell oder eines eigenständigen Programmes aus.
Alternativ kann man der Methode forward() auch einen negativen Wert als Argument übergeben. Beispiel:

myTurtle.forward(-100)

Aufgabe 12

Die Turtle soll sich nun auch nach rechts um den Winkel α drehen können. Überlege, wie du dies mit einer Hintereinanderausführung der beiden bereits bekannten Methoden realisieren kannst. Fertige zur Unterstützung eine Skizze an. Zeichne dazu auch einen Kreis um das Turtle-Objekt.

Lösung:
Nach einer Drehung nach links um 360° guckt die Turtle immer noch in die gleiche Richtung. Dreht sich sich um den Winkel 270° nach links ist das gleichbedeutend mit einer Drehung von 90° nach rechts. Soll sich die Turtle also um den Winkel α nach rechts drehen, kann sie sich auch um 360°-α nach links drehen.

Teste die beiden Arten des Drehen innerhalb der Shell oder eines eigenständigen Programmes aus. Wenn du die Turtle nach der Drehung noch ein Stückchen nach vorne laufen lässt, kannst du den Drehwinkel besser erkennen.

Am Beispiel der Zusammenfassung der beiden Befehle zur Erzeugung eines Turtle-Objektes und des Kostümwechsels zu einer einzigen Anweisung kann man mutmaßen, dass Informatiker bzw. Programmierer "faule" Menschen sind, die sich gerne Arbeit ersparen. Auch bei der Drehung nach rechts bzw. der Rückwärtsbewegung gibt es zwei Methoden, die uns diese Fähigkeit der Turtle-Objekte direkt nutzen lassen: Diese heißen right() und backward() und werden analog zu ihren "gegensätzlichen" Methoden aufgerufen. In diesen Methoden verbergen sich unter Umständen die Überlegungen, die wir in den beiden letzten Aufgaben getätigt haben. Wir brauchen also in Zukunft keine umständlichen Bewegungen und Drehungen mehr zu machen, um diese Funktionalität zu erreichen.

Aufgabe 13

Schreibe ein Programm, dass die folgende Ausgabe auf dem Bildschirm erzeugt:

Skizze der gewünschten Zeichnung

Die Seitenlänge darfst du frei wählen.
Gehe dabei in drei Schritten vor:

Fertige eine Skizze an. Zeichne die Drehwinkel und Seitenlängen ein.
Schreibe einen kurzen Entwurf für dein Programm, orientiere dich dabei an dem Entwurf für das Quadrat.
Schreibe das entsprechende Programm.

Lösung:
Verglichen mit dem Entwurf des Quadrates müssen zwei Ergänzungen vorgenommen werden:

Am Anfang: Drehung um 45° nach links.
Am Ende: Drehung um 45° nach rechts.

Damit erhalten wir das folgende Programm:

# # Autor(en) 
# Christian Graf 
# # Datum 
# 04.03.2011 
# # letzte Aenderung 
# 04.03.2011 
# # Beschreibung 
# Zeichnen eines Quadrates mit 200 px Seitenlaenge, 
# welches auf einer Ecke steht 
from turtle import Turtle 
quadratTurtle = Turtle("turtle") 
quadratTurtle.left(45) 
quadratTurtle.forward(200) 
quadratTurtle.left(90) 
quadratTurtle.forward(200) 
quadratTurtle.left(90) 
quadratTurtle.forward(200) 
quadratTurtle.left(90) 
quadratTurtle.forward(200) 
quadratTurtle.left(90) 
quadratTurtle.right(45) 
 # Fenster geoeffnet lassen - fuer Linux
 quadratTurtle.screen._root.mainloop()

Weiter geht's mit der Lernfortschrittskontrolle zu Kapitel III.

zurück