Kapitel IV - Von der Faulheit der Programmierer

Additum: Erweiterung der for-Schleife

Wie du an den nächsten Aufgaben erkennen wirst, sind die als Zählschleifen vorgestellten Schleifen noch viel mächtiger. Mit ihnen ist es möglich, bestimmte Operationen für eine ganze "Menge" von Objekten durchzuführen.

Aufgabe 1

Übertrage den folgenden Programmausschnitt in den PyScripter oder Geany und führe ihn aus.
Beschreibe deine Beobachtungen.

from turtle import Turtle
myTurtle1 = Turtle("turtle")
myTurtle2 = Turtle("turtle")
for turtle in (myTurtle1,myTurtle2):
    turtle.left(90)
    turtle.forward(300)
# Fenster geoeffnet lassen - fuer Linux
myTurtle1.screen._root.mainloop() 

Hinweis: Auch bei mehreren Turtles reicht die letzte Anweisung für das geöffnete Fenster einmal. Dabei kannst du einie beliebige - der vorhandenen - Turtles verwenden.

Lösung:
Man sieht, wie zwei Objekte der Klasse Turtle erzeugt werden. Beide führen nacheinander die gleichen Bewegungen aus. Zuerst drehen sie sich nach links (um 90°) und anschließend laufen sie die gleiche Strecke vorwärts. Abschließend sieht man nur noch ein Objekt, da beide Objekte genau übereinanderstehen.

Wie du an dem obigen Beispiel im Quellcode erkennen kannst, ist die Schleife, die in Python dazu dient eine Zählschleife umzusetzen, in Wahrheit viel viel mächtiger als bisher angenommen. Mittels der Schleife können wir bestimmte Anweisungen für eine ganze Menge oder (fachlich) besser ausgedrückt für ein Tupel von Objekten ausführen. In diesem Fall umfasst unser Tupel die beiden Turtle-Objekte myTurtle1 und myTurtle2. Zuerst zeigt die Variable turtle auf das Objekt, das sich hinter der Variablen myTurtle1 versteckt. Die Anweisungen in der Schleife werden nun für dieses Objekt ausgeführt.

In der nächsten Runde der Schleifenausführung wird der Schleifenvariablen turtle nun das Turtle-Objekt zugewiesen, dass sich hinter der Variablen myTurtle2 verbirgt. Nun werden die gesamten Anweisungen aus dem Anweisungsblock im Schleifenkörper für diese Variablenbelegung durchgeführt. Anschließend ist die Schleife beendet, da das Tupel im Schleifenkopf keine weiteren Eintragungen mehr enthält.

Im Prinzip läuft die Schleifenabarbeitung analog zu der bisher bekannten Schleife ab. Nur, dass es sich diesmal um (echte) Objekte handelt, statt um Zahlen bzw. Zahlobjekte. Oder - wie wir auch gesehen haben - um Strings oder Zeichenketten. Diese Möglichkeit der Realisierung von Schleifen ist eine Besonderheit von Python, die man nicht in allen Programmiersprachen findet. Nichtsdestotrotz kann man durch diese Schleifenart die in anderen Programmiersprachen allseits bekannte und vorhandene Zählschleife "konstruieren". Diese Besonderheit kann sich - je nach Zweck des gewünschten Programmes - als echte Arbeitserleichterung herausstellen.

Aufgabe 2

Erweitere das obige Programm so, dass sich ingesamt vier Turtle-Objekte bewegen. Das nächste Turtle-Objekt soll sich dabei jeweils doppelt so weit bewegen wie ihr Vorgänger und um 90° mehr drehen als ihr Vorgänger.
Lege dazu zwei Variablen für den Drehwinkel und die Bewegungsweite an, die in der Schleife jeweils angepasst werden.

Lösung:

# Christian Graf / 06.03.2011 / Turtle-Drehungen per Schleife
from turtle import Turtle
myTurtle1 = Turtle("turtle")
myTurtle2 = Turtle("turtle")
myTurtle3 = Turtle("turtle")
myTurtle4 = Turtle("turtle")
winkel = 90
weite = 50
for turtle in (myTurtle1,myTurtle2,myTurtle3,myTurtle4):
    turtle.left(winkel)
    turtle.forward(weite)
    weite = 2*weite # verdoppeln der Weite
    winkel = winkel+90 # erhöhen des Winkels um 90°
# Fenster geoeffnet lassen - fuer Linux
myTurtle3.screen._root.mainloop() 

Ergänzt werden müssen zwei zusätzliche Turtle-Objekte. Ferner müssen diese ebenfalls in das Tupel im Schleifenkopf eingetragen werden. Danach müssen zwei Variablen für den Drehwinkel und die Laufweite erzeugt werden, indem ihnen geeignete Werte zugewiesen werden. Da sich jedes Turtle-Objekt mehr drehen bzw. bewegen soll, müssen diese im Schleifenkörper nach einer jeweiligen Bewegung eines Objektes entsprechend der Aufgabenstellung angepasst werden. Wie du an dem Quellcode ebenfalls siehst, kann man Kommentare auch direkt hinter einzelne Anweisungen schreiben. Ab dem #-Zeichen wird dann alles als Kommentar behandelt.

Ein Vorteil an Tupeln ist ferner, dass man mit ihnen arbeiten kann. So kann man sie bereits im Vorfeld erzeugen und schrittweise Werte, Objekte etc. einfügen. Beispiel:

("Hans","Bert")+("Peter","Gustav")

Die obige Anweisung verbindet die beiden Tupel miteinander. Es entsteht ein neues Tupel mit vier Einträgen. Entsprechend erhalten wir in der Shell die entsprechende Rückmeldung:

('Hans', 'Bert', 'Peter', 'Gustav')

Die Eingabe

("Hans","Bert")+("Peter")

liefert allerdings nicht den gewünschten Erfolg. Stattdessen meldet Python

Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: can only concatenate tuple (not "str") to tuple			

Python will uns wohl mitteilen, dass er nur Tupel miteinander verbinden (engl. "concatenate") kann. Scheinbar hat er ("Peter") nicht als Tupel erkannt. Kein Problem - auch dafür gibt es eine Lösung. Man hängt einfach an den Eintrag "Peter" ein Komma an und "täuscht" somit einen nachfolgenden Wert vor. Entsprechend liefert

("Hans","Bert")+("Peter",)

die gewünschte Ausgabe:

('Hans', 'Bert', 'Peter')

Ein leeres Tupel kann man mit der Eingabe

myTuple=()

erzeugen und unter myTuple speichern. Wenn du es nicht glaubst, nutze die type()-Funktion, um abzufragen, "was" sich hinter myTuple verbirgt. Eine Anfrage

type(myTuple)
<class 'tuple'>

informiert uns darüber, dass es sich dabei wirklich um ein Tupel handelt. Wir erfahren noch mehr: Auch bei einem Tupel handelt es sich scheinbar um eine Klasse.

Dies kann man jetzt nutzen, um mittels einer Schleife ein Tupel von 36 Turtle-Objekten zu erzeugen, die sich anschließend in alle Himmelsrichtungen bewegen. Entsprechend würden wir uns sparen, für jede eine eigene Variable anzulegen. Wir brauchen dafür nur eine Variable. Nämlich eine Variable, in der wir das gesamte Tupel speichern. Alle einzelnen Turtle-Objekte sprechen wir später mit einer Schleife an. Der entsprechende Programmausschnitt würde lauten:

# lege leeres Tupel an
myTurtles = ()
for i in range(36):
    # erzeuge 36 Turtle-Objekte und hänge diese an das Tupel an
    myTurtles = myTurtles + (Turtle("turtle"),)

Der Programmausschnitt

for turtle in myTurtles:
    turtle.forward(weite)

würde im Folgenden alle erzeugten und innerhalb des Tupels gespeicherten Turtle-Objekte um eine festzulegenden Weite vorwärtsbewegen. Auf diese Weise kann man sicherlich schöne "Tanzeinlagen" mit einer Gruppe von Turtle-Objekte aufführen, oder? Download eines Beispiels

Beispiel einer "Tanzeinlage", Download des zugehörigen Quellcodes