Python

Eine Einführung in die Computer-Programmierung

Tobias Kohn
Copyright c 2016, Tobias Kohn
[Link]
Version vom 19. August 2016
Dieses Script darf für den Unterricht frei kopiert und verwendet wer-
den. Jegliche kommerzielle Nutzung ist untersagt. Alle Rechte vorbe-
halten.
 INHALTSVERZEICHNIS

1 Einführung 7

2 Grafik mit der Turtle 9

2.1 Die Turtle bewegen . . . . . . . . . . . . . . . . . . . . . 10
2.2 Den Farbstift steuern . . . . . . . . . . . . . . . . . . . . 12
2.3 Der Turtle Neues beibringen . . . . . . . . . . . . . . . . 14
2.4 Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5 Flächen füllen . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6 Repetitionen . . . . . . . . . . . . . . . . . . . . . . . . 20
2.7 Kreise und Bogen . . . . . . . . . . . . . . . . . . . . . . 22
2.8 Kuchenstücke . . . . . . . . . . . . . . . . . . . . . . . . 24
2.9 Parameter strecken . . . . . . . . . . . . . . . . . . . . . 26
2.10 Mehrere Parameter . . . . . . . . . . . . . . . . . . . . . 28
2.11 Den Programmablauf beobachten . . . . . . . . . . . . . 30
2.12 Programme mit Fehlern . . . . . . . . . . . . . . . . . . 32
2.13 Die Turtle direkt steuern* . . . . . . . . . . . . . . . . . 34
2.14 Tipps und Tricks zur Turtle* . . . . . . . . . . . . . . . . 36

3 Rechnen mit Python 39

3.1 Grundoperationen und das Zahlenformat . . . . . . . . . 40
3.2 Variablen für unbekannte Werte . . . . . . . . . . . . . . 42
3.3 Die ganzzahlige Division . . . . . . . . . . . . . . . . . . 44
3.4 Text ausgeben . . . . . . . . . . . . . . . . . . . . . . . . 46
3.5 Potenzen, Wurzeln und die Kreiszahl . . . . . . . . . . . 48
3.6 Variablenwerte ändern . . . . . . . . . . . . . . . . . . . 50
3.7 Wiederholung mit Variation . . . . . . . . . . . . . . . . 52
3.8 Fallunterscheidung . . . . . . . . . . . . . . . . . . . . . 54
3.9 Alternativen . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.10 Ein- und Ausgaben . . . . . . . . . . . . . . . . . . . . . 58
3.11 Schleifen abbrechen . . . . . . . . . . . . . . . . . . . . 60
3.12 Korrekte Programme . . . . . . . . . . . . . . . . . . . . 62

c 2016, Tobias Kohn

4 INHALTSVERZEICHNIS

4 Koordinatengrafik 67
4.1 Wiederholungen der Turtle . . . . . . . . . . . . . . . . 68
4.2 Farben mischen . . . . . . . . . . . . . . . . . . . . . . . 70
4.3 Mit dem Zufall spielen . . . . . . . . . . . . . . . . . . . 72
4.4 Turtle mit Koordinaten . . . . . . . . . . . . . . . . . . . 74
4.5 Koordinaten abfragen . . . . . . . . . . . . . . . . . . . 76
4.6 Schleifen in Schleifen . . . . . . . . . . . . . . . . . . . . 78
4.7 Die Maus jagen . . . . . . . . . . . . . . . . . . . . . . . 80
4.8 Globale Variablen . . . . . . . . . . . . . . . . . . . . . . 82
4.9 Mehrere Alternativen . . . . . . . . . . . . . . . . . . . . 84
4.10 Vier Gewinnt . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11 Mausbewegungen* . . . . . . . . . . . . . . . . . . . . . 88
4.12 Die Turtle im Labyrinth . . . . . . . . . . . . . . . . . . . 90

5 Algorithmen und Funktionen 95

5.1 Distanz berechnen . . . . . . . . . . . . . . . . . . . . . 96
5.2 Mathematische Funktionen . . . . . . . . . . . . . . . . 98
5.3 Verzweigte Funktionen . . . . . . . . . . . . . . . . . . . 100
5.4 Graphen zeichnen . . . . . . . . . . . . . . . . . . . . . 102
5.5 Graphen mit Polstellen* . . . . . . . . . . . . . . . . . . 104
5.6 Wurzeln suchen . . . . . . . . . . . . . . . . . . . . . . . 106
5.7 Wahr und Falsch . . . . . . . . . . . . . . . . . . . . . . 108
5.8 Primzahlen testen . . . . . . . . . . . . . . . . . . . . . . 110
5.9 Und und oder oder oder und und . . . . . . . . . . . . . 112
5.10 Variablen: Aus alt mach neu . . . . . . . . . . . . . . . . 114
5.11 Algorithmen mit mehreren Variablen . . . . . . . . . . . 116

6 Listen 121
6.1 Listen erzeugen . . . . . . . . . . . . . . . . . . . . . . . 122
6.2 Listen durchlaufen . . . . . . . . . . . . . . . . . . . . . 124
6.3 Bilder aus Listen und Schleifen . . . . . . . . . . . . . . 126
6.4 Polygone zeichnen . . . . . . . . . . . . . . . . . . . . . 128
6.5 Minimum und Maximum . . . . . . . . . . . . . . . . . . 130
6.6 Einfache Zahlenlisten . . . . . . . . . . . . . . . . . . . . 132
6.7 Elemente zählen . . . . . . . . . . . . . . . . . . . . . . 134
6.8 Sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . 136
6.9 Listen in Listen* . . . . . . . . . . . . . . . . . . . . . . . 138
6.10 Histogramme zeichnen . . . . . . . . . . . . . . . . . . . 140
6.11 Datenbanken* . . . . . . . . . . . . . . . . . . . . . . . . 142

7 Animation 145
7.1 Tastatursteuerung . . . . . . . . . . . . . . . . . . . . . . 146
7.2 Ping Pong . . . . . . . . . . . . . . . . . . . . . . . . . . 148
7.3 Alles fällt: Gravitation . . . . . . . . . . . . . . . . . . . 150
7.4 Mehrere Objekte bewegen . . . . . . . . . . . . . . . . . 152
7.5 Plattformen und Schattenwurf* . . . . . . . . . . . . . . 154
7.6 Objekte mit Variablen . . . . . . . . . . . . . . . . . . . 156

c 2016, Tobias Kohn

INHALTSVERZEICHNIS 5

7.7 Objekte als Parameter . . . . . . . . . . . . . . . . . . . 158

7.8 Punkte fangen . . . . . . . . . . . . . . . . . . . . . . . . 160
7.9 Ping Pong spielen . . . . . . . . . . . . . . . . . . . . . . 162
7.10 Steine entfernen* . . . . . . . . . . . . . . . . . . . . . . 164
7.11 Rotationen und Pendel* . . . . . . . . . . . . . . . . . . 166
7.12 Figuren drehen* . . . . . . . . . . . . . . . . . . . . . . 168

8 Strings 171
8.1 Bruchterme ausgeben . . . . . . . . . . . . . . . . . . . 172
8.2 Buchstaben und Wörter . . . . . . . . . . . . . . . . . . 174
8.3 Gross und Klein . . . . . . . . . . . . . . . . . . . . . . . 176
8.4 Alles ist Zahl . . . . . . . . . . . . . . . . . . . . . . . . 178

A Lösungen 181
A.1 Kapiteltest 2 . . . . . . . . . . . . . . . . . . . . . . . . . 182

c 2016, Tobias Kohn

6 INHALTSVERZEICHNIS

c 2016, Tobias Kohn

K a p i t e l E i n s

EINFÜHRUNG

Einführung In diesem Kurs lernst du, wie du einen Computer pro-

grammieren kannst. Dabei gehen wir davon aus, dass du noch kein Vor-
wissen mitbringst, und werden dir schrittweise alles erklären, was du
dazu brauchst. Am Ende des Kurses hast du dann alles nötige zusam-
men, um z. B. ein eigenes Computerspiel zu programmieren. Vielleichst
wirst du dann aber auch einen Kurs für Fortgeschrittene besuchen oder
Simulationen für eine wissenschaftliche Arbeit schreiben. Wenn du die
Grundlagen erst einmal hast, sind dir kaum noch Grenzen gesetzt.

Beim Programmieren musst du eine wichtige Regel beachten: Probiere

alles selber aus! Je mehr Programme du selber schreibst, umso mehr
wirst du verstehen und beherrschen. Der Computer wird nicht immer
das tun, was du möchtest. Halte dich in diesen Fällen einfach an Kon-
fuzius: «Einen Fehler zu machen heisst erst dann wirklich einen Fehler
zu machen, wenn man nichts daraus lernt.»

Installation Das Programm TigerJython ist schnell installiert. Lade

es von der Seite
[Link]
herunter und speichere es am besten in einem eigenen Ordner, dem du
z. B. den Namen Python geben kannst.

Damit ist die Installation eigentlich bereits abgeschlossen und du kannst

das Programm [Link] starten (Voraussetzung ist aller-
dings eine aktuelle Version von Java/JRE). Die Abbildung 1.1 zeigt, wie
das etwa aussehen sollte (allerdings wird das Editorfeld in der Mitte bei
dir leer sein).

Dein erstes Programm Tauchen wir doch gleich in die Welt des
Programmierens ein! In der Abbildung 1.1 steht im Editorfenster bereits
ein kleines Programm und zwar das folgende:

c 2016, Tobias Kohn

8 KAPITEL 1. EINFÜHRUNG

Abbildung 1.1: So präsentiert sich das Programm TigerJython. Den Um-

gang mit der Konsole und dem Debugger wirst du später im Kurs lernen.
Am wichtigsten ist die Schaltfläche zum Ausführen des Programms.

name = input("Wie heisst du?")

msgDlg("Hallo " + name)

Gib das Programm nun selber einmal ein (achte darauf, alles exakt so
einzugeben wie im Code hier) und klicke dann auf die grüne Schaltflä-
che oben, um das Programm zu starten. Bevor TigerJython dein Pro-
gramm ausführt, fragt es dich zuerst, ob du das Programm vorher spei-
chern möchtest. Im Moment ist das nicht nötig und du kannst getrost
auf «Nicht speichern» klicken.

Wenn dich der Computer jetzt nach deinem Namen fragt und dich dann
begrüsst, dann hast du erfolgreich dein erstes Programm geschrieben:
Gratulation!

Übrigens: Es ist ganz normal, dass du noch nicht alles hier verstehst.
Wichtig ist im Moment nur, dass du weisst, wie du ein Programm ein-
gibst und ausführst. Alles andere werden wir dir im Verlaufe dieses
Kurses erklären.

c 2016, Tobias Kohn

K a p i t e l Z w e i

GRAFIK MIT DER TURTLE

Die Turtle ist eine kleine Schildkröte, die eine Spur zeichnet, wenn sie
sich bewegt. Du kannst ihr sagen, sie soll vorwärts gehen oder sich nach
links oder rechts abdrehen. Indem du diese Anweisungen geschickt
kombinierst, entstehen Zeichnungen und Bilder.

Für das Programmieren wesentlich und zentral ist, dass du dabei lernst,
dieser Turtle neue Figuren beizubringen. Indem du z. B. einmal defi-
nierst, was ein Quadrat ist, kann die Turtle beliebig viele Quadrate in
allen Grössen und Farben zeichnen. Mit der Zeit kannst du so immer
komplexere Bilder und Programme aufbauen.

c 2016, Tobias Kohn

10 KAPITEL 2. GRAFIK MIT DER TURTLE

1 Die Turtle bewegen

Lernziele In diesem Abschnitt lernst du:

. Ein einfaches Programm zu schreiben und mit der Turtle beliebige
Figuren auf den Bildschirm zu zeichnen.
. Die Turtle mit den Befehlen left, right und forward zu drehen
und zu bewegen.

Einführung Programmieren heisst einer Maschine Befehle zu ertei-

len und sie damit zu steuern. Die erste solche Maschine, die du steuerst,
ist eine kleine Schildkröte auf dem Bildschirm: Die Turtle. Was kann
diese Turtle und was musst du wissen, um sie zu steuern?

Die Turtle kann sich innerhalb ihres Fensters bewegen und dabei eine
Spur zeichnen. Bevor die Turtle aber loslegt, musst du den Compu-
ter anweisen, dir eine solche Turtle zu erzeugen. Das machst du mit
makeTurtle(). Um die Turtle zu bewegen verwendest du die drei Be-
fehle forward(länge), left(winkel) und right(winkel).

Das Programm So sieht dein erstes Programm mit der Turtle aus.
Schreib es ab und führe es aus, indem du auf den grünen Start-Knopf
klickst. Die Turtle sollte dir dann ein rechtwinkliges Dreieck zeichnen.
1 from gturtle import *
2
3 makeTurtle()
4
5 forward(141)
6 left(135)
7 forward(100)
8 left(90)
9 forward(100)

Die Turtle ist in einer Datei (einem sogenannten Modul) «gturtle» ge-
speichert. In der ersten Zeile sagst du dem Computer, dass er alles
aus dieser Datei laden soll. Die Anweisung makeTurtle() in der drit-
ten Zeile erzeugt eine neue Turtle mit Fenster, die du programmieren
kannst. Ab Zeile 5 stehen dann die Anweisungen für die Turtle selber.

c 2016, Tobias Kohn

 2.1. DIE TURTLE BEWEGEN 11

Die wichtigsten Punkte Am Anfang jedes Turtle-Programms musst

du zuerst das Turtle-Modul laden und eine neue Turtle erzeugen:
from gturtle import *
makeTurtle()

Danach kannst du der Turtle beliebig viele Anweisungen geben. Die

Übrigens: Mit dem Befehl drei Anweisungen, die die Turtle sicher versteht sind:
speed(1234) (direkt nach
makeTurtle) kannst die Ge- forward(s) s Pixel vorwärts bewegen.
schwindigkeit der Turtle ein- left(w) Um den Winkel w nach links drehen.
stellen. speed(-1) verwen- right(w) Um den Winkel w nach rechts drehen.
det dabei die höchste Ge-
schwindigkeit.

AUFGABEN

1. Zeichne mit der Turtle ein regelmässiges Fünfeck (Pentagon) mit

einer Seitenlänge von 150 Pixeln.

2. Zeichne mit der Turtle zwei Quadrate ineinander wie in Abbildung

2.1(a).

Abbildung 2.1: In der Mitte das «Haus von Nikolaus» und rechts eine ein-
fache Schneeflocke.

3. Das «Haus vom Nikolaus» ist ein Zeichenspiel für Kinder. Ziel ist
es, das besagte Haus (vgl. Abbildung 2.1(b)) in einem Linienzug aus
genau 8 Strecken zu zeichnen, ohne dabei eine Strecke zweimal zu
durchlaufen. Zeichne das Haus vom Nikolaus mithilfe der Turtle. Wähle
dabei für die Seitenlänge des Quadrats 120 Pixel und nimm an, dass die
beiden Dachflächen rechtwinklig aufeinander treffen.

4.∗ Lass die Turtle eine einfache Schneeflocke zeichnen wie in der Ab-
bildung 2.1(c).

c 2016, Tobias Kohn

12 KAPITEL 2. GRAFIK MIT DER TURTLE

2 Den Farbstift steuern

Lernziele In diesem Abschnitt lernst du:

. Die Farbe und die Linienbreite einzustellen, mit der die Turtle zeich-
net.
. Mit penUp() und penDown() zu steuern, wann die Turtle wirklich
etwas zeichnet und wann nicht.

Einführung Um ihre Spur zu zeichnen hat die Turtle einen Farbstift

(engl. pen). Für diesen Farbstift kennt die Turtle wiederum vier weitere
Anweisungen.

Solange der Farbstift «unten» ist, zeichnet die Turtle eine Spur. Mit
penUp() nimmt sie den Farbstift nach oben und bewegt sich nun, ohne
eine Spur zu zeichnen. Mit penDown() wird der Farbstift wieder nach
unten auf die Zeichenfläche gebracht, so dass eine Spur gezeichnet
wird.

Über die Anweisung setPenColor("Farbe") kannst du die Farbe des

Stifts auswählen. Wichtig ist, dass du den Farbnamen in Gänsefüsschen
setzt. Wie immer beim Programmieren kennt die Turtle nur englische
Farbnamen. Die folgende Liste ist zwar nicht vollständig, aber doch ein
erster Anhaltspunkt:
yellow, gold, orange, red, maroon, violet, pink, magenta, purple, navy,
blue, sky blue, cyan, turquoise, lightgreen, green, darkgreen, chocolate,
brown, black, gray, white

Schliesslich kennt die Turtle noch den Befehl setLineWidth(Breite).

Damit kannst du die Breite der gezeichneten Linie einstellen. Die Breite
gibst du hier in Pixeln an.

Das Programm In diesem Programm zeichnet die Turtle zwei kurze

blaue Linien übereinander. Die untere Linie ist dunkelblau (navy), die
obere hellblau (light blue). Dazwischen ist ein Teil (Zeilen 9 bis 13),
in dem sich die Turtle zwar bewegt, aber keine Linie zeichnet, weil der
Stift «oben» ist.
1 from gturtle import *
2 makeTurtle()
3
4 setLineWidth(3)
5 right(90)
6 setPenColor("navy")

c 2016, Tobias Kohn

2.2. DEN FARBSTIFT STEUERN 13

7 forward(50)
8
9 penUp()
10 left(90)
11 forward(30)
12 left(90)
13 penDown()
14
15 setPenColor("light blue")
16 forward(50)

Die wichtigsten Punkte Der Zeichenstift (pen) der Turtle kann mit
setPenColor(Farbe) die Farbe wechseln. Indem du den Stift mit penUp()
«hochhebst», hört die Turtle auf, eine Spur zu zeichnen. Mit penDown()
wird der Stift wieder gesenkt und die Turtle zeichnet weiter.

Die Breite der Linie kannst du mit der Anweisung setLineWidth(Breite)

steuern.

AUFGABEN

5. Zeichne mit der Turtle ein regelmässiges Sechseck (Hexagon) und

wähle für jede Seite eine andere Farbe.

6. Lass die Turtle einen «Regenbogen» zeichnen wie in der Abbildung

2.2 angedeutet. Ganz innen ist dieser Regenbogen rot, danach orange,
gelb, grün und schliesslich aussen blau und violett. Es genügt allerdings
auch, wenn du nur drei Bogen zeichnen lässt.

Abbildung 2.2: Ein (eckiger) Regenbogen.

c 2016, Tobias Kohn

14 KAPITEL 2. GRAFIK MIT DER TURTLE

3 Der Turtle Neues beibringen

Lernziele In diesem Abschnitt lernst du:

. Für die Turtle neue Anweisungen zu definieren und damit ihren Wort-
schatz beliebig zu erweitern.

Einführung In einem grösseren Bild kommen wahrscheinlich rela-

tiv viele Dreiecke und Quadrate vor. Die Turtle weiss aber nicht, was
ein Quadrat oder ein Dreieck ist. Du musst also jedes Mal der Turtle
erklären, wie sie die Quadrate und Dreiecke zeichnet. Geht das nicht
auch einfacher?

Es geht einfacher! Du kannst der Turtle nämlich neue Befehle beibrin-

gen und musst ihr dann nur noch sagen, sie soll ein Quadrat oder ein
Dreieck zeichnen. Den Rest erledigt sie ab da selber. Neue Befehle de-
finierst du mit def NeuerName(). Danach schreibst du alle Anweisun-
gen auf, die zum neuen Befehl gehören. Damit der Computer weiss,
was zum neuen Befehl gehört, müssen diese Anweisungen eingerückt
sein.

Das Programm In diesem Programm definieren wir in den Zeilen

4 bis 12 mit def den Befehl quadrat(). Wie du ein Quadrat zeichnest,
weisst du bereits: Es braucht vier gleich lange Seiten und dazwischen
muss die Turtle um 90◦ gedreht werden. Wichtig: Alle acht Anweisun-
gen, die das Quadrat ausmachen, sind um vier Leerschläge eingerückt.
1 from gturtle import *
2 makeTurtle()
3
4 def quadrat():
5 forward(100)
6 left(90)
7 forward(100)
8 left(90)
9 forward(100)
10 left(90)
11 forward(100)
12 left(90)
13
14 setPenColor("red")
15 quadrat()
16 penUp()
17 forward(50)

c 2016, Tobias Kohn

2.3. DER TURTLE NEUES BEIBRINGEN 15

18 left(60)
19 forward(50)
20 penDown()
21 setPenColor("blue")
22 quadrat()

Ab der Zeile 14 weiss die Turtle, was ein Quadrat ist (sie hat aber noch
keines gezeichnet). Du kannst quadrat() genauso brauchen wie die
anderen Befehle: Die Turtle zeichnet dann immer an der aktuellen Po-
sition ein Quadrat mit der Seitenlänge 100. Hier zeichnen wir damit ein
rotes und ein blaues Quadrat.

Tipp: Wenn die Turtle eine Figur (z. B. ein Quadrat) zeichnet, dann
achte darauf, dass die Turtle am Schluss wieder gleich dasteht wie am
Anfang. Das macht es viel einfacher, mehrere Figuren zusammenzu-
hängen. Im Programm oben wird die Turtle in Zeile 12 deshalb auch
nochmals um 90◦ gedreht (was ja nicht nötig wäre).

Die wichtigsten Punkte Mit def NeuerName(): definierst du einen

neuen Befehl für die Turtle. Nach der ersten Zeile mit def kommen
alle Anweisungen, die zum neuen Befehl gehören. Diese Anweisungen
müssen aber eingerückt sein, damit der Computer weiss, was alles dazu
gehört.
def NeuerName():
Anweisungen

Vergiss die Klammern und den Doppelpunkt nach dem Namen nicht!

AUFGABEN

7. Definiere einen Befehl für ein Quadrat, das auf der Spitze steht und
zeichne damit die Figur in der Abbildung 2.3. Die fünf Quadrate berüh-
ren sich nicht, sondern haben einen kleinen Abstand und die Farben
blau, schwarz, rot (oben) und gelb, grün (unten).

Abbildung 2.3: Olympische Quadrate.

c 2016, Tobias Kohn

16 KAPITEL 2. GRAFIK MIT DER TURTLE

4 Parameter

Lernziele In diesem Abschnitt lernst du:

. Was ein Parameter ist und wofür du Parameter brauchst.
. Eigene Befehle mit Parametern zu definieren.

Einführung Bei der Anweisung forward() gibst du in Klammern

an, wieviel die Turtle vorwärts gehen soll. Diese Länge ist ein Parameter:
Ein Zahlenwert, der bei jeder Verwendung von forward() anders sein
kann. Je nach Zusammenhang wer-
den Parameter auch als «Argu-
Im letzten Abschnitt hast du einen eigenen Befehl quadrat() definiert. mente» bezeichnet.
Im Unterschied zu forward() ist die Seitenlänge dieses Quadrats aber
immer 100 Pixel. Dabei wäre es doch praktisch, auch die Seitenlänge
des Quadrats bei jeder Verwendung direkt angegeben und anpassen zu
können. Wie geht das?

Das Programm Auch in diesem Programm definieren wir in Zeilen 4

bis 12 ein Quadrat. Im Unterschied zum letzten Abschnitt ist die Seiten-
länge aber noch unbekannt. Anstatt forward(100) steht forward(seite).
In Zeile 4 steht seite auch in Klammern hinter dem Namen. Damit
weiss der Computer, dass du bei jeder Verwendung von quadrat eine
Zahl für seite angeben wirst.

1 from gturtle import *

2 makeTurtle()
3
4 def quadrat(seite):
5 forward(seite)
6 left(90)
7 forward(seite)
8 left(90)
9 forward(seite)
10 left(90)
11 forward(seite)
12 left(90)
13
14 setPenColor("red")
15 quadrat(80)
16 left(30)
17 setPenColor("blue")
18 quadrat(50)

c 2016, Tobias Kohn

2.4. PARAMETER 17

In Zeile 15 zeichnet die Turtle ein rotes Quadrat mit der Seitenlänge
von 80 Pixeln, in Zeile 18 ein blaues mit der Seitenlänge von 50 Pixeln.
Weil hinter quadrat in Klammern die Zahlen 80 bzw. 50 stehen, setzt
der Computer bei der Definition von Quadrat für seite überall 80 bzw.
50 ein.

Die wichtigsten Punkte Parameter sind Platzhalter für Werte, die je-
des Mal anders sein können. Du gibst den Parameter bei der Definition
eines Befehls hinter den Befehlsnamen in Klammern an.
def Befehlsname(Parameter):
Anweisungen mit
dem Parameter

Sobald du den Befehl verwenden möchtest, gibst du wieder in Klam-

mern den Wert an, den der Parameter haben soll.
Befehlsname(123)

Hier wird der Parameter im ganzen Befehl durch 123 ersetzt.

AUFGABEN

8. Definiere einen Befehl jump(Distanz), mit dem die Turtle die ange-
gebene Distanz überspringt. Der Befehl funktioniert also wie forward(),
allerdings zeichnet die Turtle hier keine Spur.

9. Definiere einen Befehl rechteck(grundseite), mit dem die Turtle

ein Rechteck zeichnet, das doppelt so hoch wie breit ist.

10.∗ Definiere einen Befehl, der ein offenes Quadrat u zeichnet und
verwende deinen Befehl, um ein Kreuz zu zeichnen, wobei du mit dem
offenen Quadrat die vier Arme zeichnest.

c 2016, Tobias Kohn

18 KAPITEL 2. GRAFIK MIT DER TURTLE

5 Flächen füllen

Lernziele In diesem Abschnitt lernst du:

. Mit fill() beliebige Flächen mit einer Farbe auszufüllen.

Einführung Indem du die Turtle bewegst, kannst du beliebige Fi-

guren zeichnen – oder zumindest den Umriss davon. Für ein hübsches
Bild willst du aber sicher auch Flächen mit einer Farbe ausfüllen. Dazu
kennt die Turtle den Befehl fill().

Um eine Figur mit Farbe zu füllen, muss die Turtle ingendwo im Innern
der Figur stehen. Bei fill() schüttet sie dann Farbe aus, bis die ganze
Figur mit Farbe gefüllt ist. Aber Vorsicht: Wenn die Turtle dabei auf
einer Linie steht, dann glaubt sie, dieses Linienstück alleine mache die
ganze Figur aus! Du brauchst also sicher penUp(), um die Turtle ins
Innere einer Figur zu bewegen ohne eine Linie zu zeichnen.

Das Programm In den Zeilen 4 bis 9 zeichnet die Turtle ein gleich-
seitiges Dreieck, das auf der Spitze steht. In den Zeilen 10 bis 12 neh-
men wir den Stift hoch und setzen die Turtle ins Innere des Dreiecks
(das muss nicht die Mitte sein). Schliesslich setzen wir die Füllfarbe in
Zeile 13 auf «Himmelblau» und füllen das Dreieck dann in Zeile 14 aus.
1 from gturtle import *
2 makeTurtle()
3
4 right(30)
5 forward(100)
6 left(120)
7 forward(100)
8 left(120)
9 forward(100)
10 penUp()
11 left(150)
12 forward(50)
13 setFillColor("sky blue")
14 fill()

c 2016, Tobias Kohn

2.5. FLÄCHEN FÜLLEN 19

Die wichtigsten Punkte Um eine (geschlossene) Figur mit Farbe zu

füllen, muss die Turtle im Innern der Figur sein (verwende penUp(), da-
mit die Turtle keine Linie ins Innere hineinzeichnet). Dann verwendest
du den Befehl fill(). Zuvor kannst du mit setFillColor("Farbe")
genauso wie bei setPenColor() eine Farbe auswählen.

AUFGABEN

11. Die Abbildung 2.4 zeigt vier Figuren mit farbigen Flächen. Lass dei-
ne Turtle diese vier Figuren zeichnen (in vier verschiedenen Program-
men). Die Farben kannst du dabei selbst wählen.

Abbildung 2.4: Figuren mit gefüllten Flächen.

12. Definiere einen neuen Befehl fillQuadrat(seite) um eine aus-

gefülltes Quadrat zu zeichnen. Verwende dann diesen neuen Befehl,
um die ersten drei Figuren in der Abbildung 2.4 nochmals zu zeichnen.

c 2016, Tobias Kohn

20 KAPITEL 2. GRAFIK MIT DER TURTLE

6 Repetitionen

Lernziele In diesem Abschnitt lernst du:

. Der Turtle zu sagen, sie soll eine oder mehrere Anweisungen mehr-
fach wiederholen.

Einführung Computer (und damit auch die Turtle) sind besonders

gut darin, die gleichen Anweisungen immer wieder zu wiederholen.
Um ein Quadrat zu zeichnen musst du also nicht viermal die Anwei-
sungen forward() und left(90) eingeben. Es genügt auch, der Turtle
zu sagen, sie soll diese zwei Anweisungen viermal wiederholen. Eine mehrfache Wiederholung
heisst in der Fachsprache
Die Turtle kennt die Anweisung repeat Anzahl. Damit sagst du der «Schleife». Mit repeat
Turtle, sie soll einige Befehle «Anzahl» Mal wiederholen. Damit die Turt- kannst du also Schleifen
le aber weiss, welche Befehle sie wiederholen soll, müssen diese wieder programmieren.
eingerückt sein – genauso wie bei def vorhin.

Das Programm Um ein regelmässiges Neuneck zu zeichnen muss

die Turtle neunmal geradeaus gehen und sich dann um 40◦ drehen.
Würdest du das alles untereinander schreiben, dann würde das Pro-
gramm ziemlich lange werden. Hier verwenden wir in Zeile 4 aber die
Anweisung repeat und sagen der Turtle damit, sie soll die zwei einge-
rückten Befehle in Zeilen 5 und 6 neunmal wiederholen.

In den Zeilen 8 bis 11 füllen wir das Neuneck auch gleich noch aus.
Weil diese Befehle nicht mehr eingerückt sind, werden sie auch nicht
wiederholt, sondern nur noch einmal ausgeführt.
1 from gturtle import *
2 makeTurtle()
3
4 repeat 9:
5 forward(50)
6 left(40)
7
8 penUp()
9 left(80)
10 forward(60)
11 fill()

Wenn du repeat in einem neuen Befehl verwenden möchtest, dann

musst du die Anweisungen, die wiederholt werden sollen, noch stärker
einrücken:

c 2016, Tobias Kohn

2.6. REPETITIONEN 21

def neuneck():
repeat 9:
forward(50)
left(40)

Die wichtigsten Punkte Mit repeat Anzahl: gibst du der Turtle

an, sie soll einen oder mehrere Befehle «Anzahl» Mal wiederholen, be-
vor sie mit neuen Befehlen weitermacht. Alles, was wiederholt werden
soll, muss unter repeat stehen und eingerückt sein.
repeat Anzahl:
Anweisungen, die
wiederholt werden
sollen

AUFGABEN

13. Zeichne mit der Turtle die Treppenfigur (a) aus der Abbildung 2.5.
Verwende dazu repeat.

Abbildung 2.5: Treppen und Sterne

14. Zeichne den fünfzackigen Stern aus der Abbildung 2.5(b) oder (c).
Dazu musst du zuerst die entsprechenden Winkel berechnen. Verwende
wiederum repeat für alles, was sich wiederholen lässt.

15. Definiere einen Befehl achteck(seite), um ein regelmässiges und

ausgefülltes Achteck zeichnen zu lassen.

16.∗ Ein gewöhnliches n-Eck erhältst du immer dann, wenn sich die
◦
Turtle an jeder Ecke um den Winkel 360n dreht (insgesamt hat sie sich
◦
nach dem Zeichnen also um 360 gedreht). Für einen regelmässigen
Stern muss sich die Turtle an jeder Ecke um einen doppelt so grossen
Winkel drehen.
Schreibe damit einen Befehl stern(n), der einen regelmässigen n-
zackigen Stern zeichnet.

c 2016, Tobias Kohn

22 KAPITEL 2. GRAFIK MIT DER TURTLE

7 Kreise und Bogen

Lernziele In diesem Abschnitt lernst du:

. Mit der Turtle Kreise und Kreisbogen zu zeichnen.

Einführung Die Turtle kann keine «perfekten» Kreise zeichnen: Sie

kann ja nur ein Stück weit geradeaus gehen und sich drehen. Wenn wir
die Turtle aber ein Vieleck mit sehr vielen Ecken zeichnen lassen, dann
entsteht eine ziemlich gute Annäherung an einen Kreis.

Der Computerbildschirm hat eine relativ grobe Auflösung. Ein 36-Eck

lässt sich meistens schon nicht mehr von einem echten Kreis unterschei-
den. 72 Ecken dürften auf jeden Fall genügen, aber wenn du besonders
präzise sein willst, kannst du natürlich auch ein 360-Eck zeichnen.

Nach einem ganzen Kreis hat sich die Turtle immer um 360◦ gedreht.
Bei z. B. 36 Ecken bedeutet das, dass sich die Turtle an jeder Ecke um
360◦ : 36 = 10◦ drehen muss.

Das Programm Dieses Programm zeichnet einen Kreis, indem die

Turtle immer 6 Pixel vorwärts geht, sich dann um 5◦ nach links dreht
und wieder vier Pixel vorwärts geht. Damit ein ganzer Kreis entsteht,
muss die Turtle sich 72 Mal drehen (72 · 5◦ = 360◦ ).
1 from gturtle import *
2 makeTurtle()
3
4 repeat 72:
5 forward(6)
6 left(5)

In der Zeile 5 kannst du die 6 ändern, um einen grösseren oder kleine-

ren Kreis zu erhalten. Mit der Zahl in Zeile 4 – hier 72 – steuerst du,
welcher Teil des Kreises gezeichnet werden soll. Für 36 Wiederholun-
gen (bei 5◦ ) entsteht zum Beispiel ein Halbkreis.

Radius und Umfang Wenn die Turtle einen Kreis zeichnet, dann
kennst du den Umfang des Kreises sehr genau. Im Beispiel oben ging
die Turtle 72 mal 6 Pixel vorwärts. Der Kreis hat also einen Umfang von
u = 72 · 6 = 432 Pixeln.
Für den Umfang u und Radius
Bei einem Kreis entspricht ein Umfang von 432 Pixeln einem Radius r eines Kreises gilt:
von 68.75 Pixeln. Das lässt sich über die Formel u = 2π · r berechnen. u = 2πr.

c 2016, Tobias Kohn

2.7. KREISE UND BOGEN 23

Weil wir die Kreise aber durch Polygone (Vielecke) annähern, stimmt
diese Rechnung nicht ganz und wird einiges komplizierter. Die Turtle
kann jedoch den exakten Umfang für einen bestimmten Radius aus-
rechnen. Das sieht dann so aus:
umfang = polyCircumference(72, radius)
repeat 72:
forward(umfang / 72)
left(360 / 72)

Die wichtigsten Punkte Die Turtle kann keine echten Kreise zeich-
nen. Bei einem regelmässigen Vieleck mit sehr vielen Ecken ist der Un-
terschied zu einem Kreis aber nicht mehr sichtbar.

Für einen ganzen Kreis muss sich die Turtle insgesamt um 360◦ drehen.
Indem du die Anzahl der Wiederholungen kleiner machst, dreht sich
die Turtle nur um 180◦ oder 90◦ und zeichnet damit einen Halb- oder
Viertelkreis.

AUFGABEN

17. Zeichne mit der Turtle einen Kreis mit einem Radius von r = 20
Pixeln.

18. Definiere einen eigenen Befehl circle(s), um einen Kreis zu zeich-

nen und einen Befehl fillcircle(s), um einen ausgefüllten Kreis zu
zeichnen. Der Parameter s gibt dabei an, um wieviel die Turtle bei je-
dem Schritt vorwärts gehen soll.

19. Lass deine Turtle den PacMan (a), das Yin-Yang-Symbol (b) und ein
beliebiges Smiley (c) zeichnen wie in der Abbildung 2.6. Bei den klei-
nen Punkten genügt es meist, ein kurzes, breites Linienstück zu zeich-
nen.

Abbildung 2.6: Kreisfiguren.

20. Die «Blume» in der Abbildung 2.6(d) setzt sich aus sieben gleich
grossen Kreisen zusammen. Verwende einen eigenen Befehl circle()
und zeichne damit diese Blume.

c 2016, Tobias Kohn

24 KAPITEL 2. GRAFIK MIT DER TURTLE

8 Kuchenstücke

Lernziele In diesem Abschnitt lernst du:

. Beim Zeichnen von Kreisen mit der Turtle Winkel zu korrigieren.
. Mit der Turtle exakte Kreissektoren und Kuchenstücke zu zeichnen.

Einführung Der Computer kann keine Kreise zeichnen. Aber ein Po-
lygon (Vieleck) mit genügend Ecken sieht auf dem Bildschirm aus wie
ein Kreis. Nur gibt es dabei ein Problem: Sobald du nur einen Teil des
Kreisbogens zeichnest oder den Radius brauchst, wird das Bild unge-
nau und fehlerhaft (das hast du sicher selbst bei der Aufgabe (2.19)
zum «PacMan» bemerkt): Der Mittelpunkt des Kreises ist am falschen
Ort.

Das Programm Um das Problem zu illustrieren, zeichnen wir mit

der Turtle einen «Halbkreis», den wir mit einem Achteck annähern. Ob-
wohl sich die Turtle dabei um 360◦ dreht ergibt sich kein geschlossener
Halbkreis, sondern die nebenstehende Figur. Warum? Wo liegt der Feh-
ler?
1 from gturtle import *
2 makeTurtle()
3 right(90)
4 forward(52)
5 left(90)
6 repeat 4:
7 forward(40)
8 left(45)
9 left(90)
10 forward(52)

Winkel korrigieren Der Grund, warum sich oben keine geschlosse-

ne Figur ergibt liegt bei den Winkeln. Du siehst in der Abbildung 2.7,
wo das Problem liegt: Bei einem Polygon steht der Radius nicht ganz
senkrecht auf der Umfangslinie. Es gibt eine kleine Abweichung ϕ. Wie
gross ist diese Abweichung ϕ? Was musst du im Programm oben än-
dern, damit diese Abweichung korrekt berücksichtigt wird?

Die Abweichung ϕ ist gerade der halbe Winkel, um den sich die Turtle
bei jedem Schritt drehen muss. In unserem Fall also die Hälfte von 45◦
und damit ist ϕ = 22.5◦ . Wenn wir im Programm oben die Zeilen 5 bis 9
entsprechend anpassen, dann ergibt sich auch ein viel besseres Bild.

c 2016, Tobias Kohn

2.8. KUCHENSTÜCKE 25

Abbildung 2.7: Beim Kreis steht der Radius senkrecht zur Kreislinie (links).
Bei einem Polygon ist der Winkel zwischen Radius und Umfangslinie nicht
ganz rechtwinklig (rechts).

left(90 + 22.5)
repeat 4:
forward(40)
left(45)
left(90 - 22.5)

Die wichtigsten Punkte Um einen Kreis mit festem Mittelpunkt oder

einen Kreissektor zu zeichnen musst du einige Winkel korrigieren. Die
Korrektur ϕ entspricht immer der Hälfte des Winkels, um den sich die
Turtle in der Schleife dreht.

AUFGABEN

21. Zeichne einen acht-teiligen Kreis wie in der Abbildung nebenan.

Verwende dazu ein 72-eck und färbe die Stücke abwechselnd mit zwei
verschiedenen Farben ein.
5 1
22. Zeichne ein Kuchendiagramm mit drei Stücken, die bzw. 14
12 , 3
des Kreises einnehmen. Verwende für jedes Stück eine andere Farbe
und achte darauf, dass die einzelnen Kuchenstücke genau sind.

c 2016, Tobias Kohn

26 KAPITEL 2. GRAFIK MIT DER TURTLE

9 Parameter strecken

Lernziele In diesem Abschnitt lernst du:

. Parameter mit einer Zahl zu multiplizieren oder zu dividieren.

Einführung Eigene Befehle mit Parametern sind unglaublich nütz-

lich und bewähren sich in vielen Situationen. Eine grosse Stärke der
Parameter kommt aber erst jetzt zum Zug: Du kannst in deinem eige-
nen Befehl nicht nur die Parameter selbst verwenden, sondern auch
Vielfache oder Teiler davon. In den zwei Programmen unten zeigen wir
dir, wie du den Parameter mit einer Zahl multiplizieren oder dividieren
kannst.

Das Programm (I) Bei einem gleichschenklig

√ rechtwinkligen Drei-
eck muss die längste Seite immer 2 mal so lang sein wie√eine der
kürzeren Seiten (vgl. Abbildung 2.8). Die Turtle kennt zwar 2 nicht,
aber in diesem Programm sagen wir ihr, dass die letzte Seite des Drei-
ecks 1.4142 mal so lang sein soll wie die beiden anderen Seiten.

Abbildung 2.8: Mit dem Satz des Pythagoras ergibt sich, dass die Hypote-
√
nuse des Dreiecks 2 mal so lang sein muss wie die Katheten x.

1 from gturtle import *

2 makeTurtle()
3
4 def rewiDreieck(seite):
5 forward(seite)
6 left(90)
7 forward(seite)
8 left(135)
9 forward(seite * 1.4142)
10 left(135)
11
12 rewiDreieck(50)

In Zeile 9√multiplizieren wir die Seitenlänge 50 mit einem Näherungs-

wert von 2 ≈ 1.41412136.

c 2016, Tobias Kohn

2.9. PARAMETER STRECKEN 27

Das Programm (II) Bei jedem geschlossenen Vieleck (oder Kreis)

muss sich die Turtle für die ganze Figur einmal um 360◦ drehen. Für
ein Quadrat dreht sich die Turtle jedes Mal um 360◦ : 4 = 90◦ , für ein
gleichseitiges Dreieck 360◦ : 3 = 120◦ (das sind nicht die Innenwinkel
der Vielecke).

Dieses Wissen nutzen wir jetzt aus, um ein allgemeines Vieleck zu de-
finieren. Der Parameter gibt dabei an, wie viele Ecken bzw. Seiten das
Vieleck haben soll. Danach wird damit ein Fünfeck gezeichnet.
1 from gturtle import *
2 makeTurtle()
3
4 def vieleck(n):
5 repeat n:
6 forward(70)
7 left(360 / n)
8 vieleck(5)

Die wichtigsten Punkte In einem eigenen Befehl kannst du Vielfa-

che eines Parameters verwenden, indem du den Parameter mit einer
Zahl multiplizierst (mit *) oder dividierst (mit /).

AUFGABEN

23. Schreibe einen Befehl, der ein Quadrat mit einem Kreuz darin zeich-
net (vgl. Abbildung 2.9 (a)). Dabei wird die Seitenlänge des Quadrats
mit einem Parameter angegeben und kann beliebig gewählt werden.

Abbildung 2.9: Figuren zu den Aufgaben 2.23 und 2.24.

24. Definiere einen Befehl treppe(stufen), der die Treppe aus Ab-
bildung 2.9(b) zeichnet. Die Treppe hat dabei immer eine Breite und
eine Höhe von 120 Pixeln. Die Anzahl der Stufen kann man über den
Parameter steuern.

25. Definiere einen Befehl kreis(umfang), der einen Kreis mit dem
angegebenen Umfang zeichnet. Schwierigere Variante: Definiere den
Kreis so, dass der Parameter den Radius angibt.

c 2016, Tobias Kohn

28 KAPITEL 2. GRAFIK MIT DER TURTLE

10 Mehrere Parameter

Lernziele In diesem Abschnitt lernst du:

. Befehle mit mehreren Parametern zu definieren.

Einführung Parameter sind sehr praktisch, weil du mit ihnen steu-

ern kannst, wie gross etwa dein Quadrat werden soll. Bei einigen Fi-
guren reicht ein einzelner Parameter aber nicht aus: Ein Rechteck hat
nicht nur eine Seitenlänge, sondern eine Breite und eine eine Höhe. In
solchen Fällen ist es sinnvoll, einen Befehl mit mehreren Parametern zu
definieren.

Parameter gibst du immer in Klammern hinter dem Befehlsnamen an.

Wenn du mehrere Parameter brauchst, dann trennst du sie mit Komma-
ta.

Das Programm In der Zeile 4 definieren wir einen neuen Befehl

für ein Rechteck. Dieser Befehl hat zwei Parameter: breite und hoehe
(beachte, dass du beim Programmieren nur englische Buchstaben ver-
wenden darfst und wir deshalb «ö» als «oe» schreiben). In Zeile 15
sagen wir der Turtle dann, sie soll das Rechteck zeichnen und geben für
beide Parameter Zahlenwerte an.

1 from gturtle import *

2 makeTurtle()
3
4 def rechteck(breite, hoehe):
5 forward(hoehe)
6 right(90)
7 forward(breite)
8 right(90)
9 forward(hoehe)
10 right(90)
11 forward(breite)
12 right(90)
13
14 setPenColor("salmon")
15 rechteck(150, 120)

Die Reihenfolge der Parameter spielt eine Rolle. Weil wir in der Defini-
tion zuerst die Breite und dann die Höhe haben, wird in Zeile 15 auch
für die Breite der Wert 150 und für die Höhe der Wert 120 eingesetzt.

c 2016, Tobias Kohn

2.10. MEHRERE PARAMETER 29

Die wichtigsten Punkte In Python können Befehle beliebig viele Pa-

rameter haben. Die verschiedenen Parameter werden immer mit Kom-
ma voneinander getrennt. Natürlich braucht auch jeder Parameter einen
eigenen Namen.
def Befehl(param1, param2, param3):
Anweisungen mit
den Parametern

Befehl(123, 456, 789)

Wenn du für deinen neuen Befehl beim Ausführen Zahlenwerte angibst,

dann ist die Reihenfolge immer die gleiche wie bei der Definition.

AUFGABEN

26. Definiere einen Befehl vieleck(n, seite), bei dem du die Anzahl
der Ecken n und die Seitenlänge angeben kannst.

27. Der Rhombus (Abb. 2.10(a)) hat vier gleich lange Seiten, im Ge-
gensatz zum Quadrat sind die Winkel allerdings in der Regel keine
rechten Winkel. Definiere einen Befehl rhombus(seite, winkel), bei
dem man die Seitenlänge und den Winkel angeben kann, und der dann
einen Rhombus zeichnet.

28.∗ Erweitere den Rhombus-Befehl zu einem Parallelogramm mit un-

terschiedlicher Breite und Höhe. Dieser Befehl hat drei Parameter.

29. Definiere einen Befehl gitter(breite, hoehe), der ein Gitter wie
in Abbildung 2.10(b) zeichnet. Jedes Quadrätchen soll eine Seitenlän-
ge von 10 Pixeln haben. Die beiden Parameter geben die Anzahl dieser
Häuschen an (in der Abbildung wäre also breite = 6 und hoehe = 4).

Abbildung 2.10: Rhombus, Gitter und Schachbrettmuster.

30.∗ Definiere einen Befehl schachbrett(breite, hoehe), um ein

Schachbrett wie in Abbildung 2.10(c) zu zeichnen. Gehe davon aus,
dass breite und hoehe gerade Zahlen sind (wie auch in der Abbil-
dung).

c 2016, Tobias Kohn

30 KAPITEL 2. GRAFIK MIT DER TURTLE

11 Den Programmablauf beobachten

Lernziele In diesem Abschnitt lernst du:

. Wie du den Programmablauf verfolgen kannst.

Einführung Du kannst der Turtle zuschauen, wie sie ihre Figuren

zeichnet und siehst dabei, in welcher Reihenfolge sie ihre Linien zeich-
net. Was du dabei nicht siehst: Welche Anweisungen in deinem Pro-
grammcode führt die Turtle im Moment gerade aus? Welche Zeile in
deinem Programmcode macht genau was?

In TigerJython kannst du nicht nur der Turtle beim Zeichnen zuschau-

en. Du kannst auch mitverfolgen, welche Zeilen im Programmcode ge-
rade ausgeführt werden. Das Werkzeug dazu heisst «Debugger». Klicke
in TigerJython auf den Käfer oben, um den Debugger zu aktivieren:

Abbildung 2.11: Der Debugger zeigt sich rechts im Fenster, sobald du auf
den Käfer klickst. Solange das Debuggerfenster offen ist, kannst du den
Programmablauf beobachten.

Das Programm Das Programm zeichnet ein Dreieck, so wie du es

selbst schon gemacht hast. Tippe es ein und starte dann den Debugger
(Abb. 2.11). Danach klickst du auf «Einzelschritt» im Debugger, um das

c 2016, Tobias Kohn

2.11. DEN PROGRAMMABLAUF BEOBACHTEN 31

Programm zu starten. Jedes Mal, wenn du auf «Einzelschritt» klickst,

wird eine Codezeile ausgeführt. Dabei kannst du beobachten, wie die
aktuelle Codezeile gelb unterlegt wird.
1 from gturtle import *
2 makeTurtle()
3
4 def dreieck(seite):
5 forward(seite)
6 left(120)
7 forward(seite)
8 left(120)
9 forward(seite)
10 left(120)
11 setPenColor("green")
12 dreieck(80)

Ist dir aufgefallen, dass der Computer von der Zeile 4 direkt zur Zei-
le 11 springt? Bei der Definition von dreieck(seite): merkt er sich
nämlich nur, dass ab der Zeile 4 steht, wie die Turtle das Dreieck zeich-
nen soll. Aber: Gezeichnet wird das Dreieck hier noch nicht! Erst in
Zeile 12 sagst du der Turtle, sie soll ein Dreieck zeichnen. Und weil
sich der Computer gemerkt hat, dass in Zeile 4 steht, was ein Dreieck
ist, springt er wieder hoch und arbeitet jetzt die Schritte ab, um das
Dreieck wirklich zu zeichnen.

AUFGABEN

31. Schreibe das Programm unten ab und beobachte mit dem Debug-
ger, wie das Programm ausgeführt wird.
from gturtle import *
makeTurtle()
repeat 4:
forward(100)
left(90)
penUp()
left(45)
forward(10)
setFillColor("sky blue")
fill()

32. Verändere das Programm oben so, dass du einen Befehl quadrat
definierst, um das Quadrat zu zeichnen. Betrachte auch dann den Pro-
grammablauf mit dem Debugger. Was ist gegenüber der ersten Version
grundlegend anders?
def quadrat(seite):
repeat 4:
forward(seite)
left(90)

c 2016, Tobias Kohn

32 KAPITEL 2. GRAFIK MIT DER TURTLE

12 Programme mit Fehlern

Lernziele In diesem Abschnitt lernst du:

. In einem Programm Fehler zu finden und zu korrigieren.

Einführung Beim Programmieren entstehen immer Fehler (auch bei

Profis). Dabei gibt es zwei wesentliche Arten von Fehlern: Ein «Syntax-
fehler» bedeutet, dass die Schreibweise nicht stimmt. Der Computer ist
hier sehr empfindlich: Wenn eine Klammer fehlt oder etwas falsch ge-
schrieben ist, dann kann der Computer das Programm nicht ausführen
oder hört mitendrin auf. Die zweite Fehlerart sind «Logikfehler». Bei sol-
chen Fehlern läuft das Programm zwar, aber es macht nicht das, was es
sollte. Bei grösseren Programmen sind solche Logikfehler sehr schwie-
rig zu finden, obwohl man weiss, dass es solche Fehler enthält.
So sieht eine Fehlermeldung in
Nachdem du bereits etwas Erfahrung im Programmieren gesammelt TigerJython aus. Die fehlerhaf-
hast, solltest du die Schreibweise (Syntax) von Python langsam ken- te Zeile wird rot markiert und
nen und Fehler selber finden können. Auf der anderen Seite solltest du unten siehst du den Hinweis,
aber auch die Fehlermeldungen verstehen lernen, die dir der Computer was falsch ist.
ausgibt, wenn etwas nicht stimmt.

Das Programm Dieses Programm sollte ein gleichseitiges Dreieck

zeichnen, enthält aber in jeder Zeile einen Fehler (ausgenommen sind
natürlich die leeren Zeilen). Der Fehler in Zeile 7 ist ein «Logikfehler»:
Da stimmt der Winkel nicht. Alles andere sind sogenannte «Syntaxfeh-
ler», bei denen die Schreibweise falsch ist.
1 from GTurtle import *
2 makeTurtle
3
4 def dreieck(seite)
5 repet 3:
6 forward seite
7 left(60)
8
9 setPenColor(red)
10 Dreieck(160)

Versuche einmal selbst, alle Fehler zu finden! Arbeite dazu zuerst ohne
Computer und teste dein Wissen über die Schreibweise von Python. Auf
der nächsten Seite findest du die Auflösung.

c 2016, Tobias Kohn

2.12. PROGRAMME MIT FEHLERN 33

Wenn ein Programm Syntaxfehler enthält, dann wird dir TigerJython

das auch sagen. Gib das fehlerhafte Programm ein und schaue dir an,
welche Fehlermeldungen zu den einzelnen Zeilen ausgegeben werden.

Und hier die Auflösung:

from gturtle import * # Das gt bei gturtle muss klein sein
makeTurtle() # Klammern vergessen

def dreieck(seite): # Doppelpunkt vergessen

repeat 3: # Ein ’a’ vergessen
forward(seite) # Parameter müssen in Klammern sein
left(120) # Der Winkel muss 120 sein

setPenColor("red") # Farbnamen gehören in Anführungszeichen

dreieck(160) # Die Gross-/Kleinschreibung ist wichtig

AUFGABEN

33. Auch dieses Programm ist voller Fehler. Finde und korrigiere sie!
from gturtle import

def fünfeck(seite):
repeat5:
forwart(seite)
left(72)

fünfeck(100)
Tipp: Auch wenn wieder grundsätzlich jede Zeile einen Fehler enthält,
kommen die gleichen Fehler oft mehrfach vor.

34. Beim diesem kurzen Progrämmchen sind zwei Fehler drin.

makeTurtle()
repeat 6:
forward(100)
right(120)

(a) Wenn du versuchst, das Programm auszuführen, dann sagt Tiger-

Jython «Unbekannter Name: makeTurtle()». Woran liegt das? Was
ist falsch und wie lässt es sich korrigieren.
(b) Nachdem du das Programm soweit korrigiert hast, zeichnet die
Turtle eine Figur. Allerdings scheint der Programmierer hier et-
was anderes gewollt zu haben. Auf welche zwei Arten lässt sich
die Absicht des Programmierers interpretieren und das Programm
korrigieren?

c 2016, Tobias Kohn

34 KAPITEL 2. GRAFIK MIT DER TURTLE

13 Die Turtle direkt steuern*

Lernziele In diesem Abschnitt lernst du:

. Mit der Konsole zu arbeiten.

Einführung Um ein Programm zu schreiben überlegst du dir im Vor-

aus, wie sich die Turtle bewegen soll, stellst das Programm zusammen
und lässt es dann laufen. Es gibt aber Situationen, in denen es praktisch
wäre, direkt zu sehen, was die Turtle bei einer Anweisung macht. Oder
du möchtest vielleicht kurz etwas berechnen oder ausprobieren.

Für all diese Fälle gibt es die interaktive Konsole (manchmal auch eng-
lisch als «Console» geschrieben). Die interaktive Konsole ist dazu da,
einzelne Anweisungen auszuführen und direkt das Resultat zu sehen.

Abbildung 2.12: So sieht die interaktive Konsole in TigerJython aus. Wenn

du eine Rechnung eingibst, dann erscheint das Resultat direkt darunter.

Starte die Konsole, indem du auf die entsprechende Schaltfläche oben

klickst. Dann öffnet sich ein neues Fenster mit dem Eingabebereich
oben und dem Ausgabefenster unten. Gib eine einfache Rechnung ein,
etwa «3+4» und drücke «Enter». Das Ergebnis wird dir dann direkt dar- Die Schaltfläche zum Aufrufen
unter angezeigt. der Konsole.

Wichtig: Die Konsole ist nicht dazu gedacht, ein ganzes Programm am
Stück auszuführen! Gib hier also immer nur einzelne Anweisungen ein
und führe sie aus.

c 2016, Tobias Kohn

2.13. DIE TURTLE DIREKT STEUERN* 35

Die Turtle und die Konsole Auch wenn wir von der Konsole aus mit
der Turtle arbeiten müssen wir die Turtle zuerst laden und ein Fenster
öffnen. Das machst du wie bisher mit den Anweisungen:
>>> from gturtle import *
>>> makeTurtle()
< Turtle(Position=(0,0), Heading=0)
>>>

Nachdem du das Turtlefenster geöffnet hast, darfst du es natürlich nicht

wieder schliessen! Ordne die Fenster auf dem Bildschirm so an, dass
das Turtlefenster und die Konsole nebeneinander zu liegen kommen.
Gib nun einzelne Befehle wie forward(20), left(45), etc. ein und
beobachte, wie sich die Turtle direkt bewegt.

Abbildung 2.13: Ordne die Fenster so an, dass das Turtlefenster neben
der Konsole zu liegen kommt. Du darfst das Turtlefenster natürlich nicht
schliessen, solange du damit arbeitest.

Wiederholungen und neue Befehle Wiederholungen mit repeat

oder neue Befehle mit def beinhalten mehrere Anweisungen, die zu-
sammengehören. In der Konsole gibst du alle solche Anweisungen, die
zusammengehören auch zusammen ein. Damit TigerJython weiss, wann
die Anweisung fertig ist musst du am Ende zweimal «Enter» drücken.

Hinweis: Wenn du etwas in der Konsole ausgeführt hast, kannst du es nicht

mehr ändern oder löschen. Du kannst nur jeweils in der untersten, gelben
Zeile eine Anweisung eingeben und ausführen lassen.

AUFGABEN

35. Verwende die Konsole, um herauszufinden, was die Turtle bei den
Befehlen dot(100), heading(45) und leftArc(60, 100) macht. Än-
dere auch die Zahlen ab und beobachte, welchen Einfluss sie haben.

c 2016, Tobias Kohn

36 KAPITEL 2. GRAFIK MIT DER TURTLE

14 Tipps und Tricks zur Turtle*

Lernziele In diesem Abschnitt lernst du:

. Punkte und Flächen zu zeichnen.

Einführung Die Turtle kann natürlich noch viel mehr als das, was
Du in diesem Kapitel gelernt hast. Zum Abschluss geben wir dir daher
noch einen kleinen Ausblick.

Das Programm: Eine Ampel Wir zeichnen eine einfache Ampel,

wie im Bild nebenan. Allerdings verwenden wir dazu zwei Tricks. Zum
einen zeichnen wir das schwarze Rechteck mit einer dicken schwarzen
Linie (Zeilen 3 bis 5). Danach setzen wir mit dem Befehl dot(d) (d ist
der Durchmesser) farbige Punkte in dieses Rechteck.
1 from gturtle import *
2 makeTurtle()
3 setPenColor("black")
4 setPenWidth(40)
5 forward(80)
6 left(180)
7 penUp()
8 setPenColor("red")
9 dot(30)
10 forward(40)
11 setPenColor("yellow")
12 dot(30)
13 forward(40)
14 setPenColor("green")
15 dot(30)
16 forward(40)

Das Programm: PacMan Die Turtle kann nicht nur Flächen mit ei-
ner Farbe füllen, sondern auch direkt gefüllte Flächen zeichnen. Nach
dem Befehl fillToPoint() verbindet die Turtle alle weiteren Punkte,
die sie zeichnet mit dem ersten Punkt. Dadurch entsteht eine farbige
Fläche. Mit fillOff() wird das wieder ausgeschaltet. Damit können
wir unseren PacMan hier sehr einfach und schnell zeichnen.
1 from gturtle import *
2 makeTurtle()
3 fillToPoint()
4 right(45)

c 2016, Tobias Kohn

2.14. TIPPS UND TRICKS ZUR TURTLE* 37

5 forward(100)
6 left(90 + 2.5)
7 s = polyCircumference(72, 100)
8 repeat 54:
9 forward(s / 72)
10 left(5)
11 fillOff()

AUFGABEN

36. Zeichne eine Perlenkette wie in der Abbildung nebenan.

37. Zeichne mit dot() einen Ring mit dem Innenradius von 120 Pixeln
und einer Dicke von 30 Pixeln.

38. Verwende die Technik mit fillToPoint(), um einen gefüllten fünf-

zackigen Stern zu zeichnen (vgl. 2.14 auf Seite 21). Umrande dann den
entstandenen Stern mit einer anderen Farbe.

39.∗ Zeichne die Bienenwaben aus Abbildung 2.14(a).

40.∗ Schreibe eine Funktion punkte(n), die nebeneinander n gleiche

Punkte zeichnet. Achte darauf, dass die Punkte auf die akktuelle Turtle-
position zentriert werden und setze die Turtle am Ende dorthin zurück,
wo sie am Anfang stand. Wenn du also drei Punkte zeichnest, dann
wird an der aktuellen Turtleposition der mittlere Punkt gezeichnet.

41.∗ Verwende die Funktion punkte(n) aus der letzten Aufgabe, um

ein Dreieck wie in Abbildung 2.14(b) zu zeichnen.

Abbildung 2.14: Bienenwaben, Punkte und ein perspektivisches Haus.

42.∗ Für Profis: Zeichne mit der Turtle ein dreidimensionales Haus. Ei-
ne besondere Herausforderung besteht darin, das Haus perspektivisch
korrekt zu zeichnen wie in Abbildung 2.14(c).
Hinweis: Mit setHeading(towards(-400, 0)) wird die Turtle auf die
Mitte des linken Fensterrands ausgerichtet. Für den rechten Fenster-
rand verwendest du +400.

c 2016, Tobias Kohn

38 KAPITEL 2. GRAFIK MIT DER TURTLE

Quiz
1. Nach welcher Anweisung zeichnet die Turtle ihre Linien in
grün?

2 a. setColor("green")
2 b. setFillColor("green")
2 c. setLineColor("green")
2 d. setPenColor("green")

2. Die Turtle soll bei einem Dreieck einen Winkel von 45◦ nach
links zeichnen. Mit welchen Drehungen entsteht der richtige
Winkel?

2 a. left(45) 2 c. right(225)
2 b. left(135) 2 d. right(-45)

3. Was macht die Turtle bei der folgenden Befehlssequenz?

repeat 36:
forward(2)
right(5)

2 a. Sie zeichnet einen Halbkreis,

2 b. Sie zeichnet eine gerade Linie und dreht sich dann,
2 c. Sie zeichnet ein 36-Eck,
2 d. Sie macht gar nichts, weil der Code falsch ist.

4. Was zeichnet die Turtle bei dieser Befehlssequenz?

def foo(x, y):
left(y)
forward(x)
repeat 9:
foo(120, 60)

2 a. Ein Sechseck,
2 b. Ein Neuneck,
2 c. Eine Schneeflocke,
2 d. Gar nichts, weil left und forward vertauscht sind.

c 2016, Tobias Kohn

K a p i t e l D r e i

RECHNEN MIT PYTHON

Rechnen am Computer ist ein Heimspiel, zumal die ersten Computer

tatsächlich zum Rechnen gebaut wurden. Du wirst sehen, dass du die
Grundoperationen wie bei einem Taschenrechner eingeben kannst. Da-
bei kannst du auch vordefinierte Konstanten wie beispielsweise π ver-
wenden.

Für das Programmieren zentral ist dabei der Umgang mit Variablen. Da-
mit kannst du Formeln einprogrammieren und mit Werten rechnen, die
du während des Programmierens noch gar nicht kennst (z. B. die Resul-
tate von komplizierten Berechnungen oder Eingaben des Benutzers).
Stell dir zum Beispiel vor, dein Programm soll herausfinden, ob ein be-
stimmtes Jahr ein Schaltjahr ist oder nicht. Dann weisst du während du
das Programm schreibst noch nicht, für welches Jahr oder welche Jahre
der Computer rechnen soll. Das wird erst dann entschieden, wenn das
Programm läuft und ausgeführt wird. Und weil der Computer zwischen
einfachen Fällen unterscheiden kann, findet er tatsächlich auch heraus,
welches Jahr nun ein Schaltjahr ist. Aber dazu später mehr.

Mit den Techniken aus diesem Kapitel kannst du beispielsweise auch

die Teilbarkeit von Zahlen untersuchen oder das Osterdatum im Jahr
2032 bestimmen. Selbst die Lösungen von quadratischen Gleichungen
lassen sich auf diese Weise berechnen.

c 2016, Tobias Kohn

40 KAPITEL 3. RECHNEN MIT PYTHON

1 Grundoperationen und das Zahlenformat

Lernziele In diesem Abschnitt lernst du:

. Die vier Grundrechenarten in Python auszuführen.
. Den Unterschied zwischen ganzen und gebrochenen bzw. wissen-
schaftlichen Zahlen kennen.
. Die wissenschaftliche Schreibweise von Zahlen zu verwenden.

Einführung: Zahlen Der Computer kennt zwei verschiedene Zah-

lentypen: Ganze Zahlen (engl. integer) und wissenschaftliche Zahlen
(engl. floating point number).

Vielleicht kennst du die wissenschaftliche Schreibweise bereits aus dem

Mathematik- oder Physikunterricht. Mit dieser Schreibweise lassen sich
sehr grosse (oder sehr kleine) Zahlen viel kürzer und übersichtlicher
schreiben. Die Masse der Erde ist z. B.:
24
| 000 000 000{z000 000 000 000} kg = 5.98 · 10 kg
5 980
24 Stellen

An diesem Beispiel siehst du bereits, wie ungemein praktisch diese kür-

zere wissenschaftliche Schreibweise ist. Die wesentlichen Ziffern sind
hier nur «598» und nach der ersten dieser Ziffern (der Fünf) kommen
nochmals 24 Stellen. Daraus entsteht die wissenschaftlichen Schreib-
weise mit der Mantisse 5.98 und dem Exponenten 24.

Computer arbeiten auch mit dieser wissenschaftlichen Schreibweise,

konnten früher aber das ·102 nicht schreiben. Deshalb hat man sich vor
langer Zeit auf die Darstellung mit einem e geeinigt: 5.98e+24 oder
einfach 5.98e24 (e steht für «Exponent»).

Sehr kleine Zahlen kannst du ebenfalls so schreiben:

−14
0. 000 {z 000 04} 9 05 = 4.905 · 10
| 000 000 = 4.905e-14
14 Stellen
Beim Rechnen mit wissen-
schaftlichen Zahlen auf dem
Im Prinzip entsteht die wissenschaftliche Schreibweise dadurch, dass Computer entstehen oft Run-
du den Dezimalpunkt (das Komma) hinter die erste wesentliche Stelle dungsfehler. Wegen dieser
verschiebst. Das wird durch den englischen Namen «floating point num- Rundungsfehler spielt auf dem
ber» ausgedrückt, meist abgekürzt zu «float». Beachte, dass Computer Computer die Reihenfolge der
einzelnen Rechnungen eine
in diesem Format nur mit 12 bis 20 Stellen arbeiten und längere Zah-
Rolle: x + y 6= y + x.
len einfach runden. Das führt schnell zu Rundungsfehlern, wie du beim
Programm auf der nächsten Seite sehen wirst.

c 2016, Tobias Kohn

 3.1. GRUNDOPERATIONEN UND DAS ZAHLENFORMAT 41

Ausgaben mit print Damit dir der Computer überhaupt etwas aus-
gibt, musst du ihn anweisen, das zu tun. Die Anweisung dafür heisst
print. Es genügt also nicht, einfach die Rechnung einzugeben. Du
musst dem Computer mit einem print auch sagen, dass er das Resul-
tat der Rechnung ausgeben muss, etwa print 13/3, um das Resultat
4.3333333333 zu erhalten.

Das Programm In diesem Programm soll uns Python zuerst die

Zahl 1 234 567 890 123 456 789 zweimal ausgeben. Im ersten Fall ist es
für den Computer eine ganze Zahl (integer). Weil im zweiten Fall am
Schluss ein Dezimalpunkt steht, ist das automatisch eine wissenschaft-
liche Zahl und wird auch gleich gerundet: Die Ausgabe von Zeile 2 ist
1.23456789012e+18.

1 print 1234567890123456789
2 print 1234567890123456789.0
3
4 print (1/2 + 1/3 + 1/6) - 1
5 print (1/6 + 1/3 + 1/2) - (1/2 + 1/3 + 1/6)

In Zeile 4 und 5 berechnet Python schliesslich zuerst das Resultat der

Rechnung und gibt das dann aus. Siehst du, dass 12 + 31 + 16 = 1 ist?
Wenn Python richtig rechnet, sollte die Ausgabe 0 sein – ist sie aber
nicht! Kannst du diesen Unterschied erklären?

Die wichtigsten Punkte Für Rechnungen verwendest du in Python

die Grundoperationen +, -, * und /. Zahlen werden entweder als gan-
ze Zahlen (integer) oder in wissenschaftlicher Schreibweise (float) an-
gegeben, also z. B. 5.98e24 für 5.98 · 1024 . In der wissenschaftlichen
Wenn du grosse ganze Zah- Schreibweise rundet Python immer auf 12 bis 20 Stellen.
len ausgibst, dann hängt Py-
thon ein «L» an, das für «long» Python schreibt die Resultate und Zahlen nur auf den Bildschirm, wenn
steht. Das ist ein Überbleibsel du das mit print angibst.
von früher und hat heute kei-
ne Bedeutung mehr.
AUFGABEN

1
1. Du kannst 3 auch als Dezimalzahl eingeben: 0.333 . . .. Wie viele
Dreien musst du eingeben, bis die folgenden Rechnungen das richti-
ge Resultat liefern?
(a) print 3 * 0.333, (b) print (3 * 0.333) - 1

2. Die Entfernung der Erde von der Sonne beträgt rund 1.496 · 108 km.
Die Lichtgeschwindigkeit beträgt ca. 300 000 000 m/s. Berechne mit Py-
thon, wie lange das Sonnenlicht braucht, um die Erde zu erreichen und
gib das Resultat in Minuten an.

c 2016, Tobias Kohn

42 KAPITEL 3. RECHNEN MIT PYTHON

2 Variablen für unbekannte Werte

Lernziele In diesem Abschnitt lernst du:

. Mit Variablen zu arbeiten, damit du die konkrten Werte für dein Pro-
gramm erst zur Laufzeit eingeben musst.

Einführung Beim Programmieren kennst du nicht immer alle Wer-

te schon im Voraus. Bei fast allen Programmen kannst du vielmehr zur
Laufzeit (d. h. während das Programm läuft) einige Werte festlegen.
Dafür brauchst du beim Programmieren Variablen für die noch unbe-
kannten Werte. Das Konzept kennst du im Prinzip bereits von den Pa-
rametern her.

Das Programm Das Programm zeichnet ein Polygon, wie du es schon

lange kennst. Wenn du das Programm startest, dann ist allerdings noch
nicht festgelegt, wie viele Ecken und welche Grösse das Polygon ha-
ben soll. Die Werte der Variablen ecken und umfang werden also erst
festgelegt, wenn das Programm bereits läuft.

Wichtig sind die beiden Funktionen inputInt() und inputFloat().

Bei diesen Funktionen erscheint auf dem Bildschirm ein kleines Fenster,
in dem du eine Zahl eingeben kannst. Bei inputInt muss es eine ganze
Zahl sein, bei inputFloat eine gebrochene Zahl.
1 from gturtle import *
2 makeTurtle()
3
4 ecken = inputInt("Anzahl Ecken?")
5 umfang = inputFloat("Umfang?")
6 winkel = 360 / ecken
7 seite = umfang / ecken
8 repeat ecken:
9 forward(seite)
10 left(winkel)

Die wichtigsten Punkte Variablen stehen in einem Programm für

unbekannte oder veränderliche Werte. Häufig gibst du den Wert für ei-
ne Variable nicht beim Programmieren ein, sondern erst wenn das Pro-
gramm schon läuft. Dazu verwendest du die Eingabefunktionen inputInt
und inputFloat.
VARIABLE = inputInt("Text")
VARIABLE = inputFloat("Text")

c 2016, Tobias Kohn

 3.2. VARIABLEN FÜR UNBEKANNTE WERTE 43

Natürlich kannst du den Wert einer Variablen auch berechnen oder di-
Namen von Variablen dürfen rekt setzen:
in Python nur aus den lateini-
VARIABLE = RECHNUNG
schen Buchstaben (ohne Um-
laute äöü), den Ziffern und
Achtung: Bei der Zuweisung muss die Variable immer links stehen!
Unterstrichen _ bestehen. Be-
achte, dass Python streng zwi-
schen Gross- und Kleinschrei-
bung unterscheidet:
x 6= X!

AUFGABEN

3. Verwende die Turtle, um eine Gitter zu zeichnen mit n × n Feldern

zu zeichnen. Den konkreten Wert für n kann man dabei über inputInt
eingeben.

4. Schreibe ein Programm, bei dem du den Radius r über inputFloat

eingeben kannst. Das Programm rechnet dann den Umfang u = 2π · r
und die Fläche A = π · r2 des Kreises mit Radius r aus und schreibt
diese Werte mit print ins Ausgabefeld.

5. Schreibe ein Programm, bei dem du zwei Zahlen eingeben kannst.

Der Computer rechnet dann den Durchschnitt dieser beiden Zahlen aus
und schreibt ihn mit print ins Ausgabefeld.

6. In den USA werden Temperaturen in Grad Fahrenheit angegeben.

Die Umrechnung solcher Temperaturangaben von Grad Fahrenheit (TF )
in Grad Celsius (TC ) erfolgt nach der folgenden einfachen Formel:
5
TC = (TF − 32) ·
9
Programmiere diese Formel so, dass man die Temperatur in Fahrenheit
eingeben kann und der Computer mit print den entsprechenden Wert
in ◦ Celsius ausgibt.
Wenn dein Programm richtig arbeitet, dann gilt: 86◦ F = 30◦ C. Teste
damit dein Programm.

7. Schreibe ein Programm, das Längenangaben von Zoll (z. B. 2700 für
die Diagonale eines Displays) in cm umrechnet. Dabei gilt: 100 = 2.54 cm.

8.∗ Schreibe ein Programm, bei dem man eine Prozentzahl eingeben
kann. Die Turtle zeichnet dann ein «Kuchenstück», das der eingegebe-
nen Prozentzahl entspricht. Bei 100 % wird der ganze Kreis eingefärbt,
bei 45 % nicht ganz die Hälfte.

c 2016, Tobias Kohn

44 KAPITEL 3. RECHNEN MIT PYTHON

3 Die ganzzahlige Division

Lernziele In diesem Abschnitt lernst du:

. Die ganzzahlige Division durchzuführen.
. Den Divisionsrest zu berechnen.

Einführung Die ganzzahlige Division mit Rest brauchst du beispiels-

weise, wenn du eine Zeitangabe wie 172 Minuten in Stunden und Mi-
nuten umrechnen willst. Du dividierst dazu 172 durch 60 und erhältst
2 Rest 52. In Python benutzst du für die ganzzahlige Division den Ope-
rator //. Mit print 172 // 60 erhältst du also 2. Doch wie kommst
du zum Divisionsrest? Der Divisionsrest wird manch-
mal auch als «remainder» oder
Zur Berechnung des Divisionsrestes verwendest du in Python den Ope- «modulo» bezeichnet.
rator %. Dieser Operator hat überhaupt nichts mit Prozentrechnung zu
tun. Wenn du print 172 % 60 eingibst, erhältst du 52, den Rest der
ganzahligen Division von 172 durch 60.1

Das Programm In diesem Programm wird eine Zeit in Sekunden ins

gemischte Format mit Stunden, Minuten und Sekunden umgerechnet.
Dazu setzen wir die Variable sekunden zunächst auf den Wert 15322 s.
In den Zeilen 3 und 4 wird dann die ganzzahlige Division durch 60
durchgeführt. Das Resultat und den Rest legen wir in zwei neuen Va-
riablen minuten und rest_Minuten ab.

Nach dem gleichen Prinzip wird in den Zeilen 6 und 7 die Anzahl Stun-
den und die Anzahl der übrigbleibenden Minuten ermittelt und in ent-
sprechenden Variablen abgelegt. Am Ende wird die Zeit mit print im
gemischten Format «Stunden Minuten Sekunden» ausgegeben.
1 sekunden = 15322
2
3 minuten = sekunden // 60
4 rest_Sekunden = sekunden % 60
5
6 stunden = minuten // 60
7 rest_Minuten = minuten % 60
8
9 print stunden, rest_Minuten, rest_Sekunden

1 Weil es auf der Tastatur kein eigentliches Zeichen für den Rest der Division gibt,
verwendet man einfach etwas «ähnliches» – und das Prozentzeichen hat ja auch einen
Schrägstrich wie bei der Division.

c 2016, Tobias Kohn

3.3. DIE GANZZAHLIGE DIVISION 45

Beachte, dass der print-Befehl hier am Ende die Werte von drei Varia-
blen ausgibt. Die Variablen müssen dabei durch ein Komma getrennt
werden. Im Ausgabefenster erscheint bei unserem Beisiel wie erwartet
4 15 22. Wir haben also mit Python berechnet, dass 15 322 Sekunden
umgerechnet 4 Stunden, 15 Minuten und 22 Sekunden entsprechen.

Die wichtigsten Punkte Das eigentliche Resultat der ganzzahligen

Division wird mit dem Operator // berechnet, der Rest der ganzzahli-
gen Division mit dem Operator %.

Mit dem Befehl print kannst du beliebig viele Zahlen, Resultate von
Rechnungen und eben auch den Inhalt von mehreren Variablen ausge-
ben. Die einzelnen Ausgaben müssen dabei durch ein Komma getrennt
werden.

AUFGABEN

9. Bei der Division durch 4 können im Prinzip die Reste 0, 1, 2, 3 auftre-

ten. Bei Quadratzahlen kommen aber nicht alle vier Möglichkeiten vor.
Rechne mit einigen Quadratzahlen durch, welche der vier möglichen
Reste bei der Division durch 4 auftreten.

10. Bei Geldautomaten gibst du einen Betrag ein. Der Automat muss
dann ausrechnen, wie viele Noten von jedem Typ er dazu ausgeben soll.
Der Automat in unserer Aufgabe kennt die Notentypen «200», «100»
und «20». Schreibe ein Programm, das für den Gesamtgeldbetrag aus-
rechnet, wie viele Noten von jedem Typ ausgegeben werden sollen – da-
bei sollen möglichst grosse Noten verwendet werden. Das funktioniert
natürlich nur für Beträge, die auch aufgehen, z. B. 480 → 2 · 200 + 4 · 20.

11.∗ Eine Herausforderung für Profis: Nimm beim Geldautomaten noch

«50» als Notentyp hinzu und lass dein Programm auch für 210 die kor-
rekte Antwort geben: 100 + 50 + 3 · 20.

12. Schreibe ein Programm, das eine dreistellige Zahl in Hunderter,

Zehner und Einer zerlegt.

13.∗ Schreibe ein Programm, das natürliche Zahlen bis 255 ins Binär-
system umrechnet. Für 202 soll also beispielsweise 1 1 0 0 1 0 1 0
ausgegeben werden.

c 2016, Tobias Kohn

46 KAPITEL 3. RECHNEN MIT PYTHON

4 Text ausgeben

Lernziele In diesem Abschnitt lernst du:

. Zwischen Variablen und Text zu unterscheiden.

Einführung Für ein gutes Programm ist eine einfache und verständ-
liche Ausgabe zentral. Das Programm gibt nicht nur einfach die Zah-
lenwerte aus, sondern schreibt auch hin, was sie bedeuten. Damit der
Computer zwischen der Variablen minuten und dem Wort «Minuten»
unterscheiden kann, musst du alles, was keine Variable ist in Gänsefüss-
chen setzen. Probiere es selbst aus:
minuten = 10
print minuten, "Minuten"

Der Text in den Gänsefüsschen darf auch länger sein, Leerschläge und
Umlaute (äöü) enthalten. Text, der in Gänsefüsschen
eingeschlossen ist heisst in
1 print "Wenn einer, der mit Mühe kaum,"
der Fachsprache «string» oder
2 print "Gekrochen ist auf einen Baum,"
«Zeichenkette».
3 print "Schon meint, dass er ein",
4 print "Vogel wär,\nSo irrt sich der."
5 print "\tWilhelm Busch"

In diesem kurzen Gedicht von Wilhelm Busch haben wir auch gleich
noch zwei Sonderzeichen verwendet. In einem Text zwischen den Gän-
sefüsschen steht die Kombination «\n» für einen Zeilenumbruch (new
line) und «\t» für den Tabulator (Einrückung). Dafür verhindet ein
Komma am Ende der Zeile bei print den Zeilenumbruch (Zeile 3).

Das Programm Das Programm ist hier sehr kurz gehalten. Dafür
verwenden wir einen hübschen Trick, um die Nachkommastellen einer
Zahl zu «berechnen». Du kennst bereits die Ganzzahldivision // und
den Operator für den Rest %. Diese funktionieren in Python auch für
gebrochene Zahlen. Und wenn du eine Zahl durch 1 teilst, dann sind
genau die Nachkommastellen der Rest dieser Division. Wenn du ganz am Ende der
Zeile bei print noch ein Kom-
1 zahl = 12.345
ma setzst, dann wird die Zeile
2 nachkommastellen = zahl % 1
nicht umgebrochen.
3 print "Die Nachkommastellen von", zahl,
4 print "sind:", nachkommastellen

Bei print siehst du sehr schön, wie wir zwischen Textstücken unter-
scheiden, die der Computer direkt ausgeben soll, und Variablen, die
der Computer durch den entsprechenden Wert ersetzen soll. Du siehst

c 2016, Tobias Kohn

 3.4. TEXT AUSGEBEN 47

auch: Einmal soll er das Wort «Nachkommastellen» auf den Bildschirm

schreiben und einmal ist nachkommastellen eine Variable. Dank den
Gänsefüsschen weiss der Computer, wann was gemeint ist.

Die wichtigsten Punkte Der Computer interpretiert grundsätzlich

alle Wörter als Anweisungen, Variablen oder Funktionen. Wenn er ein
Übrigens kannst du mit der Textstück bei print buchstabengetreu ausgeben und nicht interpretie-
Anweisung clrScr() das ren soll, dann muss dieses Textstück zwischen Gänsefüsschen stehen:
ganze Ausgabefeld leeren und
den Text darin löschen. print "Textstück"

Im Gegensatz zu Variablen darf ein solches Textstück auch Leerschläge

und Umlaute (äöü) enthalten. Wenn du einmal Gänsefüsschen selber
brauchst, dann verwende dafür die Kombination \".

Du darfst Textstücke auch mit Variablen mischen, musst aber dazwi-

schen immer ein Komma setzen:
print "Textstück", Variable, "Textstück"

AUFGABEN

14. Mit print 3+4 gibt dir Python einfach das Resultat 7 aus. Schrei-
be ein Programm, das nicht nur das Resultat berechnet und ausgibt,
sondern auch die Rechnung auf den Bildschirm schreibt: 3+4 = 7

15. Du hast bereits ein Programm gesehen, um eine Zeitangabe von Se-
kunden in Stunden, Minuten und Sekunden umzurechnen (z. B. 17200 →
20 5200 ). Diese erste Version hat aber einfach drei Zahlen ausgegeben. Er-
gänze das Programm jetzt so, dass die Ausgabe mit Einheiten erfolgt:
4 Stunden, 15 Minuten, 22 Sekunden

16. Verwende den Trick mit der Ganzzahldivision durch 1, um zu einer

beliebigen (gebrochenen) Zahl anzugeben, zwischen welchen zwei na-
türlichen Zahlen sie liegt. Die Ausgabe sähe dann zum Beispiel so aus:
14.25 liegt zwischen 14.0 und 15.0.

17.∗ Ascii-Art ist die Kunst, nur mit den Buchstaben und Zeichen des
Computers Bilder darzustellen2 . Verwende print, um solche Ascii-Art-
Bilder zu «zeichnen», z. B. die Eule:
______ __ __ __ ______
.___. / ___/ / / / / / / / ___/
{o,o} / __/ / / / / / / / __/
/)__) / /__ / /__/ / / /___ / /__
-’-’- /_____/ /______/ /_____/ /_____/

2 vgl. [Link]

c 2016, Tobias Kohn

48 KAPITEL 3. RECHNEN MIT PYTHON

5 Potenzen, Wurzeln und die Kreiszahl

Lernziele In diesem Abschnitt lernst du:

. Potenzen und Quadratwurzeln auszurechnen.
. Die Kreiszahl π anzuwenden.

Einführung Natürlich kannst du eine Potenz wie 35 in Python aus-

rechnen, indem du sie als Multiplikation ausschreibst: 35 = 3 · 3 · 3 · 3 · 3.
Python kann aber Potenzen auch direkt berechnen und hat dafür einen
eigenen Operator: **. Für 35 gibst du also 3**5 ein. print 3**5 liefert
somit wie erwartet 243.

Auch das Gegenstück zu den Potenzen, die Wurzel, lässt sich mit Py-
thon berechnen. Für die Quadratwurzel gibt es dafür die Funktion sqrt
(engl. square root). Die Funktion sqrt ist in einem «Erweiterungspack»,
einem sogenannten Modul definiert, und zwar im «math»-Modul. Bevor
du also mit sqrt eine Wurzel berechnen kannst, musst du sie aus dem
math-Modul laden:
from math import *

Das math-Modul ist viel zu umfangreich, um alle Funktionen hier zu

besprechen. Neben den Funktionen gibt es aber noch eine nützliche
Konstante, die in diesem Modul definiert ist: Die Kreiszahl π als pi.

Das Programm Das folgende Programm berechnet ausgehend vom

Radius r das Volumen einer Kugel. Die Formel dazu lautet:
4 3
VKugel = πr
3
√
In unserem Beispiel setzen wir den Radius auf r = 2.
1 from math import *
2
3 radius = sqrt(2)
4 volumen = 4/3 * pi * radius**3
5
6 print round(volumen, 2)

Auf der Zeile 1 wird wie oben angekündigt das Modul math geladen.
Damit lässt sich auf Zeile 4 das Kugelvolumen berechnen, das schliess-
lich auf Zeile 6 ausgegeben wird. Bei der Ausgabe wird das Volumen
mit dem Befehl round(Zahl, Anzahl_Stellen) auf zwei Nachkom-
mastellen gerundet.

c 2016, Tobias Kohn

3.5. POTENZEN, WURZELN UND DIE KREISZAHL 49

Die wichtigsten Punkte Potenzen berechnest du mit **, z. B. 5**2

2
für 5 .
√
Für die Quadratwurzel x gibt es die Funktion sqrt(x) im math-
Modul. Ebenfalls in diesem math-Modul ist die Kreiszahl π als pi defi-
niert. Bevor du die Quadratwurzel berechnen oder π verwenden kannst,
musst du sie aus dem Modul laden:
from math import *

Mit round(Zahl, Anzahl_Stellen) wird eine Zahl auf die angegebe-

ne Anzahl Stellen gerundet. Im Gegensatz zu sqrt und pi kennt Python
die round-Funktion auch ohne das math-Modul zu laden.

AUFGABEN

18. Die Kreiszahl π lässt sich zwar nicht genau angeben. Es gibt aber
eine Reihe von Brüchen und Wurzelausdrücken, um π anzunähern. Ei-
nige davon sind:
r √

√ √ √ 63 17 + 15 5
q
22 355
π≈ , , 2 + 3, 7 + 6 + 5, √

7 113 25 7 + 15 5

Berechne diese Näherungswerte mit Python und vergleiche sie mit π.

Auf wie viele Stellen stimmen die Werte jeweils?

19. Der goldene Schnitt ist ein Verhältnis, das in der Kunst und Ar-
chitektur gerne√verwendet wird. Zeige numerisch, dass der goldene
5+1
Schnitt a : b = die Eigenschaft b : a = a : b − 1 erfüllt.
2
20. Nach dem Satz des Pythagoras gilt für die drei Seiten a, b und c
eines rechtwinkligen Dreiecks a2 + b2 = c2 . Berechne mit Python für
die zwei Katheten a = 48 und b = 55 die Hypotenuse c.

21.∗ Schreibe ein Programm, mit dem du Winkel aus dem Gradmass ins
Bogenmass umrechnen kannst. (Genauigkeit: 3 Nachkommastellen)
Zur Erinnerung: Das Bogenmass entspricht der Bogenlänge des entspre-
chenden Sektors auf dem Einheitskreis.

c 2016, Tobias Kohn

50 KAPITEL 3. RECHNEN MIT PYTHON

6 Variablenwerte ändern

Lernziele In diesem Abschnitt lernst du:

. Den Wert einer Variable zu verändern.
. Variablen in Schleifen zu brauchen.

Einführung Eine Variable steht für einen Wert bzw. eine Zahl. Mit
der Zuweisung x = 3 sagst du dem Computer, dass die Variable x für
den Wert 3 steht. Aber: Variablen können ihren Wert im Laufe des Pro-
gramms ändern! Damit kannst du die gleiche Rechnung für verschiede-
ne Zahlen durchführen.

Erinnerst du dich an die Schleifen aus dem Kapitel über Turtle-Grafik?

Bei einer Schleife wird ein Programmteil mehrmals hintereinander aus-
geführt. Mit der Technik aus diesem Abschnitt kannst du bei jedem
Durchgang (Wiederholung) der Schleife den Wert deiner Variablen än-
dern. Darin liegt die Stärke dieser Technik.

Das Programm (I) Dieses erste kurze Programm gibt untereinander

die Quadratzahlen von 1 bis 100 aus. Bei jedem Durchgang der Schleife
wird in Zeile 3 zuerst der Wert von x um 1 erhöht. In Zeile 4 wird dann
das Quadrat von x ausgegeben.
1 x = 0
2 repeat 10:
3 x += 1
4 print x*x

Es lohnt sich, den Ablauf dieses Programms mit dem Debugger zu beob-
achten. Klicke dazu auf den Käfer oben im Editorfenster. Wenn du jetzt
das Programm startest, dann kannst du im Debugfenster beobachten,
wie sich der Wert von x ändert.

Das Programm (II) Das zweite Programm schreibt die Quadratzah-

len nicht einfach auf den Bildschirm, sondern zählt sie zusammen. Auch
das geschieht wieder mit einer Variable: summe.
1 x = 0
2 summe = 0
3 repeat 10:
4 x += 1
5 summe += x*x
6 print summe

c 2016, Tobias Kohn

3.6. VARIABLENWERTE ÄNDERN 51

Verwende auch hier den Debugger, um den Programmablauf genau zu

verfolgen und sicherzustellen, dass du die einzelnen Anweisungen und
Schritte verstehst.

Die wichtigsten Punkte Du kannst den Wert einer Variable während

des Programms ändern, indem du etwas hinzuzählst, abziehst oder mit
einer Zahl multiplizierst bzw. dividierst. Dazu verwendest du die Ope-
ratoren +=, -=, *=, /= sowie //= und %=. Die folgende Codezeile ver-
dreifacht den Wert der Variablen a:
a *= 3

Diese Technik brauchst du vor allem im Zusammenhang mit Schleifen,

etwa um alle Zahlen in einem bestimmten Bereich durchzugehen.

AUFGABEN

22. Verwende *=, um den Wert einer Variablen bei jedem Schritt zu ver-
doppeln und lass dir damit alle Zweierpotenzen (2, 4, 8, . . .) bis 210 =
1024 ausgeben.

23. Lass dir vom Computer die ersten 20 (a) geraden, (b) ungeraden
Zahlen ausgeben.

24. Lass dir vom Computer alle natürlichen Zahlen von 1 bis 100 zu-
sammenzählen und bestätige, dass das Resultat 5050 ist.

25. Schreibe ein Programm, das alle natürlichen Zahlen von 1 bis 10
multipliziert und das Resultat 3 628 800 auf den Bildschirm schreibt.

26. Bilde mit dem Computer die Summe der ersten n Stammbrüche:

1 1 1 1 1
1+ + + + + ··· +
2 3 4 5 n
Probiere aus: Wie gross muss das n sein, damit die Summe grösser ist
als 5?

27.∗ Berechne die Summe der ersten 10 000 Stammbrüche einmal von
1
«vorne» und einmal von «hinten» (also 1+ 21 +. . . bzw. 10000 1
+ 9999 +. . .).
Wie gross ist der Unterschied zwischen den beiden Summen?

c 2016, Tobias Kohn

52 KAPITEL 3. RECHNEN MIT PYTHON

7 Wiederholung mit Variation

Lernziele In diesem Abschnitt lernst du:

. Das Verhalten der Turtle in einer Schleife zu variieren.

Einführung Eine Schleife, in der du den Wert einer Variable änderst

ist ein sehr wichtiges und mächtiges Werkzeug. In diesem Abschnitt
verwendest du das Konzept, um das Verhalten der Turtle bei jedem
Durchgang einer Schleife leicht zu variieren. Du kannst zum Beispiel
bei jedem Durchgang der Schleife die Farbe oder die Länge der Strecke
ändern.

Das Programm In diesem Programm zeichnet die Turtle eine Kette

von 10 farbigen Punkten. Dazu verwenden wir die Funktion makeColor
zum Erzeugen der Farben. Der erste Parameter "rainbow" gibt an, dass
wir eine Regenbogenfarben erzeugen möchten. Als zweiten Parameter
gibst du dann einen Wert zwischen 0.0 und 1.0 an, der die Farbe im
Spektrum angibt, z. B. makeColor("rainbow", 0.69) für «gelb».
1 from gturtle import *
2 makeTurtle()
3
4 penUp()
5 i = 0.05
6 repeat 10:
7 farbe = makeColor("rainbow", i)
8 setPenColor(farbe)
9 dot(20)
10 forward(20)
11 i += 0.1
12 hideTurtle()

Beim Befehl dot(durchmesser) zeichnet die Turtle übrigens einen Punkt

mit dem angegebenen Durchmesser an der aktuellen Position. Auch
dann, wenn der Stift gerade «oben» ist wie in diesem Beispiel.

Die wichtigsten Punkte In sehr vielen Problemstellungen musst du

in einer Schleife Werte durchzählen. Das machst du immer mit dem
Schema:
VARIABLE = STARTWERT
repeat ANZAHL:
CODE
VARIABLE += AENDERUNG

c 2016, Tobias Kohn

3.7. WIEDERHOLUNG MIT VARIATION 53

Je nach Situation verwendest du anstelle von += auch z. B. -= oder *=.

AUFGABEN

28. Ändere das Programm so ab, dass die Turtle 20 Punkte horizon-
tal (waagrecht) zeichnet. Die Variable i soll also nacheinander 20 ver-
schiedene Werte zwischen 0.0 und 1.0 annehmen.

29. (a) Ersetze in Zeile 7 im Programm das "rainbow" durch ein

"gray" und beobachte, was dabei passiert. Welche Werte muss
die Variable i haben, damit die Farbe «schwarz» bzw. «weiss» ent-
steht?
(b) Ersetze die Zeile 5 durch i = 0 und Zeile 11 durch i += 1. Er-
zeuge dann die Farbe in Zeile 7 mit:
farbe = makeColor("gray", i % 2)
Was bewirkt der Ausdruck i % 2 in den einzelnen Schleifendurch-
gängen? Was für ein Muster zeichnet die Turtle hier?

30. Lass die Turtle eine Kette von immer kleiner werdenden Punkten
zeichnen, die sich alle berühren.

31. Zeichne mit der Turtle eine «sechseckige» Spirale. Dazu zeichnest
du ein Sechseck und vergrösserst bei jedem Durchgang der Schleife die
Länge der Seite um 2 Pixel (Abbildung 3.1(a)).

Abbildung 3.1: Verschiedene Turtle-Figuren.

32.∗ Lass die Turtle eine Zick-Zack-Linie bzw. Treppe zeichnen. Dazu
dreht sich die Turtle in jedem Schleifendurchgang entweder nach links
oder rechts. Hinweis: Die Turtle dreht sich auch dann nach rechts, wenn
der Winkel in left negativ ist (Abbildung 3.1(b)).

33.∗ Eine kleine Herausforderung: Lass die Turtle die verschachtelten

Quadrate in der Abbildung 3.1(c) zeichnen.

c 2016, Tobias Kohn

54 KAPITEL 3. RECHNEN MIT PYTHON

8 Fallunterscheidung

Lernziele In diesem Abschnitt lernst du:

. Mit dem Computer zwischen verschiedenen Fällen zu unterscheiden
und dadurch auch Spezialfälle zu berücksichtigen.
. Programmcode nur in bestimmten Situationen ausführen zu lassen.

Einführung Ein Programm soll nicht immer alle Befehle der Rei-
he nach durcharbeiten, sondern manchmal eine Auswahl treffen und
gewisse Befehle nur ausführen, wenn auch die Voraussetzungen dafür
gegeben sind. In anderen Worten: Das Programm muss verschiedene
Fälle unterscheiden können und dabei auch Spezialfälle berücksichti-
gen.

Stell dir z. B. vor, dein Programm soll die Wurzel einer Zahl x ziehen.
Das geht nur, wenn die Zahl x nicht negativ ist! Es hat also Sinn, vor
dem Wurzelziehen den Wert von x mit if zu überprüfen:
if x >= 0:
Wurzel ziehen

Mit if hast du also beim Programmieren die Möglichkeit, auf spezielle

Situationen gezielt zu reagieren. Dazu braucht if immer eine Bedin-
gung, um entscheiden zu können, ob diese Situation wirklich eintrifft.

Das Programm Woran erkennst du, ob eine Zahl eine Quadratzahl

ist? Und wie programmierst du den Computer so, dass er Quadratzah-
len erkennt? In diesem Programm hier haben wir folgende Idee ver-
wendet: Wenn du die Wurzel einer Quadratzahl ziehst, dann sind die
Nachkommastellen alle Null.

Der ganze Trick funktioniert aber nur, wenn die Zahl nicht-negativ ist.
Von negativen Zahlen können wir keine Wurzeln ziehen und das Pro-
gramm würde abstürzen.
1 from math import *
2 zahl = 74
3 if zahl >= 0:
4 wurzel = sqrt(zahl)
5 kommateil = wurzel % 1
6 if kommateil == 0.0:
7 print "Zahl ist eine Quadratzahl."
8 if kommateil != 0.0:

c 2016, Tobias Kohn

 3.8. FALLUNTERSCHEIDUNG 55

9 print "Zahl ist keine Quadratzahl."

10 if zahl < 0:
11 print "Negative Zahlen sind nie Quadrate."

Ändere den Anfangswert zahl = 74 in Zeile 2 ab und probiere ver-

schiedene Werte aus. Mache dich so soweit mit dem Programm ver-
traut, dass du die if-Struktur wirklich verstehst!

Die wichtigsten Punkte Die if-Struktur hat immer eine Bedingung

und darunter Programmcode, der eingerückt ist. Dieser eingerückte Co-
de wird nur dann ausgeführt, wenn die Bedingung bei if erfüllt ist.
Ansonsten überspringt Python den eingerückten Code.
if Bedingung:
Code, der nur ausgeführt wird,
Warum braucht es bei Ver- wenn die Bedingung wahr ist.
gleichen ein doppeltes Gleich-
heitszeichen? Weil das einfa-
Die Bedingung ist meistens ein Vergleich. Dabei ist speziell, dass du
che Gleichheitszeichen für Py- zwei Gleichheitszeichen brauchst, um zu prüfen, ob zwei Werte gleich
thon immer eine Zuweisung sind!
ist. x = 3 heisst also in je-
dem Fall, die Variable x soll x == y gleich x != y ungleich
den Wert 3 haben. x < y kleiner als x >= y grösser oder gleich
if x = 3 bedeutet für Py-
x > y grösser als x <= y kleiner oder gleich
thon übersetzt: «Die Variable x
hat jetzt den Wert 3 und falls
ja, dann. . . ». Das hat nicht
wirklich Sinn!

AUFGABEN

34. Schreibe ein Programm, das überprüft, ob eine Zahl gerade ist und
entsprechend «gerade» oder «ungerade» auf den Bildschirm schreibt.

35. Schreibe ein Programm, das überprüft, ob ein gegebenes Jahr ein
Schaltjahr ist. Achte darauf, dass dein Programm auch mit vollen Jahr-
hunderten (1600, 1700, etc.) richtig umgehen kann. Mit der Einfüh-
rung des gregorianischen Kalenders 1582 wurde die Schaltjahrregelung
nämlich so ergänzt, dass von den vollen Jahrhunderten nur diejenigen
Schaltjahre sind, deren erste zwei Ziffern durch 4 teilbar sind.

36. Schreibe ein Programm, das zu einer Zahl alle Teiler sucht und
ausgibt. Verwende dazu eine Schleife. In dieser Schleife prüfst du mit
der «Division mit Rest» alle möglichen Teiler durch und schreibst diese
möglichen Teiler auf den Bildschirm, wenn der Rest Null ist.

c 2016, Tobias Kohn

56 KAPITEL 3. RECHNEN MIT PYTHON

9 Alternativen

Lernziele In diesem Abschnitt lernst du:

. Bei einer if-Bedingung auch eine Alternative anzugeben.

Einführung Mit if kontrollierst du, ob ein bestimmtes Stück in dei-

nem Programmcode ausgeführt werden soll oder nicht. Das haben wir
im letzten Abschnitt verwendet, um zu unterscheiden, ob eine Zahl po-
sitiv oder negativ ist. Für eine solche Unterscheidung von zwei Alterna-
tiven gibt es in Python eine Kurform: Das else.

else heisst übersetzt «andernfalls» und ersetzt das zweite if. Die bei-
den Codebeispiele hier sind absolut gleichwertig:

if zahl >= 0: if zahl >= 0:

print sqrt(zahl) print sqrt(zahl)
if zahl < 0: else:
print "Zahl negativ" print "Zahl negativ"

Allerdings hat das else natürlich nur deshalb Sinn, weil sich die beiden
if links ergänzen: Entweder ist zahl >= 0 erfüllt oder dann zahl < 0.

Neben der einfachen if-Bedingung gibt es also noch eine if-else-

Unterscheidung zwischen zwei Alternativen. Das else selber hat nie
eine eigene Bedingung, sondern tritt immer dann in Kraft, wenn die
Bedingung im if zuvor nicht erfüllt war.

Das Programm Das Osterdatum ändert sich jedes Jahr und muss
daher immer neu berechnet werden. Carl Fiedrich Gauss hat für diese
Berechnung ein Verfahren (Algorithmus) vorgestellt. Weil Ostern im-
mer im März oder April sind, gibt seine Formel den Tag ab dem 1. März
an. Der Tag «32» entspricht dann einfach dem 1. April.

In unserem Programm berechnet easterday aus dem Modul tjaddons

den Ostertag. Danach müssen wir aber selber noch prüfen, ob es im
März oder April liegt. Weil wir nur zwei Alternativen haben, können wir
das mit if-else machen (Zeilen 5 und 11). In der Zeile 6 berücksichti-
gen wir noch eine Spezialregelung: Wenn das Datum auf den 26. April
fällt, dann wird Ostern auf den 19. April vorverschoben.
1 from tjaddons import *
2
3 Jahr = inputInt("Gib ein Jahr ein:")
4 Tag = easterday(Jahr)

c 2016, Tobias Kohn

3.9. ALTERNATIVEN 57

5 if Tag > 31:

6 if Tag == 57:
7 Tag = 19
8 else:
9 Tag -= 31
10 msgDlg(Tag, "April", Jahr)
11 else:
12 msgDlg(Tag, "März", Jahr)

In diesem Programm kommen zwei else vor. Dasjenige in der Zeile 8

gehört zum if in der Zeile 6 und das in der Zeile 11 gehört zum if in
der Zeile 5. Woher weiss der Computer, welches else zu welchem if
gehört? An der Einrückungstiefe! Jedes else muss genau gleich einge-
rückt sein wie das if, zu dem es gehört.

Die wichtigsten Punkte Bedingungen mit if können entweder al-

leine stehen oder zusammen mit einer Alternative. Diese wird über
else eingeleitet und wird immer dann ausgeführt, wenn die Bedingung
bei if nicht erfüllt ist und der Computer den Code von if überspringt.
if Bedingung:
Code ausführen, wenn die
Bedingung erfüllt ist.
else:
Code ausführen, wenn die
Bedingung nicht erfüllt ist.

AUFGABEN

37. Bei der Collatz-Vermutung startest du mit einer Zahl x und erzeugst
dann eine Zahlenfolge noch dem folgenden Prinzip: Wenn x gerade ist,
dann teile durch 2. Andernfalls multipliziere x mit 3 und zähle 1 dazu:

17 52 26 13 40 20 10 5 16 8 4 2 1

Schreibe ein Programm, das zu einer beliebigen Startzahl 10 Folgezah-

len nach diesem Prinzip berechnet und ausgibt.

38.∗ Du kannst die Osterformel von Gauss auch selbst programmieren.

Hier sind die Formeln dafür (natürlich kannst du in Python nicht alles
so kompakt schreiben wie hier):

k = Jahr // 100, p = k // 3, q = k // 4,
M = (15 + k - p - q) % 30, N = (4 + k - q) % 7
a = Jahr % 19, b = Jahr % 4, c = Jahr % 7,
d = (19a + M) % 30, e = (2b + 4c + 6d + N) % 7
Ostertag = 22 + d + e

c 2016, Tobias Kohn

58 KAPITEL 3. RECHNEN MIT PYTHON

10 Ein- und Ausgaben

Lernziele In diesem Abschnitt lernst du:

. Mit beliebigen Texteingaben zu arbeiten.
. Resultate und Mitteilungen in einem Fensterchen auszugeben.

Einführung Du kennst bereits inputInt und inputFloat, um Zah-

len einzugeben und kannst mit print Resultate auf den Bildschirm aus-
geben. Neu kommen inputString und msgDlg hinzu, um auch Text
eingeben und mit einem Fensterchen ausgeben zu können.

Magst du dich erinnern, dass ein Text (in Gänsefüsschen) im Program-

mieren «string» heisst? Ist es da nicht logisch, dass die Eingabefunktion
für solchen Text inputString() genannt wird? Während du also bei
inputInt und inputFloat nur Zahlen eingeben kannst, kannst du bei
inputString jeden möglichen Text eingeben, z. B. deinen Namen:

name = inputString("Wie heisst du?")

print "Hallo", name

Wäre dieses Programm aber nicht noch besser, wenn auch die Ausgabe
in einem kleinen Fensterchen erfolgen würde? Dafür gibt es msgDlg().
Es funktioniert (fast) genau gleich wie print, allerdings mit einem
wichtigen Unterschied: Bei print setzst du nie Klammern, bei msgDlg
dafür immer.
name = inputString("Wie heisst du?")
msgDlg("Hallo", name)

Das Programm Mit den neuen Ein- und Ausgaben können wir ein
kleines Quiz schreiben, das auch gleich zählt, wie viele richtige und
falsche Antworten gegeben wurden. Beachte, wie wir in Zeile 11 auch
die Zahl 169 in Gänsefüsschen setzen müssen. inputString gibt uns
nämlich auch dann einen String/Text zurück, wenn die Eingabe eigent-
lich eine Zahl wäre.
1 richtig = 0 # Anzahl richtige Antworten
2 falsch = 0 # Anzahl falsche Antworten
3
4 eingabe1 = inputString("Hauptstadt von Frankreich?")
5 if eingabe1 == "Paris":
6 richtig += 1
7 else:
8 falsch += 1

c 2016, Tobias Kohn

3.10. EIN- UND AUSGABEN 59

9
10 eingabe2 = inputString("Quadrat von 13?")
11 if eingabe2 == "169":
12 richtig += 1
13 else:
14 falsch += 1
15
16 msgDlg("Du hattest", richtig, "richtige und",
17 falsch, "falsche Antworten.")

Die wichtigsten Punkte Je nachdem, ob du als Eingabe eine ganze

Zahl, eine beliebige Zahl oder einen String/Text erwartest, verwendest
du eine andere Funktion: inputInt(), inputFloat(), inputString().

Mit msgDlg() kannst du beliebigen Text, Variablen und Zahlen in ei-

nem eigenen kleinen Fensterchen ausgeben. Auch hier kannst du mit
der Kombination \n in einem String einen Zeilenumbruch erzeugen.

AUFGABEN

39. Ändere die Zeile 10 im Beispielprogramm oben ab und verwende

inputInt anstelle von inputString. Was musst du dann noch ändern,
damit das Programm korrekt funktioniert?

40. Wenn jemand eine falsche Antwort gibt, dann lass dein Programm
die korrekte Antwort ausgeben: Falsch. Richtig wäre «Paris».

41. Erweitere dein Quiz um eigene Fragen. In den Einstellungen von

TigerJython kannst du auch das Editorfenster während der Program-
mausführung ausblenden lassen. Dann sieht man während des Quizes
nicht gleich die Antworten im Code.

42. Schreibe das Programm aus dem Abschnitt über Fallunterscheidung

(Seite 54) so um, dass du über inputInt eine Zahl eingeben kannst,
die dann daraufhin überprüft wird, ob sie eine Quadratzahl ist.

43.∗ Schreibe ein Programm, das dein Sternzeichen herausfindet. Dazu

muss man zuerst den Tag und den Monat seiner Geburt eingeben. Das
Programm antwortet dann z. B. mit «Du bist Schütze.» Tipp: Berechne
aus dem Datum zuerst den Tag im Jahr. Der «3. Februar» wäre demnach
der 34. Tag.

c 2016, Tobias Kohn

60 KAPITEL 3. RECHNEN MIT PYTHON

11 Schleifen abbrechen

Lernziele In diesem Abschnitt lernst du:

. Eine Schleife abzubrechen, bevor sie fertig ist.

Einführung Schleifen verwendest du beim Programmieren oft dazu,

um etwas zu suchen oder zu berechnen. Dabei kannst du nicht immer
genau wissen, wie oft sich die Schleife wiederholen muss, bis der Com-
puter das Ergebnis gefunden hat. Deshalb ist es manchmal sinnvoll,
eine Schleife mit break abzubrechen.

Nehmen wir als Beispiel an, der Computer soll überprüfen, ob 91 ei-
ne Primzahl ist. Dazu muss er grundsätzlich alle Zahlen von 2 bis 90
durchgehen und ausrechnen, ob sich 91 ohne Rest durch eine kleinere
Zahl teilen lässt. Nachdem der Computer aber festgestellt hat, dass 91
durch 7 teilbar ist, muss er die anderen Zahlen nicht mehr überprüfen.
Er hat die Antwort auf unsere Frage und kann daher mit der Berech-
nung aufhören.

Das Programm Das Programm fordert den Anwender in der ersten

Zeile dazu auf, eine ganze Zahl einzugeben (erinnerst du dich daran,
dass int für eine ganze Zahl steht?).

In den Zeilen 2 bis 8 prüft das Programm der Reihe nach alle möglichen
Teiler durch. Wenn die eingegebene Zahl durch einen Teiler wirklich
teilbar ist, dann wird die Schleife in Zeile 7 abgebrochen. Die Variable
teiler enthält jetzt den kleinsten Teiler der eingegebenen Zahl (ausser
1 natürlich).

Am Schluss prüfen wir, ob der gefundene Teiler kleiner ist als die Zahl
und geben entsprechend aus, dass es eine Primzahl ist oder nicht.
1 zahl = inputInt("Bitte gib eine ganze Zahl ein:")
2 teiler = 2
3 repeat zahl-1:
4 rest = zahl % teiler
5 if rest == 0:
6 break
7 teiler += 1
8
9 if teiler < zahl:
10 msgDlg(zahl, "ist durch", teiler, "teilbar!")
11 if teiler == zahl:
12 msgDlg(zahl, "ist eine Primzahl!")

c 2016, Tobias Kohn

3.11. SCHLEIFEN ABBRECHEN 61

Probiere das Programm mit verschiedenen Zahlen aus und beobachte

mit dem Debugger, wann was passiert. Achte dabei vor allem darauf,
was break bewirkt und wo das Programm nach break weiterfährt.

Die wichtigsten Punkte Schleifen wiederholen einen Programmteil

für eine feste Anzahl von Durchläufen. Mit break kannst du die Schlei-
fe aber auch vorzeitig abbrechen. Bei break fährt der Computer also
nach dem Schleifencode weiter: Er überspringt sowohl den Rest des
Schleifencodes als auch alle Wiederholungen, die noch ausstehen.

Die break-Anweisung hat nur innerhalb einer if-Bedingung Sinn, weil

die Schleife sonst sofort abgebrochen und gar nicht wiederholt würde.
repeat n:
Schleifencode
if Abbruch-Bedingung:
break
Schleifencode

AUFGABEN

44. Wie oft musst du 1.5 mit sich selbst multiplizieren, bis das Ergebnis
grösser ist als 100? Wie sieht es auf mit 1.05 . . . ?
Schreibe ein Programm, das die Antwort mit einer Schleife sucht. So-
bald 1.5n grösser ist als 100, bricht die Schleife ab und das Programm
gibt das Ergebnis aus. Mit anzahl += 1 kannst du z. B. zählen, wie oft
die Schleife tatsächlich wiederholt wird.

45. Zerlege eine Zahl in ihre Primfaktoren. Das Grundprinzip funktio-

niert ähnlich wie beim Primzahltest oben. Wenn allerdings rest == 0
ist, dann teilst du die Zahl zahl mit /= durch den Teiler. Und nur wenn
der Rest nicht Null ist, erhöhst du den Teiler um Eins (eine Zahl kann
ja auch mehrfach durch 3 teilbar sein).
Woran erkennst du, dass die Zahl fertig zerlegt ist und du die Schleife
abbrechen kannst?

46. Schreibe eine «Passwort-Schleife», die sich so lange wiederholt, bis

jemand das richtige Passwort (oder die richtige Antwort auf eine Quiz-
frage oder Rechnung) eingegeben hat.

c 2016, Tobias Kohn

62 KAPITEL 3. RECHNEN MIT PYTHON

12 Korrekte Programme

Lernziele In diesem Abschnitt lernst du:

. Dass du ein Programm immer auch daraufhin testen musst, ob es
die korrekten Ergebnisse liefert.

Einführung Zu einem fehlerfreien Programm gehören zwei Aspek-

te. Erstens musst du das Programm so schreiben, dass es der Compu-
ter auch versteht und ausführen kann. Zweitens muss dein Programm
aber auch das richtige tun bzw. bei einer Berechnung das korrekte Er-
gebnis liefern. Um diese zweite Art von Korrektheit geht es in diesem
Abschnitt.

Wie stellst du sicher, dass dein Programm korrekt ist und wirklich im-
mer das richtige Resultat liefert? Diese Frage ist gar nicht so einfach
zu beantworten und wird immernoch erforscht. Was du aber sicher tun
kannst: Teste deine Programme und zwar in möglichst verschiedenen
Situationen bzw. mit verschiedenen Eingabewerten.

Das Programm Wenn du unendlich viele Zahlen zusammenzählst,

dann wird auch das Ergebnis unendlich gross, oder? Erstaunlicherweise
nicht immer. Ein Beispiel für eine solche Summe mit endlichen Ergebnis
ist:
1 1 1 1 1 2
1− + − + − + ··· =
2 4 8 16 32 3
Du siehst sicher sofort die Struktur hinter dieser Summe:

0
1
2
3
4
5
6
− 12 + − 12 + − 12 + − 12 + − 21 + − 12 + − 12 + · · ·
Weil diese Summe unendlich lang ist, kannst du zwar nicht alles zu-
sammenzählen. Aber es reicht nur schon, z. B. die ersten hundert Sum-
manden zu nehmen und das Ergebnis auszurechnen. Genau das macht
das Programm hier.
1 i = 0
2 summe = 0
3 repeat 100:
4 summe += -1/2 ** i
5 i += 1
6 print summe

Das Programm läuft soweit einwandfrei, nur: Das Ergebnis stimmt nicht!
Es sollte 23 sein und nicht −2. Findest du heraus, wo der Fehler liegt?
Nimm vielleicht auch den Debugger zu Hilfe oder spiele mit der An-
zahl der Wiederholungen, um ein besseres Gefühl zu bekommen (die
Lösung erfährst du auf der nächsten Seite).

c 2016, Tobias Kohn

3.12. KORREKTE PROGRAMME 63

Und hier die Auflösung: Der Fehler liegt in der Zeile 4. Der Computer berechnet
bei -1/2 ** i zuerst 2**i aus und dann den Rest. Um also wirklich − 21 zu
potenzieren, braucht es Klammern: (-1/2) ** i.

Die wichtigsten Punkte Teste deine Programme immer auch dar-

auf, ob sie die korrekten Ergebnisse liefern. Beginne zuerst mit einfa-
chen Fällen, überprüfe aber immer auch möglichst schwierige, spezielle
oder sogar unmögliche Fälle. Erst dann siehst du, ob Dein Programm
wirklich funktioniert!

AUFGABEN

47. Die Lösungen einer quadratischen Gleichung ax2 +bx+c = 0 kannst

du mithilfe der Lösungsformel berechnen:
√
−b ± b2 − 4ac
x1,2 =
2a
An der Diskriminante D = b2 − 4ac siehst du jeweils, ob die Gleichung
keine (D < 0), eine (D = 0) oder zwei (D > 0) Lösungen hat.
Schreibe ein Programm, das aus den Koeffizienten a, b und c die Lösun-
gen der Gleichung berechnet. Das Programm soll für jeden Fall funktio-
nieren! Wenn die Gleichung z. B. keine Lösungen hat, dann zeigt dein
Programm auch eine entsprechende Meldung an!
Teste das Programm an folgenden Gleichungen (in Klammern sind je-
weils die Lösungen angegeben):
x2 − 10x + 21 = 0 (3, 7); 6x2 − 18x − 60 = 0 (−2, 5); 3x2 − 24x + 48 = 0
(4); 2x2 − 3x − 5 = 0 (−1, 2.5); 2x2 + 3x + 5 = 0 (–); x2 + 5x + 6.5 = 0
(–).

48. Was passiert, wenn du bei deinem Programm für den Wert von
a Null eingibst? Stelle sicher, dass dein Programm auch dann korrekt
funktioniert!

c 2016, Tobias Kohn

64 KAPITEL 3. RECHNEN MIT PYTHON

Quiz
5. Du möchtest die Rechnung 1 + 2 = 3 auf den Bildschirm aus-
geben. Welche Anweisung ist dazu die richtige?

2 a. print 1 + 2 = 3
2 b. print 1 + 2 == 3
2 c. print "1 + 2 = 3"
2 d. print "1"+"2"="3"

6. Wie prüfst du, ob die Zahl x gerade ist?

2 a. if x // 2:
2 b. if x // 2 == 0:
2 c. if x % 2:
2 d. if x % 2 == 0:

7. Welches Codestück hier wird sicher nie ausgeführt, sondern im-

mer übersprungen?
if a > 5:
if a >= 5:
#A
else:
#B
if a <= 5:
#C
else:
#D

2 a. #A 2 b. #B 2 c. #C 2 d. #D

8. Welchen Wert liefert das folgende kurze Programm?

resultat = 1
x = 1
repeat 3:
x //= 2
resultat += x
print resultat

2 a. 1.0 2 b. 1.75 2 c. 2.0 2 d. 7.0

c 2016, Tobias Kohn

 KAPITELTEST 1

1. Im folgenden Programm zeichnet die Turtle ein Bild. Zeichne das

Bild möglichst genau, ohne das Programm mit dem Computer auszu-
Der Name «foo» hat keine führen.
eigene Bedeutung und lässt
from gturtle import *
sich wohl am Besten mit
«Dings» übersetzen. In Pro- makeTurtle()
grammieranleitungen werden def foo(r):
«foo», «bar» und «baz» gerne s = 3.1415926 / 2 * r / 30
als Beispielnamen verwendet, forward(s / 2)
die keinen eigenen Sinn ha- repeat 29:
ben. In Python findest auch oft left(3)
«spam» und «egg». forward(s)
left(3)
forward(s / 2)
repeat 2:
forward(200)
left(90)
foo(200)

2. Im folgenden Programm soll die Turtle ein gleichseitiges Dreieck

zeichnen. Dabei fehlt eine Codesequenz. Welche der untenstehenden
Sequenzen kannst du dort einsetzen?
repeat 3:
forward(100)
#???#

(a) left(60) (d) repeat 4:

right(60)
(b) right(300)
(e) repeat 3:
(c) left(120) left(20)

c 2016, Tobias Kohn

66 KAPITEL 3. RECHNEN MIT PYTHON

3. Schreibe jeweils ein Turtle-Programm, das die olympischen Ringe

(links) bzw. das Pentagramm (rechts) zeichnet:

4. Mit welchen Codesequenzen wird die positive Zahl x auf 0.5 genau
gerundet ausgegeben? Die Zahl 2.3 würde also auf 2.5 gerundet.

(a) print round(x, 0.5)

(b) print round(2 * x) / 2
(c) print round(2 * x, 0) // 2
(d) print (x * 2 + 1) // 1 / 2
(e) print (x + 0.5) * 2 // 1 / 2
(f) print x + 0.25 - (x + 0.25) % 0.5

5. Schreibe ein Programm, das die ersten fünfzig Quadratzahlen zu-

sammenzählt und das Ergebnis auf den Bildschirm schreibt.

6. Ein Programmierer möchte diese Summe ausrechnen:

1 1 1 1 1 1 1
1+ + + + + + + ··· +
2 4 8 16 32 64 1024
Dazu hat er das folgende Programm geschrieben. In jeder Zeile hat
es aber einen Fehler. Finde die Fehler und korrigiere sie, so dass das
Programm richtig funktioniert.
summe == 1
1 = x
repeat 10
x //= 2
summe + x
print "summe"

c 2016, Tobias Kohn

K a p i t e l V i e r

KOORDINATENGRAFIK

Mit der Turtle kannst du im Prinzip beliebige Bilder zeichnen. Es gibt

sogar Grafiken, für die die Turtle die beste Möglichkeit darstellt, um sie
zu zeichnen. Auf der anderen Seite gibt es aber auch Fälle, in denen
andere Verfahren besser und schneller sind.

Zuerst werden wir in diesem Kapitel die Turtlegrafik und das Rechnen
mit Variablen zusammenführen. Das ist ein wichtiger Schritt, um kom-
plexere Bilder zeichnen zu können. Der Schwerpunkt dieses Kapitels
liegt dann aber auf der Grafik mit einem Koordinatensystem bis hin zu
einfachen Spielen.

Es gibt beim Programmieren eine Reihe von Grundtechniken, die du

sicher beherrschen musst. Dazu gehören Schleifen (Wiederholungen),
Variablen, Fallunterscheidungen und das Definieren eigener Befehle.
Ein wichtiges Ziel dieses Kapitels ist, dass du diese Grundtechniken so-
weit geübt hast, dass du sie vollständig verstehst und problemlos damit
umgehen kannst.

Du wirst auch sehen, dass die Beispielprogramme in diesem Kapitel

immer länger und grösser werden. Je grösser ein Programm ist, umso
wichtiger ist, dass du es mit der Definition neuer Befehle in überschau-
bare Einzelteile zerlegst und damit sinnvoll strukturierst.

In den späteren Kapiteln werden wir dann diese Grundtechniken so

ergänzen, dass du auch grössere und kompliziertere Grafiken und Spie-
le programmieren kannst. Du wirst aber sehen, dass sich dir mit den
Grundtechniken hier schon viele Möglichkeiten bieten.

c 2016, Tobias Kohn

68 KAPITEL 4. KOORDINATENGRAFIK

1 Wiederholungen der Turtle

Lernziele In diesem Abschnitt lernst du:

. Das Verhalten der Turtle in einer Schleife zu variieren, so dass sich
die Turtle z. B. abwechselnd nach links und nach rechts bewegt.
. Dass du else nicht immer durch if ersetzen kannst.

Einführung In diesem Abschnitt kehren wir zur Turtle-Grafik zurück

und wiederholen gleich die zwei wichtigsten Prinzipien: Mit def kannst
du einen neuen Befehl für die Turtle definieren. Und mit repeat n:
wird der eingerückte Programmteil n Mal wiederholt.

Zusätzlich kommt hinzu, dass du das Verhalten der Turtle auch mit Va-
riablen steuerst. In unserem Beispiel lassen wir die Turtle abwechselnd
nach links oder nach rechts gehen, indem wir den Wert einer Variablen
bei jedem Schleifendurchgang wieder ändern. In den Übungen wirst du
mit dieser Technik auch eine Spirale zeichnen.

Das Programm Das Programm beginnt damit, dass wir das Turtle-
Modul laden (importieren) und eine neue Turtle mit Fenster erzeugen.
Danach definieren wir in den Zeilen 4 bis 9 einen neuen Befehl treppe
für die Turtle. Zur Erinnerung: Mit dieser Definition macht die Turtle
noch nichts! Damit wird erst der Befehl definiert. Ganz am Schluss in
Zeile 11 sagen wir dann der Turtle, sie soll eine Treppe zeichnen, und
zwar mit einer Stufenlänge von 25 Pixeln.
1 from gturtle import *
2 makeTurtle()
3
4 def treppe(stufe):
5 winkel = 90
6 repeat 10:
7 forward(stufe)
8 right(winkel)
9 winkel *= -1
10
11 treppe(25)

An diesem Programm ist besonders, dass wir innerhalb der Schleife in

den Zeilen 6 bis 9 den Wert der Variablen winkel bei jedem Durchgäng
ändern. Durch die Multiplikation mit −1 in der Zeile 9 wechselt der
Wert von winkel immer zwischen −90 und +90 ab. Damit dreht sich
die Turtle abwechselnd nach links oder nach rechts.

c 2016, Tobias Kohn

4.1. WIEDERHOLUNGEN DER TURTLE 69

Eine Alternative Es gibt eine zweite Möglichkeit, wie du die Variable

winkel im Programm bei jedem Schleifendurchgang ändern kannst:
Mit if und else.
1 def treppe(stufe):
2 winkel = 90
3 repeat 10:
4 forward(stufe)
5 right(winkel)
6 if winkel == 90:
7 winkel = -90
8 else:
9 winkel = 90

Das hier ist übrigens ein Fall, bei dem du das else nicht durch ein
if winkel != 90: ersetzen kannst. Warum das nicht geht, ist eine
Frage in den Übungenen.

Die wichtigsten Punkte Die Turtle selber kennt zwar keine Varia-
blen. Aber du kannst beim Programmieren trotzdem geschickt Varia-
blen einsetzen, um das Verhalten der Turtle zu steuern.

AUFGABEN

1. Lass die Turtle in einer Schleife eine Spirale zeichnen, die auf einem
Rechteck beruht. Dazu dreht sich die Turtle jedes Mal um 90◦ . Dafür
geht sie bei jedem Mal etwas weiter geradeaus (z. B. 5 Pixel mehr),
bevor sie sich wieder dreht.

2.∗ Vergrössere die Seitenlängen der Spirale jedes Mal um 5 %.

3. Warum kannst du in der zweiten Variante des Programms oben das

if/else nicht (!) durch folgenden Code ersetzen? Warum funktioniert
das nicht wie gewünscht?
if winkel == 90:
winkel = -90
if winkel == -90:
winkel = 90
Hinweis: Es kann hilfreich sein, wenn du das Programm mit dem De-
bugger verfolgst.

4. Lass die Turtle mit der Technik aus diesem Abschnitt eine gestrichel-
te Linie zeichnen:

5.∗ Zeichne mit der Turtle eine drei- oder vierfarbige Linie nach dem
Prinzip der gestrichelten Linie. Die Farben wechseln sich also immer ab:
Gelb, rot, blau, gelb, rot, blau, . . .

c 2016, Tobias Kohn

70 KAPITEL 4. KOORDINATENGRAFIK

2 Farben mischen

Lernziele In diesem Abschnitt lernst du:

. Selber Farben zu mischen und damit Farbverläufe zu zeichnen.

Einführung Wie füllst du am besten ein Rechteck mit einer Farbe

aus? Eine Möglichkeit zeigt dir das Bild nebenan: Die Turtle baut das
Rechteck Zeilenweise auf. Zwischen den Zeilen muss die Turtle natür-
lich immer ein Pixel nach oben gehen.

Ein Rechteck ausfüllen, das konntest du aber auch schon vorher. Jetzt
variieren wir das Programm aber leicht, indem die Turtle jede Zeile mit
einer anderen Farbe zeichnen soll. Mit dieser Technik kannst du sehr
einfach schöne Farbverläufe erzeugen. Allerdings reichen dafür wieder-
um die üblichen Farben nicht aus: Du musst deine Farben schon selber
mischen. Das machst du mit der Funktion makeColor(R, G, B). Hier
stehen R für rot, G für grün und B für blau. Jeder dieser Anteile ist ein
Wert zwischen 0.0 und 1.0, zum Beispiel:

blau (0.0, 0.0, 1.0) dunkelblau (0.0, 0.0, 0.5)

gelb (1.0, 1.0, 0.0) grün (0.0, 0.5, 0.0)
hellblau (0.4, 0.6, 1.0) rot (1.0, 0.0, 0.0)
schwarz (0.0, 0.0, 0.0) türkis (0.0, 0.5, 0.6)
violett (0.5, 0.0, 0.5) weiss (1.0, 1.0, 1.0)
Der Computer kann bei jedem
Farbanteil rund 250 verschie-
Im Programm schreibst du dann setPenColor( makeColor(...) )
dene Werte unterscheiden, was
mit den entsprechenden Farbanteilen. Wichtig ist, dass du auch dann dann etwa 16 Millionen mög-
die Nachkommastellen angibst, wenn sie Null sind. Also 0.0 und nicht liche Farben ergibt.
einfach 0.

Das Programm Dieses Programm zeichnet ein Rechteck mit einem

blauen Farbverlauf. Dafür lassen wir die Variable i von 0.01 bis 1.00
laufen und setzen den Blauanteil jeweils auf i.
1 from gturtle import *
2 makeTurtle()
3 hideTurtle()
4
5 right(90)
6 i = 0
7 winkel = 90
8 repeat 100:

c 2016, Tobias Kohn

4.2. FARBEN MISCHEN 71

9 i += 0.01
10 setPenColor( makeColor(0.0, 0.0, i) )
11 forward(150)
12 left(winkel)
13 forward(1)
14 left(winkel)
15 winkel *= -1

Die wichtigsten Punkte Mit makeColor(R, G, B) kannst du dir

selber alle Farben mischen, die der Computer überhaupt kennt. Die drei
Parameter R, G und B stehen für rot, grün bzw. blau und müssen ge-
brochene Zahlen (floats) zwischen 0.0 und 1.0 sein.

AUFGABEN

6. Das Rechteck im Beispielprogramm ist 150 Pixel breit und 100 Pixel
hoch. Ändere das so ab, dass es neu 240 Pixel breit und 50 Pixel hoch
ist. Die oberste Linie sollte immer noch ein kräftiges Blau sein.

7. Ändere die Farben des Farbverlaufs z. B. von rot nach gelb.

8. Links oben hat das Rechteck einen «Zipfel»: Die Turtle zeichnet da
einen einzelnen Pixel auf das Rechteck drauf. Warum macht sie das
(welche Zeilen im Programm sind dafür verantwortlich)? Und wie kannst
du das beheben bzw. verhindern?

9. Im Beispielprogramm steht in Zeile 5 ein right(90). Welche Be-

deutung hat diese Drehung? Was passiert, wenn du diese Winkelan-
gabe änderst, etwa zu right(30)? Tipp: Ein setPenWidth(2) an der
richtigen Stelle kann das Bild retten.

10. Definiere einen neuen Befehl farbVerlauf(breite, hoehe), der

ein Rechteck mit einem Farbverlauf zeichnet. Dabei lassen sich die Brei-
te und die Höhe als Parameter angeben.

11.∗ Zeichne mit der Turtle einen Farbkreis mit den drei Grundfarben
rot, grün und blau. Zwischen diesen Grundfarben gibt es einen flies-
senden Übergang. Verwende setPenWidth(5), damit man die Farben
auch gut sieht.

12. Mit dot(durchmesser) zeichnet die Turtle an der aktuellen Positi-

on einen Punkt mit dem angegebenen Durchmesser.
Zeichne einen «runden Farbverlauf», indem du dot() verwendest und
immer kleiner werdende Punkte an der gleichen Stelle zeichnest.

13.∗ Wenn du die Turtle bei einem runden Farbverlauf langsam nach
links oben wandern lässt, dann entsteht der Eindruck einer Kugel. Zeich-
ne eine solche Kugel.

c 2016, Tobias Kohn

72 KAPITEL 4. KOORDINATENGRAFIK

3 Mit dem Zufall spielen

Lernziele In diesem Abschnitt lernst du:

. Eine ganzzahlige Zufallszahl aus einem gegebenen Bereich zu zie-
hen.

Einführung Der Zufall spielt in der Informatik eine erstaunlich gros-

se Rolle. Zwei Beispiele wären Simulationen und Computerspiele, bei
denen sich eine Figur zufällig verhält. Wir verbinden sogar beides und
präsentieren als Musterprogramm eine Simulation für die brownsche
Bewegung, bei der die Turtle zufällig umherirrt.

Die einzelnen Teilchen in einem Gas oder in einer Flüssigkeit wandern

immer ein wenig umher. Dabei stossen sie immer wieder mit anderen
Teilchen zusammen und ändern daher plötzlich ihre Richtung. Diese
zufällige Bewegung heisst «brownsche Bewegung». Und die können wir
mit der Turtle hervorragend simulieren. Weil wir nur eine einzige Turtle
als «Teilchen» haben, tun wir einfach so, als würde sie mit anderen
zusammenstossen und ändern alle paar Pixel die Richtung.

Das Programm In diesem Programm lassen wir die Turtle ziemlich

ziellos umherirren. Sie geht immer 35 Pixel gerauseaus und dreht sich
dann um einen zufälligen Winkel. Für diesen zufälligen Winkel verwen-
den wir die Funktion randint (Zeile 7). Sie zieht eine zufällige ganze
Zahl im angegebenen Bereich (bei uns also zwischen 1 und 360).

In den Zeilen 8 und 10 verwenden wir einen Trick, um die Grafik et-
was schneller zu machen: Bevor wir die Turtle jeweils drehen, machen
wir sie unsichtbar mit hideTurtle und nach der Drehung wird sie mit
showTurtle wieder sichtbar. Damit dreht sich die Turtle ohne die übli-
che Animation und ist dadurch viel schneller.
1 from gturtle import *
2 from random import randint
3
4 makeTurtle()
5 repeat 100:
6 forward(35)
7 winkel = randint(1, 360)
8 hideTurtle()
9 left(winkel)
10 showTurtle()

c 2016, Tobias Kohn

4.3. MIT DEM ZUFALL SPIELEN 73

Bevor wir die Funktion randint verwenden können, müssen wir sie
aus dem Modul random laden (importieren).

Die wichtigsten Punkte Im Modul random ist die Funktion randint

definiert. Diese Funktion zieht eine ganzzahlige Zufallszahl aus einem
festen Bereich. Diese Zufallszahl wirst du fast immer zunächst in einer
Variablen ablegen.
from random import randint
zufaellige_variable = randint(0, 10)

AUFGABEN

14. Ändere das Programm aus dem Text so ab, dass auch die Länge der
Strecke, die die Turtle geht, zufällig ist. Die Turtle soll also nicht immer
35 Pixel, sondern einen zufälligen Wert zwischen 25 und 50 vorwärts
gehen.

15. Mit dem Befehl dot(durchmesser) zeichnet die Turtle an der aktu-
ellen Position einen (runden) Punkt mit dem angegebenen Durchmes-
ser. Das funktioniert auch, wenn der Farbstift «oben» ist und die Turtle
eigentlich keine Spur zeichnet.
Ergänze das Programm aus dem Text damit so, dass die Turtle bei jeder
Drehung noch einen Punkt mit Radius 5 zeichnet.

16. Definiere einen Befehl zufallsfarbe, der eine zufällige Farbe setzt.
Dazu ziehst du zuerst eine Zufallszahl zwischen z. B. 1 und 4. Danach
schreibst du eine Reihe von if-Bedingungen, nach dem Muster:
if zahl == 1:
setPenColor("red")
Zeichne dann damit ein Quadrat, bei dem jede Seite eine (andere) zu-
fällige Farbe hat.

17. Schreibe mit dot ein Programm, das zufällige Punkte auf den Bild-
schirm zeichnet. Natürlich kannst du auch den Radius der Punkte zu-
fällig ziehen lassen. Verwende deinen Befehl zufallsfarbe aus der
letzten Aufgabe, damit die Punkte auch verschiedene Farben haben.

18.∗ Schreibe ein Programm, das einen Würfelwurf simuliert, indem es

eine zufällige Zahl zwischen 1 und 6 zieht. Lass dein Programm dann
50 Mal den «Würfel werfen» und abbrechen, wenn es das erste Mal eine
Sechs «gewürfelt» hat.
Dein Programm soll jede gewürfelte Zahl mit print auf den Bildschirm
schreiben und am Schluss ausgeben, wie oft es würfeln musste, bis eine
Sechs kam.

c 2016, Tobias Kohn

74 KAPITEL 4. KOORDINATENGRAFIK

4 Turtle mit Koordinaten

Lernziele In diesem Abschnitt lernst du:

. Die Turtle an eine bestimmte Position zu setzen oder eine Linie zu
einem vorgegebenen Punkt hin zu zeichnen.

Einführung Bis jetzt hast du die Turtle immer relativ zu ihrer aktu-
ellen Position gesteuert, indem du Winkel und Längen angegeben hast.
Je nach Grafik ist es aber praktischer, die Turtle direkt an eine bestimm-
te, absolute Stelle im Grafikfenster zu setzen, ohne dass du dafür zuerst
ausrechnen musst, in welchem Winkel und wie weit sie gehen soll.

Für diese absolute Steuerung (d. h. unabhängig von der aktuellen Posi-
tion und Richtung der Turtle) verwenden wir ein Koordinatensystem,
wie du es auch aus der Mathematik kennst. Du gibst also die Positionen
innerhalb des Fensters mit einer x- und einer y-Koordinate an (siehe
Abb. 4.1). Die Fenstermitte hat dabei immer die Koordinaten (0, 0).

Die zwei wichtigsten Befehle hier sind setPos(x, y) um die Turtle

direkt an eine bestimmte Stelle zu setzen, und moveTo(x, y) um von
der aktuellen Position aus eine Linie bis zum Punkt (x, y) zu zeichnen.

Abbildung 4.1: Das Koordinatensystem mit drei eingezeichneten Punkten.

Das Programm In diesem Programm zeichnet die Turtle zuerst die

Koordinatenachsen zur Orientierung. Dabei nutzen wir aus, dass du die
Turtle mit setPos(0, 0) in die Mitte zurücksetzen kannst. Anschlies-
send zeichnet die Turtle noch ein rotes Dreieck. Das spezielle an diesem
roten Dreieck ist, dass die drei Eckpunkte mit Koordinaten vorgegeben
sind: Wir müssen uns also dieses Mal nicht darum kümmern, wie gross
die Winkel oder Seitenlängen des Dreiecks sind!
1 from gturtle import *
2 makeTurtle()
3

c 2016, Tobias Kohn

4.4. TURTLE MIT KOORDINATEN 75

4 # Die Koordinatenachsen zeichnen

5 setPenColor("black")
6 repeat 4:
7 forward(250)
8 setPos(0, 0)
9 left(90)
10
11 # Das rote Dreieck zeichnen
12 setPenColor("red")
13 setPenWidth(3)
14 setPos(160, 130)
15 moveTo(-120, -10)
16 moveTo(50, -180)
17 moveTo(160, 130)

Die wichtigsten Punkte Die Turtle kann sich entweder relativ zu

ihrer aktuellen Position bewegen oder zu einem festen Punkt (x, y) im
Koordinatensystem gehen. Mit setPos(x, y) setzst du dabei die Turtle
direkt an den entsprechenden Punkt und mit moveTo(x, y) zeichnet
die Turtle eine Linie dahin.

Du kannst die relative und die absolute Steuerung nach Belieben mi-
schen. Dazu gibt es noch einen weiteren Befehl, der nützlich sein dürf-
te: Mit heading(winkel) kannst du die Turtle ausrichten. Ein Winkel
von 0 entspricht «gerade nach oben», 90 «direkt nach rechts», etc.

AUFGABEN

19. Definiere zwei neue Befehle xline(y) und yline(x). Bei yline
zeichnet die Turtle eine vertikale (senkrechte) Linie über die ganze
Fensterhöhe an der angegebnen x-Position. Bei xline(y) zeichnet die
eine horizontale (waagrechte) Linie über die ganze Fensterbreite.

20. Nutze die beiden Befehle xline und yline aus der letzten Aufga-
be, um ein Gitter über das ganze Fenster zu zeichnen und zwar sollen
die einzelnen Linien 50 Pixel voneinander entfernt sein.

21. Zeichne mit der Turtle noch einmal die Figuren aus der Abbildung
2.1 auf Seite 11. Verwende dieses Mal aber nur absolute Koordinaten,
d. h. setPos(x, y) und moveTo(x, y).

22. Definiere einen Befehl rectangle(x1, y1, x2, y2), mit dem die
Turtle ein Rechteck mit den Eckpunkten A(x1 , y1 ), B(x1 , y2 ), C(x2 , y2 )
und D(x2 , y1 ) zeichnet.

c 2016, Tobias Kohn

76 KAPITEL 4. KOORDINATENGRAFIK

5 Koordinaten abfragen

Lernziele In diesem Abschnitt lernst du:

. Herauszufinden, wo sich die Turtle im Moment befindet.

Einführung In diesem Abschnitt geht es darum, die Turtle nicht nur

auf einen speziellen Punkt zu setzen, sondern auch herauszufinden,
wo sich die Turtle im Moment befindet. Dazu gibt es zwei Funktionen
getX() und getY() für die x- und die y-Koordinaten.

Das Programm (I) Das Grundprogramm hier füllt den mittleren Teil
des Bildschirms mit Punkten: Dazu zieht es für die x- und die y-Koordinate
Zufallszahlen im Bereich zwischen −200 und 200.
1 from gturtle import *
2 from random import randint
3
4 def zufallsPunkt():
5 radius = randint(4, 7)
6 dot(radius * 2)
7
8 makeTurtle()
9 setColor("black")
10 setFillColor("black")
11 fill()
12 repeat 1000:
13 x = randint(-200, 200)
14 y = randint(-200, 200)
15 setPos(x, y)
16 zufallsPunkt()

Das Programm (II) Ausgehend vom Grundprogramm ersetzen wir

den Befehl zufallsPunkt durch eine Alternative. Hier ist der Radius
nicht zufällig, sondern hängt von der Höhe des Punktes ab. Je weiter
oben der Punkt liegt, umso grösser wird der Radius.
def zufallsPunkt():
y = getY()
radius = (y + 200) // 40
dot(radius * 2)

Die Koordinaten liegen alle im Bereich zwischen −200 und 200, weil
wir die Zufallszahlen im Hauptprogramm oben aus diesem Bereich zie-
[Link] der Radius nicht negativ sein kann, addieren wir 200 und
teilen das Ergebnis dann durch 40. Damit liegt der Radius immer im
Bereich von 0 bis 10.

c 2016, Tobias Kohn

4.5. KOORDINATEN ABFRAGEN 77

Das Programm (III) In dieser dritten Variante kehren wir wieder zu

Punkten mit einem zufälligen Radius zurück. Dafür setzen wir die Farbe
in Abhängigkeit von der x-Koordinate des Punkts.
def zufallsPunkt():
x = getX() + 200
clr = makeColor("rainbow", x / 400)
setPenColor(clr)
radius = randint(4, 7)
dot(radius * 2)

Die Funktion makeColor("rainbow", farbwert) gibt eine «Regenbo-

genfarbe» zurück. Der farbwert muss dazu zwischen 0.0 und 1.0 lie-
gen.

AUFGABEN

23. Ändere die Version (II) so ab, dass (a) die Radien der Punkte im
Bereich zwischen 2 und 18 liegen, (b) die grossen Punkte unten liegen
und die kleinen Punkte oben.

24. Schreibe den Befehl zufallsPunkt() so um, dass die Punkte in

jedem Quadranten eine andere Farbe haben. Die Punkte rechts oben
sind z. B. rot, die Punkte links oben blau, etc.

25.∗ Ändere die Version (III) so ab, dass die Regenbogenfarben nicht
mehr horizontal (waagrecht) verteilt sind, sondern diagonal: Links un-
ten ist violet und rechts oben rot.

26.∗ Schreibe den Befehl zufallsPunkt() so um, dass tatsächlich ein

Regenbogen entsteht: Die Verteilung der Farben soll also kreisförmig
oder sogar bogenförmig sein. Tipp: Du kannst mit dem Satz des Pytha-
goras die Distanz zwischen zwei Punkten berechnen.

27.∗ In dieser Aufgabe geht es darum, die relative und absolute Turt-
lesteuerung zu kombinieren, um ein Pentagramm zu zeichnen (vgl.
p. 66). Zeichne mit der Turtle zunächst ein Fünfeck und lass dir bei
jedem Punkt die aktuellen Koordinaten ausgeben. Verwende danach
moveTo, um das Fünfeck mit dem Stern zu ergänzen.

28. Schreibe einen Befehl dotXY(x, y, r), der an der Stelle (x, y)
einen Punkt mit Radius r zeichnet und danach die Turtle dahin zu-
rücksetzt, wo sie vor dem Befehl war.

29. Definiere einen Befehl squareDot(s), der ein ausgefülltes Quadrat

mit der Seitenlänge s zeichnet. Die aktuelle Turtleposition ist dabei der
Mittelpunkt.

c 2016, Tobias Kohn

78 KAPITEL 4. KOORDINATENGRAFIK

6 Schleifen in Schleifen

Lernziele In diesem Abschnitt lernst du:

. Schleifen (repeat) zu verschachteln.

Einführung Mit Schleifen kannst du sehr gut verschiedene Werte

für eine Variable durchgehen (z. B. mit i += 1). Im Koordinatensystem
sollst du nun Paare von Koordinaten (x, y) durchgehen, etwa so:
(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), . . .
Das erreichst du am einfachsten, in dem du Schleifen verschachtelst, d. h.
eine Schleife innerhalb einer anderen Schleife schreibst.

Das Programm (I) Mit zwei üblichen Spielwürfeln kannst du ver-

schiedene Kombinationen der Zahlen von 1 bis 6 werfen. Dieses Pro-
grämmchen erstellt eine Liste aller möglichen Zahlen-Kombinationen
und schreibt diese auf den Bildschirm. Die äussere Schleife umfasst die
Zeilen 3 bis 7. Bei jedem Durchgang wird zuerst die zweite Zahl auf 1
gesetzt, dann wird die innere Schleife 6 Mal wiederholt und schliesslich
die erste Zahl um 1 erhöht. Arbeite hier mit dem Debugger,
um ganz sicher zu verstehen,
1 erste_zahl = 1
in welcher Reihenfolge Python
2 repeat 6:
die Programmzeilen ausführt.
3 zweite_zahl = 1
4 repeat 6:
5 print erste_zahl, zweite_zahl
6 zweite_zahl += 1
7 erste_zahl += 1

Warum wird die Variable zweite_Zahl innerhalb der äusseren Schleife

auf 1 gesetzt und nicht wie die Variable erste_Zahl ganz am Anfang?
Was passiert, wenn du diese Zuweisung ganz an den Anfang nimmst?

AUFGABEN

30. Füge in Zeile 5 eine if-Bedingung ein, so dass die Paare nur aus-
gegeben werden, wenn die zweite Zahl grösser ist als die erste.

31. Ergänze das Programm so, dass es für jede Zahlen-Kombination

auch die Summe der beiden Zahlen ausgibt.

32. Schreibe ein Programm, das pythagoräische Zahlentrippel sucht

und ausgibt, d. h. ganze Zahlen a, b, c mit a2 + b2 = c2 (z. B. (3, 4, 5)).

c 2016, Tobias Kohn

 4.6. SCHLEIFEN IN SCHLEIFEN 79

Das Programm (II) Die Technik der verschachtelten Schleifen wen-

den wir jetzt an, um einen «zweidimensionalen Farbverlauf» (siehe Bild
nebenan) zu zeichnen. Die Grundtechnik des Farbverlaufs kennst du
bereits von der Seite 70. In diesem Programm ändern wir die rot- und
Ein zweidimensionaler Farb- die blau-Komponente unabhängig voneinander und zeichnen damit ein
verlauf mit rot und blau. Quadrat.
1 from gturtle import *
2 makeTurtle()
3 hideTurtle()
4 y = 0
5 repeat 20:
6 x = 0
7 repeat 20:
8 setPenColor( makeColor(x / 20, 0.0, y / 20) )
9 setPos(x * 10, y * 10)
10 dot(10)
11 x += 1
12 y += 1

Die wichtigsten Punkte Du kannst Schleifen nach belieben ineinan-

der verschachteln. Das ist besonders praktisch, wenn du verschiedene
Schleifen-Variablen miteinander zu Zahlenpaaren kombinieren willst.
i = 0
repeat n:
j = 0
repeat m:
Schleifencode
j += 1
i += 1

AUFGABEN

33. Ändere die Farben und die Grösse der Punkte im Programm (II).

34. Schreibe ein Programm, das ein Quadrat aus 12×12 Punkten zeich-
net, die sich alle berühren und alle eine zufällige Farbe haben.

35. Schreibe das Programm so, dass die Punkte von links nach rechts
immer kleiner und von unten nach oben immer heller (d. h. farbiger)
werden.

36.∗ Definiere einen eigenen Befehl squareDot(s), um einen quadra-

tischen Punkt zu zeichnen und zeichne damit einen durchgehenden
zweidimensionalen Farbverlauf (ohne die Lücken, die bei den runden
Punkten entstehen).

c 2016, Tobias Kohn

80 KAPITEL 4. KOORDINATENGRAFIK

7 Die Maus jagen

Lernziele In diesem Abschnitt lernst du:

. Mit der Turtle auf Mausklicks zu reagieren.
. Mit if und and gleich mehrere Bedingungen auf einmal zu prüfen.

Einführung Es ist an der Zeit, unsere Programme etwas interaktiver

zu gestalten. Du kannst die Turtle sehr einfach so programmieren, dass
sie auf Mausklicks reagiert. Dazu musst du aber zwingend einen Befehl
definieren, der bei einem Mausklick ausgeführt werden soll. Wie dieser
Befehl heisst, spielt keine Rolle, aber er muss genau zwei Parameter
haben: x und y. Damit gibt dir die Maus an, an welchen Koordinaten
du geklickt hast. Zudem stellst du dem Befehl ein @onMouseHit voran:
@onMouseHit
def mouseClicked(x, y):
print x, y

Das Programm In diesem Programm kombinieren wir zwei wichti-

ge Ideen. Zum einen siehst du, dass wir wieder einen Befehl onClick
definieren, der jedes Mal ausgeführt wird, wenn du mit der Maus klickst.

Wenn die Maus geklickt wird, soll die Turtle eine Linie an die entspre-
chende Stelle zeichnen. Aber nur innerhalb des Quadrats in der Mitte
des Fensters. Dazu prüfen wir, ob die Koordinaten x und y im entspre-
chenden Bereich liegen.
1 from gturtle import *
2
3 @onMouseHit
4 def onClick(x, y):
5 if (-200 < x < 200) and (-200 < y < 200):
6 moveTo(x, y)
7 else:
8 setPenColor("red")
9
10 makeTurtle()
11 hideTurtle()
12 setPos(-200, -200)
13 repeat 4:
14 forward(400)
15 right(90)
16 setPos(0, 0)
17 showTurtle()

c 2016, Tobias Kohn

4.7. DIE MAUS JAGEN 81

In Zeile 4 möchten wir prüfen, ob die x- und die y-Koordinaten beide

gleichzeitig im Bereich zwischen −200 und 200 liegen. Das erreichen
wir mit and. Dadurch müssen beide Bedingungen erfüllt sein. Ansons-
ten wird das moveTo nicht ausgeführt, sondern das setPenColor im
else-Teil. Für die Bereichsüberprüfung kannst du bei Bedarf z. B. auch
schreiben:
if (-100 <= x <= 200) and (y < 180):

Die wichtigsten Punkte Auf Mausklicks reagieren: Definiere einen

eigenen Befehl, der die beiden Parameter x und y für die Mauskoor-
dinaten hat. Diesem Befehl stellst du direkt in der Zeile darüber ein
@onMouseHit voran.

Bedingungen verknüpfen: Wenn du auf Mausklicks reagieren möchtest,

dann wirst du oft prüfen, ob die Maus in einem bestimmten Bereich
liegt. Um die x- und die y-Koordinaten gleichzeitig zu überprüfen, kannst
du die Bedingungen mit and zusammenhängen.
if Bedingung-1 and Bedingung-2:

AUFGABEN

37. Ändere das Programm oben so ab:

(a) Dass es bei einem Klick ausserhalb des Quadrats eine Zufallsfarbe
für die Stiftfarbe wählt.
(b) Dass der Zeichenbereich in der Mitte kein Quadrat, sondern ein
Rechteck mit unterschiedlicher Höhe und Breite ist.
(c) Dass die Maus im Zeichenbereich keine Linie zeichnet, sondern
nur Punkte an der Stelle, an der du geklickt hast.
(d) Der Zeichenbereich in der Mitte ein Kreis ist.

38. Im Programm oben hast du in der Mitte einen «Zeichenbereich».

Ergänze das Programm nun mit farbigen Rechteck so, dass man gezielt
die Stiftfarbe wählen kann. Wenn man z. B. auf ein rotes Rechteck aus-
senrum klickt, dann ist die Stiftfarbe nachher rot.

39.∗ Baue dein Programm zu einem Zeichenprogramm aus, bei dem du

auch die Linienbreite auswählen kannst und die Möglichkeit hast, die
Maus zu bewegen, ohne dass eine Linie gezeichnet wird.

c 2016, Tobias Kohn

82 KAPITEL 4. KOORDINATENGRAFIK

8 Globale Variablen

Lernziele In diesem Abschnitt lernst du:

. Innerhalb einer Befehlsdefinition auf globale Variablen zuzugreifen
und diese zu verändern.

Einführung Quizfrage: Welchen Wert hat die Variable x am Ende

dieses Programms? Welcher Zahlenwert wird am Schluss ausgegeben?
def twelve():
x = 12

x = 5
twelve()
print x

Der Befehl twelve setzt den Wert von x auf 12 und weil Python diesen
Code nach dem x = 5 ausführt, sollte die Variable x den Wert 12 haben.
Tut sie aber nicht. Warum? === Lokale Variablen ===
x = 12 [int]
Um dem auf den Grund zu gehen ist es sinnvoll, dass du den Debugger === Globale Variablen ===
verwendest und das Programm langsam Schritt für Schritt ausführst. x = 5 [int]
Sieh dir dabei im Debuggerfester an, welchen Wert die Variable x hat.
Während das Programm den Befehl twelve ausführt, wirst du im De-
buggerfenster zwei verschiedene x finden.

In Python hat jeder Befehl seine eigenen lokalen Variablen! Aus Sicht von
Python hat das x im Befehl twelve also grundsätzlich nichts mit dem
x unten zu tun: Das sind zwei verschiedene Variablen, die nur zufäl-
lig gleich heissen. Falls du möchtest, dass der Befehl twelve mit der Eine Variable, die innerhalb ei-
globalen Variable arbeitet, dann musst du das mit global x angeben: ner Befehlsdefinition verwen-
det wird, heisst lokale Varia-
def twelve(): ble. Eine Variable, die aus-
global x serhalb einer Definition steht
x = 12 heisst hingegen globale Varia-
ble.
Schau dir auch dieses Programm schrittweise an. Du wirst feststellen,
dass Python jetzt keine lokale Variable x mehr verwendet: Beide x sind
jetzt ein und dieselbe Variable!

Also: Python unterscheidet zwischen globalen Variablen im Hauptpro-

gramm selber und lokalen Variablen innerhalb einer Befehlsdefinition.
Lokale Variablen werden immer dann erzeugt, wenn ein Befehl ausge-
führt wird und am Ende wieder gelöscht. Wenn du also den gleichen
Befehl ein zweites Mal ausführst, dann erzeugt Python dafür wieder
eine neue lokale Variable x.

c 2016, Tobias Kohn

4.8. GLOBALE VARIABLEN 83

Das Programm In diesem Programm repräsentiert ein Punkt im

Fenster eine kleine Lampe. Wenn du mit der Maus klickst, soll sich diese
Lampe ein- oder ausschalten. Das Programm zeichnet also den Punkt
in der Fenstermitte gelb oder schwarz.

Die Variable lampe enthält den aktuellen Farbwert der Lampe, am An-
fang also schwarz. In der Definition des Befehls von onClick müssen
wir angeben, dass wir diese globale Variable innerhalb der Definition
verwenden (und verändern) wollen (Zeile 5).
1 from gturtle import *
2 lampe = "black"
3
4 @onMouseHit
5 def onClick(x, y):
6 global lampe
7 if lampe == "black":
8 lampe = "yellow"
9 else:
10 lampe = "black"
11 setPenColor(lampe)
12 dot(20)
13
14 makeTurtle()
15 clear("black")

Mit dem clear("black") in Zeile 14 löschen wir am Anfang nicht nur

den ganzen Fensterinhalt, sondern setzen die Hintergrundfarbe auch
gleich noch auf «schwarz».

Die wichtigsten Punkte Variablen, die innerhalb eines Befehls ver-

wendet werden, sind lokal. Das heisst, dass diese Variablen erst dann
definiert werden, wenn der Befehl ausgeführt wird. Sobald der Befehl
fertig ist, werden diese Variablen wieder gelöscht. Wenn du eine globale
Variable innerhalb eines Befehls verwenden möchtest, dann gib das mit
«global variable1, variable2, variable3» an:
def mein_befehl():
global globale_variable
code

AUFGABEN

40. Schreibe ein Programm, das die Anzahl der Mausklicks zählt und
ausgibt.

41. Schreibe ein Programm, das bei jedem Mausklick die Hintergrund-
farbe wechselt, z. B. mit makeRainbowColor().

c 2016, Tobias Kohn

84 KAPITEL 4. KOORDINATENGRAFIK

9 Mehrere Alternativen

Lernziele In diesem Abschnitt lernst du:

. Verschiedene if-Bedingungen mit elif zu verketten, so dass nur
eine von vielen Alternativen ausgewählt wird.

Einführung Mit if und else kannst du zwischen genau zwei Alter-

nativen unterscheiden. Wenn du mehr als zwei Alternativen hast, wird
das vor allem in Bezug auf das else problematisch: getPixelColorStr() gibt
die Farbe des Pixels an, auf
if getPixelColorStr() == "red": dem die Turtle sitzt. Das Str
print "Der Pixel ist rot." am Schluss bedeutet, dass du
if getPixelColorStr() == "blue": die Farbe als englischen Na-
print "Der Pixel ist blau." men möchtest.
else:
print "Der Pixel ist weder rot noch blau."

Das Problem: Bei einem roten Pixel schreibt das Programm nicht nur,
dass der Pixel rot ist, sondern auch «Der Pixel ist weder rot
noch blau.» Warum? Weil sich das else nur auf den Test mit blau
bezieht und nicht auch auf das rot!

Wir können die beiden if-Bedingungen aber mit einem elif zusam-
menhängen, so dass das Programm richtig funktioniert, sogar wenn wir
noch weitere Tests hinzufügen:
if getPixelColorStr() == "red":
print "Der Pixel ist rot."
elif getPixelColorStr() == "blue":
print "Der Pixel ist blau."
elif getPixelColorStr() == "green":
print "Der Pixel ist grün."
else:
print "Der Pixel ist weder rot, blau noch grün."

elif steht für else if. Wenn du eine Bedingung mit elif an die vor-
hergehende anhängst, dann wird sie nur dann ausgeführt, wenn keine
der vorausgehenden Bedingungen erfüllt war. Python wählt aus einer
solchen Kette von if, elif und else also nur genau eine Alternative
aus!

Das Programm Das Programm ist ein kleines Farbenspiel. Die Turtle
springt von Punkt zu Punkt. Je nach Farbe des Punkts ändert die Turtle
ihre Richtung und ändert die Farbe des Punkts, auf dem sie sitzt. Wenn
du die «Farbregeln» änderst, entstehen je nachdem andere Muster.

c 2016, Tobias Kohn

4.9. MEHRERE ALTERNATIVEN 85

In unserem Fall macht die Turtle 100 Schritte (Zeile 22) und zeichnet
dabei gelbe, rote und blaue Punkte.
1 from gturtle import *
2 from time import sleep
3
4 def doStep():
5 hideTurtle()
6 forward(24)
7 if getPixelColorStr() == "white":
8 setPenColor("yellow")
9 dot(24)
10 right(60)
11 elif getPixelColorStr() == "yellow":
12 setPenColor("red")
13 dot(24)
14 left(60)
15 else:
16 setPenColor("blue")
17 dot(24)
18 showTurtle()
19
20 makeTurtle()
21 penUp()
22 repeat 100:
23 doStep()
24 sleep(0.1)

Übrigens: sleep(0.1) aus dem time-Modul wartet 0.1 Sekunden, be-

vor das Programm weiterläuft. Damit sorgen wir dafür, dass die Turtle
nicht zu schnell ist.

AUFGABEN

42. Ergänze das Programm durch weitere Regeln und Farben. Füge
auch eine Regel hinzu, bei der die Turtle ein Feld überspringt (verwen-
de forward) oder sich um 180◦ dreht.

43. In diesem Programm könntest du die elif auch dann nicht durch
if ersetzen, wenn du das else weglässt. Warum nicht? Finde heraus,
was passieren würde und erkläre, warum die elif hier wichtig sind.

44.∗ Das Programm basiert auf einer sechseckigen Grundstruktur. Än-

dere das Programm zu einer quadratischen Grundstruktur, indem du
nur die Winkel 90◦ und 180◦ verwendest. Passe die Regeln so an, dass
wiederum interessante Muster entstehen.

45.∗ Lass die Turtle z. B. bei grünen Punkten zufällig eine Farbe aus-
wählen oder entscheiden, ob sie nach links oder rechts gehen soll.

c 2016, Tobias Kohn

86 KAPITEL 4. KOORDINATENGRAFIK

10 Vier Gewinnt

Lernziele In diesem Abschnitt lernst du:

. Fallende Punkte zu simulieren.

Einführung Kennst du das Spiel «Vier Gewinnt»? Du und deine Mit-

spielerin lassen abwechseln runde Chips (gelbe und rote) in ein Gerüst
fallen und wenn du vier gleichfarbige Chips in einer Reihe hast (hori-
zontal, vertikal oder diagonal), gewinnst du das Spiel.

Um das zu programmieren brauchen wir zwei neue Techniken. Zum

einen müssen wir die Chips so programmieren, dass sie nach unten
fallen (siehe unten). Zum anderen müssen wir aus den Koordinaten des Unser Spielfeld hat 5 × 7
Mausklicks herausfinden, welche Spalte das ist: Weil der linke Rand des Punkte, jeder Punkt hat einen
Radius von 10 Pixeln und die
Spielfeld bei x = −105 liegt, rechnen wir zur x-Mauskoordinate zuerst
einzelnen Punkte haben einen
150 dazu. Dadurch erhalten wir eine Zahl zwischen 0 und 210 (falls Abstand von 10 Pixeln.
die Maus im Spielfeld ist). Teilen durch 30 (Spaltenbreite) ergibt dann
einen Wert zwischen 0 und 6 für die Spalte.

Das Programm In diesem Programm definieren wir zuerst einmal

vier Befehle. drawGrid zeichnet die weissen Punkte als Grundgerüst.
dotXY zeichnet einen Punkt mit der angegebenen Farbe an die Stel-
le (x, y). putChip lässt einen «Chip» in die angegebene Spalte fallen.
onClick schliesslich reagiert auf die Mausklicks. Beachte, dass wir hier
onMouseHitX und nicht onMouseHit verwenden. Das X am Ende sorgt
dafür, dass wir erst dann einen neuen Chip einwerfen können, wenn
der alte bis nach unten gefallen ist. Beachte, dass dieses Pro-
gramm nicht «fertig» ist.
1 from gturtle import *
Hier sind nur gelbe Chips im
2 from time import sleep
Spiel. Um wirklich spielen zu
3
können, musst du es im Zuge
4 def drawGrid(): der Aufgaben noch ausbauen.
5 setPenColor("white")
6 x = -90
7 repeat 7:
8 setPos(x, -60)
9 repeat 5:
10 dot(20)
11 forward(30)
12 x += 30
13
14 def dotXY(x, y, color):
15 setPenColor(color)
16 setPos(x, y)
17 dot(20)

c 2016, Tobias Kohn

4.10. VIER GEWINNT 87

18
19 def putChip(spalte):
20 x = -90 + spalte * 30
21 y = 60
22 repeat 5:
23 dotXY(x, y, "yellow")
24 sleep(0.25)
25 setPos(x, y - 30)
26 if getPixelColorStr() != "white":
27 break
28 dotXY(x, y, "white")
29 y -= 30
30
31 @onMouseHitX
32 def onClick(x, y):
33 spalte = (x + 105) // 30
34 if 0 <= spalte <= 6:
35 putChip(spalte)
36
37 makeTurtle()
38 hideTurtle()
39 penUp() # Keine Spur zeichnen
40 clear("blue") # Blauer Hintergrund
41 drawGrid()

Wie die Chips fallen Wie machen wir das, dass ein Chip nach unten
fällt? Zuerst einmal rechnen wir die Koordinaten (x, y) des obersten
Punkts aus. Danach gehen wir der Reihe nach von oben nach unten
und versuchen, den Chip «fallen zu lassen»:

Zuerst setzen wir einen gelben Punkt (den Chip). Danach schauen wir,
ob der Punkt darunter frei (d. h. weiss) ist. Wenn nicht, dann sind wir
fertig und wir brechen die Schleife ab (Zeile 27). Ansonsten löschen wir
den gelben Punkt von vorhin wieder, weil er ja nach unten fallen kann.
Zwischen dem Zeichnen und dem Löschen des gelben Punkts fügen
wir eine Pause von einer Viertelsekunde ein, damit man den Chip auch
fallen sieht.

AUFGABEN

46. Definiere eine globale Variable farbe und wechsele bei jedem Maus-
klick (d. h. im Befehl onClick) den Wert zwischen "yellow" und "red"
ab. Baue das anschliessend so in das Programm ein, dass die Chips ab-
wechselnd rot und gelb sind und du mit einer Freundin spielen kannst.
47.∗ Spiele gegen den Computer. Ergänze dazu den Befehl onClick so,
dass nach jedem Chip, den du hineinwirfst der Computer eine Zufalls-
zahl zieht und in die entsprechende Spalte einen Chip einwirft.

c 2016, Tobias Kohn

88 KAPITEL 4. KOORDINATENGRAFIK

11 Mausbewegungen*

Lernziele In diesem Abschnitt lernst du:

. Die Bewegungen der Maus abzufangen und darauf zu reagieren.

Einführung Im Abschnitt 4.7 hast du ein erstes Beispiel für einen

Callback gesehen. Nachdem du einen eigenen Befehl «onClick(x, y)»
definiert hast, kannst du der Turtle angeben, dass dieser Befehl immer
dann ausgeführt werden soll, wenn du mit der Maus klickst. Der Name
«Callback» kommt daher, dass dich die Maus über diesen Befehl «zu-
rückruft» sobald etwas passiert.

Neben dem Mausklick (onMouseHit) gibt es noch weitere Maus-Callbacks,

die für dich interessant sein dürften: Mit onMouseMoved und onMouseDragged
reagierst du z. B. auf Bewegungen der Maus.

onMouseMoved Maus ohne Tastendruck bewegt.

onMouseDragged Maus mit gedrückter Taste bewegt.
onMousePressed Maustaste gedrückt.
onMouseReleased Maustaste wieder losgelassen.
onMouseClicked Mit der Maus geklickt.

Das Programm In diesem Programm kannst du nun «freihändig»

zeichnen. Dazu nutzen wir den onMouseDragged-Callback. Dieser wird
aufgerufen (zurückgerufen), wenn du die Maus mit gedrückter Taste
bewegst (engl. «drag» heisst «ziehen»). Wie du siehst, können wir auch
beliebig viele Callbacks kombinieren.

Mit setCursor() ändern wir zudem die Form des Mauszeigers wäh-
rend des Zeichnens. Dazu fangen wir auch die Callbacks für das Drücken
und Loslassen der Maustaste ab. Sobald die Maus gedrückt wird, setzen
wir die Turtle an die entsprechende Stelle, noch ohne etwas zu zeich-
nen.
1 from gturtle import *
2
3 @onMouseDragged
4 def mouseDragged(x, y):
5 moveTo(x, y)
6
7 @onMousePressed
8 def mouseDown(x, y):
9 setCursor(Cursor.CROSSHAIR_CURSOR)

c 2016, Tobias Kohn

4.11. MAUSBEWEGUNGEN* 89

10 setPos(x, y)
11
12 @onMouseReleased
13 def mouseUp(x, y):
14 setCursor(Cursor.DEFAULT_CURSOR)
15
16 @onMouseClicked
17 def mouseClick(x, y):
18 setPos(x, y)
19 dot(10)
20
21 makeTurtle()
22 hideTurtle()

Für den Cursor hast du unter anderem folgende Möglichkeiten:

DEFAULT_CURSOR, CROSSHAIR_CURSOR, HAND_CURSOR, TEXT_CURSOR.

AUFGABEN

48. Mit setCursor(Cursor.HAND_CURSOR) ändert sich der Mauszei-

ger zu einer kleinen Hand, die du von Links im Internetbrowser her
kennst. Schreibe ein Programm, in dem du onMouseMoved abfängst
und den Mauszeiger immer dann zu einer Hand änderst, wenn sich
die Maus über einem blauen Rechteck befindet (natürlich musst du das
Rechteck zuerst noch zeichnen).

49. Schreibe ein vollständiges Zeichenprogramm, bei dem man gera-

de Linien ziehen oder freihändig zeichnen kann. Zudem kann man die
Stiftbreite und -farbe wählen oder verschieden grosse Punkte setzen.
Dazu gibt es in der Mitte einen Zeichenbereich und rundum verschie-
dene Rechtecke für die Farben und Werkzeuge.
Übrigens: Mit label("Text") schreibt dir die Turtle einen Text an der
aktuellen Position.

c 2016, Tobias Kohn

90 KAPITEL 4. KOORDINATENGRAFIK

12 Die Turtle im Labyrinth

Lernziele In diesem Abschnitt lernst du:

. Ein grösseres Programm zusammenzusetzen.

Einführung Lass uns ein kleines Spiel programmieren! Wir setzen

die Turtle in ein «Labyrinth», in dem sie ihren Weg zum Ziel suchen
muss. Dabei unterstützt du die Turtle, indem du ihren Weg mit schwar-
zen Feldern blockierst, so dass sie sich abdreht (ein schwarzes Feld er-
zeugst du über einen Mausklick).

Das Programm Wir geben dir hier erst einmal nur die Grundstruk-
tur für das Spiel an. Die Turtle bewegt sich hier auf einer Art von
«Schachbrett». Mit Klicken kannst du ein Feld schwarz färben.

Bei einem grösseren Programm ist es wichtig, dass du mit Kommentaren

erklärst, was die einzelnen Teile machen. Kommentare beginnen jeweils
mit «#». Python ignoriert alle solchen Kommentare – sie dienen nur dem
Leser zum besseren Verständnis!

Nachdem wir zuerst alle Befehl definiert haben, beginnt das Hauptpro-
gramm erst in Zeile 51. Das machen wir deutlich mit ### MAIN ###
(eine Kurzform für main program, also Hauptprogramm). Auch das hat
für Python keine Bedeutung, hilft uns aber, die Übersicht zu behalten.
1 from gturtle import *
2 from time import sleep
3
4 CELLSIZE = 40 # Wähle zwischen: 10, 20, 40, 50
5
6 # Zeichnet das Grundgitter:
7 def drawGrid():
8 global CELLSIZE
9 hideTurtle()
10 setPenColor("gray")
11 x = -400
12 repeat (800 // CELLSIZE) + 1:
13 setPos(x, -300)
14 moveTo(x, +300)
15 x += CELLSIZE
16 y = -300
17 repeat (600 // CELLSIZE) + 1:
18 setPos(-400, y)
19 moveTo(+400, y)

c 2016, Tobias Kohn

4.12. DIE TURTLE IM LABYRINTH 91

20 y += CELLSIZE
21 setPos(0, 0)
22 showTurtle()
23
24 # Bei Mausklick eine Zelle schwarz färben.
25 @onMouseHit
26 def onClick(x, y):
27 # Die Position der Turtle speichern
28 turtle_x = getX()
29 turtle_y = getY()
30 # Zelle schwarz färben
31 hideTurtle()
32 setPos(x, y)
33 if getPixelColorStr() == "white":
34 setFillColor("black")
35 fill()
36 # Die Turtle wieder dahin zurücksetzen,
37 # wo sie am Anfang war.
38 setPos(turtle_x, turtle_y)
39 showTurtle()
40
41 def doStep():
42 hideTurtle()
43 # Einen Schritt nach vorne machen.
44 forward(CELLSIZE)
45 # Falls die Turtle auf einem schwarzen Feld landet,
46 # setzen wir sie wieder zurück und drehen sie dafür.
47 if getPixelColorStr() == "black":
48 back(CELLSIZE)
49 right(90)
50 showTurtle()
51
52 ### MAIN ###
53 makeTurtle()
54 drawGrid()
55 # An dieser Stelle könntest du ein Feld als Ziel färben.
56 # Die Turtle auf ein Anfangsfeld setzen:
57 setPos(-400 + 5*CELLSIZE // 2, -300 + 5*CELLSIZE // 2)
58 penUp()
59
60 repeat 1000:
61 doStep()
62 sleep(0.5)

Bevor wir die Turtle an eine bestimmte Stelle bewegen, machen wir
sie mit hideTurtle() unsichtbar und zeigen sich danach wieder mit
showTurtle(). Das hat zwei Gründe. Zum einen wäre es z. B. merk-
würdig, wenn die Turtle bei einem Mausklick kurz zum Mauscursor
springt und danach wieder zurückgeht. Zum anderen wäre das Pro-
gramm zu langsam, wenn die Turtle bei all ihren Bewegungen sichtbar
wäre.

c 2016, Tobias Kohn

92 KAPITEL 4. KOORDINATENGRAFIK

AUFGABEN

50. Ergänze das Programm so, dass du mit der Maus schwarze Felder
auch wieder wegklicken kannst. Wenn du also auf ein schwarzes Feld
klickst, dann wird es wieder weiss.

51. Ergänze das Programm zu einem Spiel, indem du ein Feld rot ein-
färbst (Zeile 54). Wenn die Turtle dieses rote Feld erreicht hat, ist das
Spiel fertig und man hat «gewonnen». Im Modul sys gibt es übrigens
einen Befehl exit(), um das Programm sofort zu beenden:
from sys import exit

exit() # Programm beenden

52. Im Moment kann es passieren, dass die Turtle aus dem Bild her-
ausfällt. Ergänze das Programm also so, dass du alle Felder am Rand
zuerst schwarz färbst.

53. Das Spiel wird erst dann interessant, wenn du gewisse Hindernisse
oder Punkte einbaust. Du könntest z. B. die Anzahl der schwarzen Blö-
cke zählen, die man braucht, um das Spiel zu lösen. Je weniger Blöcke,
umso höher die Punktzahl. Oder du zählst die Schritte, die die Turtle
braucht. Überlege dir selber, wie du die Punktzahl berechnen möchtest
und gib am Ende diese Punktzahl mit msgDlg aus!

54.∗ Baue ein Level, in dem du bereits gewisse Wände vorgibst, die der
Turtle im Weg stehen. Damit wird das Spiel etwas schwieriger.

55.∗ Neben den schwarzen Blöcken könntest du noch graue Blöcke ein-
führen, die der Turtle ebenfalls im Weg stehen. Im Unterschied zu den
schwarzen Blöcken lassen sich die grauen Blöcke aber nicht mehr ent-
fernen.

56.∗ Die Turtle könnte beim Gehen eine gelbe Spur hinterlassen und
sich so weigern, ein zweites Mal auf ein Feld zu gehen.

57.∗ Mach das Spiel schwieriger, indem sich die Turtle zufällig nach
links oder rechts abdreht. Du kannst die Turtle auch schneller machen,
indem du den Wert in sleep() veränderst. Sie sollte aber nicht zu
schnell sein, weil sonst das Erzeugen und Entfernen der Blocks nicht
mehr richtig funktioniert.

58.∗ Für Profis: Programmiere das Spielfeld so, dass wenn die Turtle
rechts hinausläuft, dass sie dann von links wieder hineinkommt. Natür-
lich funktioniert das dann auch in die entgegengesetzte Richtung und
genauso für oben/unten.

c 2016, Tobias Kohn

4.12. DIE TURTLE IM LABYRINTH 93

Quiz
9. Wie kannst du eine Turtlegrafik mit absoluten Koordinaten so
an der Mitte spiegeln, dass links und rechts danach vertauscht
sind?

2 a. Wechsle bei allen x-Koordinaten das Vorzeichen.

2 b. Wechsle bei allen y-Koordinaten das Vorzeichen.
2 c. Vertausche überall die x- und die y-Koordinaten.
2 d. Das erfordert aufwändige Berechnungen.

10. Wie viele «x» scheibt das folgende Programm auf den Bild-
schirm?
k = 1
repeat 20:
repeat k:
print "x",
k += 1

2 a. 20 2 b. 21 2 c. 210 2 d. 400

11. Welchen Wert schreibt das folgende Programm auf den Bild-
schirm?
x = 2
def egg():
global x
x = 3
def spam(x):
x = 5
x = 4
egg()
spam(x)
print x

2 a. 2 2 b. 3 2 c. 4 2 d. 5

c 2016, Tobias Kohn

94 KAPITEL 4. KOORDINATENGRAFIK

c 2016, Tobias Kohn

K a p i t e l F ü n f

ALGORITHMEN UND FUNKTIONEN

Nachdem du mit den Grundtechniken des Programmierens vertraut

bist, führen wir in diesem Kapitel eine der wichtigsten Strukturen über-
haupt ein: Die Funktion. Funktionen sind eine Erweiterung der selber
definierten Befehle und helfen dir, deine Programme so zu struktu-
rieren, dass du die Übersicht behältst und auch grössere Programme
schreiben kannst.

Neben den Funktionen lernst du auch eine Reihe von Algorithmen ken-
nen. Ein Algorithmus ist ein Berechnungsverfahren. Zum Beispiel wird
die «Berechnung von Wurzeln» das ganze Kapitel hindurch eine grosse
Rolle spielen und du lernst verschiedene Algorithmen (also Verfahren)
kennen, um die Wurzel einer Zahl zu berechnen.

c 2016, Tobias Kohn

96 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

1 Distanz berechnen

Lernziele In diesem Abschnitt lernst du:

. Wie du eine Berechnung in eine Funktion auslagerst.
. Dass eine Funktion immer ein return braucht.

Einführung Ganz zu Beginn hast zu gelernt, mit def eigene Befehle

zuschreiben, die etwas tun. Im Gegensatz zu diesen Befehlen berechnet
oder ermittelt eine Funktion etwas: Sie gibt immer einen Wert zurück.

Bei der Turtle wäre left() ein Befehl, der etwas tut, getX() hingegen
eine Funktion, die einen Wert ermittelt und zurückgibt. Wenn du selbst
eine Funktion definierst, dann verwendest du immer die Anweisung
return, um anzugeben, was das Resultat ist.

Das Programm Das Programm lässt die Turtle 50 000 zufällige Punk-
te zeichnen. Punkte, die weniger als 75 Pixel von der Bildmitte entfernt
sind zeichnen wir rot, alle anderen blau.

Neu ist hier die Funktion distance in den Zeilen 5 bis 7. Du weisst
bereits, dass mit def hier ein neuer Befehl definiert wird, der dann in
Zeile 14 ausgeführt wird. Das return d in Zeile 7 bewirkt danach, dass
der berechnete Wert d in der Zeile 14 für distance eingesetzt wird.

Eine zweite Funktion ist zufall in Zeilen 9 bis 11. Sie zieht eine ge-
rade Zufallszahl zwischen −200 und 200 und gibt diese – wiederum
mit return – zurück. In den Zeilen 16 und 17 verwenden wir diese
Funktion dann, um zwei Zufallszahlen zu ziehen. Die Distanz eines Punktes
(x, y) zur Bildmitte (0, 0) be-
1 from gturtle import *
rechnest
p du über die Formel:
2 from math import sqrt
d = x2 + y 2 .
3 from random import randint
4
5 def distance(x, y):
6 dist = sqrt(x**2 + y**2)
7 return dist
8
9 def zufall():
10 z = randint(-100, 100) * 2
11 return z
12
13 makeTurtle()
14 hideTurtle()
15 repeat 25000:

c 2016, Tobias Kohn

5.1. DISTANZ BERECHNEN 97

16 x = zufall()
17 y = zufall()
18 if distance(x, y) < 75:
19 setPenColor("red")
20 else:
21 setPenColor("blue")
22 setPos(x, y)
23 dot(5)

AUFGABEN

1. Im Beispiel-Programm oben liefert die Funktion zufall nur gerade

Zahlen, weil die gezogene Zahl mit 2 multipliziert wird. Ändere das
Beispielprogramm so ab, dass (a) nur Vielfache von 5 bzw. (b) beliebige
ganze Zahlen zwischen −200 und 200 zurückgegeben werden.

2. Schreibe das Beispiel-Programm so um, dass die Kreise gegen aus-

sen immer kleiner werden. In der Mitte haben sie noch einen Durch-
messer von 10 Pixeln, aussen nur noch 1 Pixel.

3. Ersetze die Funktion distance(x, y) durch eine neue Funktion

metrik(x, y), die den Wert nach folgender Formel berechnet (für den
Betrag |x| verwendest du abs(x)):

(a) d = |x| + |y| (b) d = min(|x|, |y|)

4. Mit makeColor("rainbow", |n|) kannst du eine Regenbogenfar-

be erzeugen, wobei die Zahl n zwischen 0.0 und 1.0 liegen muss. Für
ein mittelhelles Blau verwendest du z. B.:
setPenColor(makeColor("rainbow", 0.3))
Im Beispiel-Programm oben erhältst du einen schönen Regenbogen,
wenn du die Farbe so bestimmst:
setPenColor(makeColor("rainbow", distance(x, y) / 200))
Schreibe das Beispiel-Programm oben entsprechend um, so dass ein
Regenbogen entsteht.

c 2016, Tobias Kohn

98 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

2 Mathematische Funktionen

Lernziele In diesem Abschnitt lernst du:

. Wie du Funktionen mit Rückgabewerten programmierst.
. Welche Bedeutung return hat.

Einführung Mathematische Funktionen hast du in Python schon oft

verwendet, besonders die Wurzelfunktion sqrt(x). Jetzt schreibst du
dazu deine eigenen Funktionen und lernst, wie du eine Quadratfunkti-
on sq(x) (engl. «square») definieren kannst.

Eine Funktion definierst du wie eigene Befehle mit einem def. Im Un-
terschied zu den Befehlen braucht eine Funktion immer ein return.
Nach dem return gibst du an, was das Resultat der Funktion sein soll.
So sieht dann also die Quadratfunktion aus:
def sq(zahl):
ergebnis = zahl * zahl
return ergebnis

Eine andere (kürzere) Möglichkeit, die gleiche Funktion zu definieren

ist:
def sq(zahl):
return zahl**2

Du kannst dir sicher noch weitere Möglichkeiten vorstellen. Das wich-

tigste ist aber in jedem Fall: Am Ende steht ein return mit dem Schluss-
resultat der Berechnung.

Das Programm Hier definieren wir eine eigene einfache Funktion,

um die Wurzel einer Zahl zu finden. Das Verfahren kennst du bereits
von früher: Probiere einfach alle möglichen Wurzeln durch und höre
auf, sobald du die richtige Wurzel gefunden hast. Natürlich funktioniert
dieses Berechnungsverfahren nur für Quadratzahlen korrekt.
1 def my_sqrt(zahl):
2 x = 0
3 repeat zahl:
4 if x**2 >= zahl:
5 break
6 x += 1
7 return x
8
9 eingabe = inputInt("Gib eine Zahl ein:")

c 2016, Tobias Kohn

5.2. MATHEMATISCHE FUNKTIONEN 99

10 wurzel = my_sqrt(eingabe)
11 msgDlg("Die Wurzel von", eingabe, "ist ca.", wurzel)

Die wichtigsten Punkte Funktionen definierst du wie Befehle mit

def. Das wichtigste bei einer Funktion ist, dass du am Schluss mit
return das Resultat oder Ergebnis der Funktion zurückgibst.

def Name(Parameter):
Code/Berechnung
return Resultat

Natürlich kannst du Funktionen nicht nur in der interaktiven Konsole

schreiben, sondern in all deinen Programmen!

AUFGABEN

5. Schreibe eine Funktion teiler(n), die den kleinsten Primteiler der

Zahl n sucht und zurückgibt, z. B. schreibt print teiler(45) die Zahl
3 auf den Bildschirm.

6. Schreibe eine Funktion average(a, b), die den Durchschnitt der

beiden Zahlen a und b berechnet und zurückgibt.

7. Schreibe eine Funktion sq_sum(n), die die ersten n Quadratzahlen

1 + 22 + · · · + n2 zusammenzählt und diese Summe zurückgibt.

8. Schreibe eine Funktion minimum(a, b), die von den beiden Zahlen
a und b die kleinere zurückgibt. Natürlich machst du das ohne Pythons
Funktion min zu verwenden.

9. Wie berechnest du den Abstand zweier Punkte P (x1 , y1 ) und Q(x2 , y2 )?

Du verwendest dazu den Satz des Pythagoras:
p
d = (x2 − x1 )2 + (y2 − y1 )2

Programmiere eine Funktion distance(x1, y1, x2, y2), die diesen

Abstand berechnet und zurückgibt. Teste deine Funktion mit P (7, −2),
Q(3, 1) (d = 5).

10.∗ Schreibe eine Funktion invert(z), die die Ziffern einer zweistel-
ligen Zahl z vertauscht und z. B. aus 47 die Zahl 74 macht. Wenn dir
das zu einfach ist, dann schreibe die Funktion so, dass sie alle Zahlen
von 1 bis 999 richtig behandelt.

11.∗ Eine Herausforderung für Profis: Schreibe die Funktion invert(z)

so, dass sie mit jeder natürlichen Zahl z arbeiten kann und das richtige
Ergebnis zurückgibt.

c 2016, Tobias Kohn

100 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

3 Verzweigte Funktionen

Lernziele In diesem Abschnitt lernst du:

. Funktionen mit if-Verzweigungen zu programmieren.

Einführung Üblicherweise wird eine Funktion ihr Ergebnis berech-

nen oder mit einem speziellen Verfahren suchen. Es gibt aber auch Si-
tuationen, in denen eine Funktion nur einen vorgegebenen Wert aus
einer Liste oder Tabelle heraussuchen soll. Solche Funktionen kannst
du mit einer Reihe von if-Verzweigungen programmieren. Im Zentrum
steht dann aber auch hier das return, mit dem die Funktion angibt,
was ihr Ergebnis ist.

Mit einer (natürlich unvollständigen) Tabelle kannst du die Wurzel-

√
funktion y = x so darstellen:

x 1 4 9 16 25 36 49 64
y 1 2 3 4 5 6 7 8

Diese Tabelle kannst du in einer Funktion mit dem Prinzip program-

mieren:
if x == 49:
return 7

In unserem Beispielprogramm haben wir das ein wenig erweitert, so

dass für alle Zahlen zwischen 42 und 56 das Resultat 7 ist.

Das Programm (I) Die Wurzelfunktion hier gibt nur für Werte bis
20 das «richtige» Resultat an (natürlich gerundet). Weil eine Funktion Zugegeben: Für die Wurzelbe-
aber immer mit return ein Ergebnis haben muss, geben wir für alle rechnung hat das Schema der
anderen x-Werte die falsche Lösung 0 zurück (Zeilen 10 und 11). verzweigten Funktion relativ
wenig Sinn. Es soll uns hier
1 def wurzel(x): aber genügen, um das Prinzip
2 if 0 < x <= 3: darzustellen.
3 return 1
4 elif 3 < x <= 7:
5 return 2
6 elif 7 < x <= 13:
7 return 3
8 elif 13 < x <= 20:
9 return 4
10 else:
11 return 0

c 2016, Tobias Kohn

5.3. VERZWEIGTE FUNKTIONEN 101

Das Programm (II) Das ist die selbe Funktion wie oben. Hier sind die
if-Verzweigungen allerdings binär (d. h. nach einem Ja-Nein-Schema)
aufgebaut. Dieser binäre Aufbau ist in der Informatik ziemlich wichtig
und spielt später eine grosse Rolle.
1 def wurzel(x):
2 if 0 < x <= 20:
3 if x <= 7:
4 if x <= 3:
5 return 1
6 else:
7 return 2
8 else:
9 if x <= 13:
10 return 3
11 else:
12 return 4
13 else:
14 return 0

AUFGABEN

12. Schreibe eine Funktion primzahl(index) mit Verzweigungen, die

eine der ersten vier Primzahlen 2, 3, 5, 7 zurückgibt. primzahl(3) wäre
die 3. Primzahl, also 5.

13. Schreibe eine Funktion stellen(n), die für eine beliebige natürli-
che Zahl n zwischen 1 und 99 999 angibt, wie viele Stellen die Zahl hat.
Beispiel: stellen(416) ergäbe dann 3.

14. Ein Siebtel hat die sich wiederholende Dezimaldarstellung:

1
= 0.142857 142857 142857 . . .
7
Schreibe eine Funktion siebtel(index) die für eine beliebige Nach-
kommastelle die Ziffer angibt. siebtel(3) wäre z. B. 2. Tipp: Verwen-
de den Divisionsrest x % 6.

15. Das Koordinatensystem wird in der Mathematik in vier Quadranten

eingeteilt (vgl. p. 74). Oben rechts ist der erste Quadrant, oben links
der zweite, unten links der dritte und unten rechts der dritte.
Programmiere eine Funktion quadrant(x, y), die aufgrund der Werte
von x und y den Quadranten 1 bis 4 ermittelt und zurückgibt. Pro-
grammiere die Funktion einmal linear wie das Beispielprogramm (I)
oben und einmal nach dem binären Muster wie das Programm (II).

c 2016, Tobias Kohn

102 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

4 Graphen zeichnen

Lernziele In diesem Abschnitt lernst du:

. Den Graphen einer Funktion zu zeichnen.

Einführung In der Mathematik lernst du, zu einer Funktion f (x)

den Graphen im Koordinatensystem zu zeichnen. Natürlich kann dir
das der Computer auch machen. In diesem Abschnitt zeichnen wir sol-
che Funktionsgraphen mithilfe der Turtle.

Damit die Graphen nicht zu klein werden, skalieren wir sie beim Zeich-
nen. Unser Turtlefenster hat x-Koordinaten von −400 bis +400. Wir
legen nun also unser Koordinatensystem so, dass die Funktion von −40
bis +40 gezeichnet werden. Eine Einheit entspricht also 10 Pixeln. Im
Programm erkennst du diese Skalierung daran, dass statt moveTo(x, y)
steht: moveTo(x*10, y*10).

Das Programm Das Programm zeichnet den Graphen der Funktion:

x2
f (x) = − 12
25
Diese Funktion definieren wir in den Zeilen 4 und 5. In Zeilen 7 bis 9
setzen wir die Turtle auf die Startposition. Danach gehen wir in einer
Schleife die x-Werte von −40 bis +40 durch, berechnen zu jedem x-Wert
den y-Wert und setzen die Turtle entsprechend. Wenn du nach dem
makeTurtle() noch
1 from gturtle import *
ein speed(-1) einfügst,
2 makeTurtle()
dann arbeitet die Turt-
3
le etwas schneller. Mit
4 def f(x): setPenWidth(2) wird die
5 wert = x**2 / 25 - 12 Linie des Graphen ein wenig
6 return wert deutlicher.
7
8 setPenColor("red")
9 x = -40
10 y = f(-40)
11 setPos(x*10, y*10)
12
13 repeat 80:
14 x += 1
15 y = f(x)
16 moveTo(x*10, y*10)

Die Funktion f (x) hätten wir übrigens auch so programmieren können:

c 2016, Tobias Kohn

5.4. GRAPHEN ZEICHNEN 103

def f(x):
return (x**2 / 25 - 12)

AUFGABEN

16. Baue das Programm so aus, dass zuerst das Koordinatensystem ge-
zeichnet wird, am besten sogar mit Einheiten oder einem Gitter. Du
kannst mit label("1") etc. auch Zahlen oder Text hinschreiben.

17. Ändere die Skalierung so, dass der Graph von −80 bis +80 gezeich-
net wird.

18. Lasse dir von der Turtle auch die folgenden Funktionen zeichnen.
 x 3
(15 + x)(21 − x)
(a) f1 (x) = (b) f2 (x) = −x
20 9

19. Bei diesen zwei Funktionen musst du den Bereich, den die Turtle
zeichnet anpassen, weil die Funktionen nicht für alle x-Werte definiert
sind.
√ p
(a) f3 (x) = x (b) f4 (x) = 900 − x2

20. Um was für eine mathematische Funktion handelt es sich hier? Wie
sieht ihr Graph aus?
def f(x):
if x >= 0:
return x
else:
return -x

21. Schreibe ein Programm, dass beide Funktionen f (x) und g(x) in
das gleiche Bild zeichnet.
 x 2 x
f (x) = − + x + 16, g(x) = −3
5 4

22.∗ Bestimme mithilfe der Turtlegrafik die Schnittpunkte der Funkti-

on f (x) mit der x-Achse (die sogenannten Nullstellen). Lass dir dazu

2
von der Turtle die Funktion f (x) = − x5 + x + 16 zeichnen. Da-
nach setzst du die Turtle an die Position (−400, 0) und lässt sie nach
rechts gehen, bis sie den Graphen der Funktion f (x) findet (verwende
getPixelColorStr()).

c 2016, Tobias Kohn

104 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

5 Graphen mit Polstellen*

Lernziele In diesem Abschnitt lernst du:

. Graphen von Funktionen mit Polstellen zu zeichnen.
. Mit undefinierten Werten (NaN) zu arbeiten.

Einführung Der Graph der Hyperbel y = x1 lässt sich mit unserem

Pythonprogramm nicht so ohne weiteres zeichnen. Das Problem ist die
Stelle x = 0. Dort meldet Python nämlich eine Division durch Null und
bricht das Programm ab. Das wollen in diesem Abschnitt umgehen.

Eine Stelle, an der die Funktion wegen einer Division durch Null «un-
endlich» gross oder klein (oder beides) wird heisst eine «Polstelle». Un-
sere Aufgabe wird sein, diese Polstellen richtig darzustellen. Dazu brau-
chen wir zwei Techniken: Erstens müssen wir verhindern, dass Python
durch Null Dividiert und das Programm abbricht. Zweitens müssen wir
trotzdem etwas sinnvolles zeichnen.
Ein Funktionsgraph mit einer
Die Division durch Null verhindern wir mit einer einfachen if-Verzwei- Polstelle.
gung. Neu ist hier vor allem das «NaN». Es steht für «not a number» und
bedeutet, dass sich die Funktion hier nicht berechnen lässt.
def f(x):
if x == 0:
return NaN
else:
return 1 / x

Leider lässt sich NaN bei einem Vergleich nicht wie üblich mit if x==NaN
abfragen. Du brauchst vielmehr die Funktion isnan aus dem math-
Modul:
y = f(x)
if isnan(y):
# POLSTELLE
else:
# NORMAL ZEICHNEN

Beim Zeichnen der Polstelle entsteht immer eine kleine Lücke. Wir dür-
fen also die Punkte links nicht mit den Punkten rechts verbinden. Die
Lücke sollte aber auch nicht zu gross sein. Anstelle des Punkts (x, f (x))
zeichnen wir den Graphen deshalb bis zum Punkt (x − 0.1, f (x − 0.1))
und fahren bei (x + 0.1, f (x + 0.1)) wieder weiter – bei einer Polstelle
zeichnen wir also zwei Punkte, beide möglichst nahe am undefinierten
Wert x.

c 2016, Tobias Kohn

5.5. GRAPHEN MIT POLSTELLEN* 105

Das Programm So sieht das minimale Programm aus. Die Hyperbel

1
y = xhaben wir durch y = 50 x ersetzt, weil der Graph damit etwas
schöner wird. Beachte, wie wir die Polstelle in den Zeilen 17 bis 20 mit
zwei Punkten zeichnen.
1 from gturtle import *
2 from math import isnan
3 makeTurtle()
4
5 def f(x):
6 if x == 0:
7 return NaN
8 else:
9 return 50 / x
10
11 x = -40
12 setPos(x*10, f(x)*10)
13 repeat 80:
14 x += 1
15 y = f(x)
16 if isnan(y):
17 y = f(x - 0.1)
18 moveTo(x*10-1, y*10)
19 y = f(x + 0.1)
20 setPos(x*10+1, y*10)
21 else:
22 moveTo(x*10, y*10)

AUFGABEN

23.∗ Polstellen werden in der Regel mit einer vertikalen gestrichelten

Linie angedeutet, wie in der Abbildung auf Seite 104. Ergänze das Pro-
gramm so, dass es diese gestrichelte Linie auch zeichnet.
Verwende für den Graphen selber eine Strichbreite von 2 Pixeln und
für die gestrichelte Linie und das Koordinatensysteme eine Strichbreite
von 1 Pixel.

24.∗ Zeichne auch den Graphen der Funktion:

x3 + 19x2 − 120x + 500

f (x) =
2(x − 5)(x + 24)

25.∗ Zeichne auch den Graphen des Tangens y = tan(x). Der Tangens
hat Nullstellen bei ±90◦ , ±270◦ , ±450◦ , . . .
Python arbeitet mit dem Bogenmass (Radian). Du musst also die Win-
kelangabe in Grad zuerst mit der Funktion radian umrechnen. Zudem
ist es sinnvoll, x mit 10 zu multiplizieren: y = tan(radian(x*10)).
Beide Funktionen tan und radian sind im math-Modul definiert.

c 2016, Tobias Kohn

106 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

6 Wurzeln suchen

Lernziele In diesem Abschnitt lernst du:

. Wurzeln beliebig genau zu berechnen.
. Was ein Algorithmus ist.
. Endlos-Schleifen zu programmieren.

Einführung Unsere eigene Wurzelfunktion my_sqrt(zahl) aus dem

letzten Abschnitt ist nicht besonders ausgereift. Wenn zahl keine Qua-
dratzahl ist, stimmt das Resultat relativ schlecht. In diesem Abschnitt
werden wir dieses Problem angehen und das «Berechnungsverfahren»
(Algorithmus) für Wurzeln verbessern.

Die Genauigkeit erhöhen Es gibt eine ziemlich offensichtliche ers-

te Möglichkeit, um die Genauigkeit unseres Wurzel-«Algorithmus» zu
verbessern: Wir probieren nicht alle natürlichen Zahlen durch, sondern
Hunderstel (beachte vor allem die geänderte Zeile 6): Der Computer kann die Zahl
0.01 übrigens nur mit einem
1 def my_sqrt(zahl): kleinen Rundungsfehler spei-
2 x = 0 chern. In diesem Programm
3 repeat: hier wird dieser Rundungsfeh-
4 if x**2 >= zahl: ler sichtbar. Eigentlich müsste
5 break die Funktion nämlich den Wert
6 x += 0.01 5.48 zurückgeben.
7 return x
8 print my_sqrt(30)

Hast du gesehen, dass in der Zeile 3 hinter dem repeat die Zahl fehlt?
Dadurch entsteht eine sogenannte Endlos-Schleife. Diese Schleife wird
so lange wiederholt, bis sie mit break abgebrochen wird.

Dieser Ansatz ist bereits besser, aber noch nicht perfekt. Vor allem ist
das Verfahren so auch nur auf zwei Nachkommastellen beschränkt. Na-
türlich kannst du Zeile 6 zu x += 0.001 ändern, wenn du drei Nach-
kommastellen brauchst. Aber je kleiner die Schrittweite wird, umso län-
ger braucht die Funktion, um die Wurzel zu finden. Versuche es einmal
mit my_sqrt(100000) – das dauert bereits seine Zeit!

Die Schrittweite verfeinern Die Lösung besteht darin, die Schritt-

weite nicht fest auf 1 oder 0.01 festzulegen. Vielmehr wird die Schritt-
weite jedes Mal verkleinert, wenn unsere «Wurzel» x zu gross wird.

c 2016, Tobias Kohn

5.6. WURZELN SUCHEN 107

Lass uns das am Beispiel mit zahl=30 durchgehen. Am Anfang ist die
Schrittweite 1. Python probiert also die Zahlen 0, 1, 2, 3, 4, 5 und 6 durch.
Bei 6 stellt es fest, dass 62 > 30 und geht darum zurück zu 5. Gleichzei-
tig wird die Schrittweite durch 10 geteilt, so dass sie jetzt 0.1 ist. Jetzt
probiert Python die Zahlen 5.0, 5.1, 5.2, 5.3, 5.4 und 5.5 durch. Bei 5.5
stellt es wiederum fest, dass 5.52 > 30. Entsprechend geht es zurück zu
5.4 und dividiert die Schrittweite durch 10, so dass sie jetzt 0.01 ist.

Das Programm So sieht der Algorithmus als Programm aus. Gib

dieses Programm nicht mehr in der interaktiven Konsole ein, sondern
wechsle zurück zum Editor. Dort kannst du nämlich den Debugger ak-
tivieren und wirklich Schritt für Schritt nachvollziehen, was passiert.
1 def my_sqrt(zahl):
2 x = 0
3 schritt = 1
4 repeat:
5 if x**2 == zahl:
6 break
7 if x**2 > zahl:
8 x -= schritt
9 schritt /= 10
10 if schritt < 0.00001:
11 break
12 x += schritt
13 return x
14
15 print my_sqrt(30)

Dieser Algorithmus (hier ist es mehr ein «Such-» als ein «Berechnungs-
verfahren») ist jetzt auch viel schneller als vorher. Das siehst du, wenn
du die Wurzel einer grossen Zahl wie 100 000 berechnest.

AUFGABEN

26. Warum braucht es die Zeilen 10 und 11? Was würde passieren,
wenn du diese Zeilen mit dem if schritt < 0.00001? weglässt?

27. Funktioniert der Algorithmus auch, wenn du die Zahl 10 in Zei-

le 9 änderst und z. B. schritt /= 2 oder schritt /= 100 schreibst?
Ändert sich dadurch etwas wesentliches am Algorithmus?

28. Schreibe eine Funktion cubrt(zahl), um die dritte Wurzel einer

√
3
Zahl zu finden. Also z. B. 64 = 4.

c 2016, Tobias Kohn

108 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

7 Wahr und Falsch

Lernziele In diesem Abschnitt lernst du:

. Eine Funktion zu programmieren, die prüft, ob eine komplexe Bedin-
gung erfüllt ist.
. Was die boolschen Werte True und False bedeuten.

Einführung Was passiert, wenn du in der interaktiven Konsole einen

Vergleich wie «4 < 5» oder «6*2 == 18» eingibst? Python antwortet
dir mit True (wahr) oder False (falsch). Python kennt und arbeitet
also mit speziellen Werten für «wahr» und «falsch». Tatsächlich kannst
du bei if auch direkt True oder False verwenden (auch wenn das
selten sinnvoll ist):
antwort = True
if antwort:
print "Die Antwort ist ’wahr’!"
else:
print "Die Antwort ist ’falsch’!"

Nach if muss immer etwas stehen, das True oder False ist. Wie in die-
sem kurzen Beispiel muss das aber kein Vergleich sein; hier haben wir
eine Variable mit dem Wert True definiert und weil die Variable hinter
if durch ihren Wert ersetzt wird, ist das hier dasselbe wie if True:.

Richtig praktisch wird das mit den beiden Werten True und False,
wenn du eine komplexere Bedingung hast, die du prüfen musst. Dann
kannst du die Bedingung nämlich in einer Funktion prüfen und am
Ende mit return True oder return False angeben, ob die Bedingung
erfüllt ist oder nicht.

Das Programm Das Kernstück dieses Programms ist die Funktion

isSquare(x), die für eine Zahl x prüft, ob sie eine Quadratzahl ist
oder nicht. Der Algorithmus (das Verfahren) in der Funktion wird dir
vertraut sein. Beachte dabei, dass return die Funktion/Berechnung so-
fort beendet – das Resultat der Funktion steht damit ja fest!

Weil die Funktion isSquare entweder True oder False zurückgibt,

können wir sie in Zeile 10 direkt in die if-Bedingung einsetzen.
1 def isSquare(x):
2 wurzel = 0
3 repeat x:
4 if wurzel**2 == x:

c 2016, Tobias Kohn

5.7. WAHR UND FALSCH 109

5 return True
6 wurzel += 1
7 return False
8
9 n = inputInt("Gib eine natürliche Zahl ein:")
10 if isSquare(n):
11 print n, "ist eine Quadratzahl."
12 else:
13 print n, "ist keine Quadratzahl."

Die wichtigsten Punkte Python drückt «wahr» und «falsch» mit den
beiden boolschen Werten True und False aus. Damit kannst du Funk-
tionen programmieren, die eine komplexe Bedingung überprüfen und
dann einen dieser beiden Werte mit return zurückgeben.

AUFGABEN

29. Schreibe eine Funktion isCubic(x), die prüft, ob die Zahl x eine
Kubikzahl ist, d. h. eine Zahl von der Form n3 (z. B. 8 = 23 oder 125 =
53 ). Deine Funktion gibt also bei Zahlen wie 8 und 125 True zurück
und ansonsten False.

30. Verwende die Funktion isCubic(x) aus der letzten Aufgabe und
schreibe ein Programm, das mithilfe von isCubic alle Kubikzahlen zwi-
schen 1 und 999 sucht und auf den Bildschirm schreibt.

31. Schreibe eine Funktion isPrime(n), die für eine natürliche Zahl n
prüft, ob es eine Primzahl ist. Gehe dabei einfach alle theoretisch mög-
lichen Teiler von n durch und prüfe, ob sich n teilen lässt. Achte darauf,
dass deine Funktion auch bei n = 1 die richtige Antwort zurückgibt.

32. Schreibe eine Funktion isPythagorean(a, b, c), die prüft, ob a,

b und c ein pythagoräisches Trippel ist, d. h. a2 + b2 = c2 . Achtung:
Die Funktion sollte auch dann True angeben, wenn die Zahlen in der
«falschen» Reihenfolge sind, also z. B. a2 = b2 + c2 .

33.∗ Eine perfekte Zahl ist eine Zahl x, deren Teiler (ausser x) zusam-
mengezählt gerade x ergeben. Bsp: Die Teiler von 6 sind: 1, 2, 3, 6 und
1 + 2 + 3 = 6. 6 ist also eine perfekte Zahl. Schreibe eine Funktion
isPerfect(x), die prüft ob x eine perfekte Zahl ist.
Neben 6 gibt es eine weitere perfekte Zahl, die kleiner ist als 100 und
eine dritte, die kleiner ist als 1000. Finde sie!

c 2016, Tobias Kohn

110 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

8 Primzahlen testen

Lernziele In diesem Abschnitt lernst du:

. Schneller zu prüfen, ob eine Zahl eine Primzahl ist.
. Zu messen, wie lange eine Funktion für die Berechnung braucht.

Einführung Es ist ziemlich aufwändig zu prüfen, ob eine natürli-

che Zahl n eine Primzahl ist oder nicht. Du hast im letzten Abschnitt
einen einfachen Algorithmus programmiert: Gehe alle Zahlen, die klei-
ner sind als n durch und prüfe, ob sich n durch eine dieser Zahlen
teilen lässt. Das Problem ist dabei nur, dass dieses Verfahren sehr lange
braucht! Versuche es einmal mit der Primzahl 12 504 269. . .

In diesem Abschnitt schauen wir uns an, wie wir das Verfahren (den
Algorithmus) zum Testen von Primzahlen schneller machen können.

Der erste Ansatz So sieht der erste Algorithmus aus, der prüft, ob
n eine Primzahl ist. Der Algorithmus geht alle Zahlen t von 2 bis n
durch und prüft, ob sich n durch t teilen lässt. Wenn der Algorithmus
den kleinsten (!) Primfaktor einer Zahl gefunden hat, hört er auf und
gibt zurück, dass die Zahl keine Primzahl ist. Findet er keinen kleinsten
Primfaktor, ist n selber offenbar eine Primzahl. Auch hier verwenden wir
repeat ohne eine Anzahl
1 def isPrime(n):
(vgl. 106) und nutzen aus,
2 t = 1
dass die ganze Funktion
3 repeat:
(also auch die Schleife) mit
4 t += 1
return sofort beendet wird.
5 if t >= n:
6 return True
7 if n % t == 0:
8 return False

Geschwindigkeit messen Die Geschwindigkeit des Primzahltests

kannst du ganz einfach messen, indem du die Zeit in Sekunden misst.
Falls dein Computer zu schnell sein sollte, kannst du auch eine grössere
Primzahl verwenden, z. B. 122 951 833 oder 281 702 753.
1 from time import *
2 startzeit = time()
3 isPrime(12504269)
4 endzeit = time()
5 print "Der Algorithmus hat", endzeit - startzeit,
6 print "Sekunden gebraucht."

c 2016, Tobias Kohn

5.8. PRIMZAHLEN TESTEN 111

Doppelte Geschwindigkeit Für die erste Verbesserung nutzen wir,

dass von allen geraden Zahlen 2 die einzige Primzahl ist. Wenn wir
also ganz am Anfang prüfen, ob n gerade ist, dann genügt es nachher,
wenn wir nur noch die ungeraden Zahlen durchprobieren. Beachte die
Zeile 10, wo wir die Variable t immer um zwei erhöhen und t damit
immer ungerade bleibt.
1 def isPrime(n):
2 if n % 2 == 0:
3 if n == 2:
4 return True
5 else:
6 return False
7 else:
8 t = 1
9 repeat:
10 t += 2
11 if t >= n:
12 return True
13 if n % t == 0:
14 return False

Viel Schneller In diesem dritten Schritt wird der Algorithmus noch

einmal massiv schneller. Erinnerst du dich, dass der Algorithmus hier
immer den kleinsten Primfaktor findet? Bei der Zahl 917 = 7 · 131 hört
der Algorithmus also schon bei 7 auf und nicht erst bei 131.

Wenn der Teiler t so gross ist, dass t · t grösser ist als n, dann können
wir bereits aufhören, weiter zu suchen. Bei der Primzahl 919 können
wir also bei t = 31 aufhören, weil 312 = 961 > 919. Wäre 919 nämlich
durch eine grösse Primzahl wie 37 teilbar, dann wäre der zweite Fak-
tor kleiner als 37 (919 : 37 ≈ 25) und wir hätten ihn deshalb bereits
gefunden! Die Schleife in der Funktion isPrime(n) sieht dann so aus:
1 t = 1
2 repeat:
3 t += 2
4 if t**2 == n:
5 return False
6 elif t**2 > n:
7 return True
8 if n % t == 0:
9 return False

Es lohnt sich bei aufwändigeren Algorithmen und Funktionen also, den

Algorithmus zu verbessern. Du siehst aber auch, dass es viel mehr bringt,
den Algorithmus konzeptuell zu verbessern als z. B. den Computer dop-
pelt so schnell zu machen.

c 2016, Tobias Kohn

112 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

9 Und und oder oder oder und und

Lernziele In diesem Abschnitt lernst du:

. Innerhalb von if mehrere Bedingungen miteinander zu verknüpfen.

Einführung Wie prüfst du mit if, ob zwei Bedingungen gleichzeitig

zutreffen? Mit and (und)! Das kennst du bereits aus dem Abschnitt 4.7.
Dort haben wir mit and geprüft, ob die Variablen x und y beide in einem
bestimmten Bereich liegen:
if 0 < x < 10 and 0 < y < 20:

Und wie prüfst du, ob von mehreren Bedingungen mindestens eine zu-
trifft? Mit or (oder)!
if x == 2 or x == 3 or x == 5 or x == 7:
print "x ist eine einstellige Primzahl"

Schliesslich kannst du zusammen mit not auch noch komplexere Be-

dingungen zusammenbauen. Die folgenden drei Varianten prüfen alle
genau das gleiche auf verschiedene Arten:
if (0 < x < 10) and not (x == 5): Es ist übrigens eine gute Idee,
if (0 < x < 10) and (x != 5): bei komplexeren Bedingungen
Klammern zu setzen, auch
if (0 < x < 5) or (5 < x < 10): wenn die Klammern nicht im-
mer nötig sind.

Das Programm Das Programm basiert auf einem Gesellschaftsspiel,

bei dem es darum geht, der Reihe nach alle Zahlen durchzugehen. So-
bald die Zahl durch 7 teilbar ist oder eine 7 enthält, wird die Zahl
allerdings durch das Wort «Bingo» ersetzt. Das soll jetzt der Computer
für dich machen.

Weil nicht alle Vergleiche auf eine Zeile passen, schreiben wir sie auf
zwei Zeilen (3 und 4). Damit Python aber weiss, dass es auf der nächs-
ten Zeile weitergeht, musst du das mit einem Backslash «\» ganz am
Ende der ersten Zeile anzeigen.
1 zahl = 1
2 repeat 50:
3 if (zahl % 7 == 0) or (zahl == 17) or \
4 (zahl == 27) or (zahl == 37) or (zahl == 47):
5 print "Bingo"
6 else:
7 print zahl
8 zahl += 1

c 2016, Tobias Kohn

5.9. UND UND ODER ODER ODER UND UND 113

Die wichtigsten Punkte Mit and (und) bzw. or (oder) kannst du

mehrere Bedingungen zu einer verknüpfen. Wenn du and verwendest,
dann müssen alle Teilbedingungen gleichzeitig erfüllt sein. Bei or muss
mindestens eine Teilbedingung erfüllt sein.

AUFGABEN

34. Formuliere die Bedingungen jeweils mit einem einzigen if.

(a) Die Zahl x ist durch 5 teilbar aber nicht durch 10.
(b) Die Zahl x ist durch 11, durch 13 oder durch beide teilbar.
(c) Die Zahlen x und y sind entweder beide positiv oder beide negativ.
(d) Die Zahl z ist durch 2 oder durch 3 teilbar, aber nicht beides.

35. Prüfe mit einem einzigen if, ob von den drei Zahlen a, b und c eine
die Summe der beiden anderen Zahlen ist (z. B. 3 + 4 = 7).

36. Schreibe eine Funktion, die prüft, ob von drei Zahlen a, b und c
genau zwei Zahlen gleich sind, aber nicht alle drei. Der Rückgabewert
für (1, 2, 2) wäre dann True und für (1, 2, 3) oder (4, 4, 4) False.
k
37. Fermatsche Primzahlen sind Primzahlen von der Form n = 2(2 ) +1.
Bis heute kennt man genau fünf solche Fermatschen Primzahlen:
3, 5, 17, 257, 65537.
Schreibe eine Funktion isFermatPrime(n), die prüft, ob die Zahl n
eine der fünf Fermatschen Primzahlen ist. Hinweis: Das ist eine sehr
k
einfache Aufgabe, die du lösen kannst, ohne die Form 2(2 ) + 1 zu be-
rücksichtigen.
k
38.∗ Allgemein ist eine Fermatzahl eine Zahl von der Form n = 2(2 ) +1.
Schreibe eine Funktion isFermatNumber(n), die für eine Zahl n prüft,
ob es eine Fermat-Zahl ist. Verwende dann diese Funktion zusammen
mit isPrime(n) aus dem letzten Abschnitt, um eine neue Funktion
isFermatPrime(n) zu schreiben, die mithilfe von isFermatNumber(n)
und isPrime(n) prüft, ob n eine Fermatsche Primzahl ist.
Teste deine neue Funktion mit den fünf Fermatschen Primzahlen.

c 2016, Tobias Kohn

114 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

10 Variablen: Aus alt mach neu

Lernziele In diesem Abschnitt lernst du:

. Aus dem aktuellen Wert einer Variable den neuen Wert zu berech-
nen.

Einführung Der griechische Mathematiker Heron fand einen einfa-

√
chen Algorithmus,√um die Wurzel x einer Zahl n zu berechnen: x = n.
Am Beispiel von 2 ≈ 1.414214 (n = 2) sieht Herons Algorithmus so
aus:
x0 = n2 x0 = 1
x0 + xn 1+ 12
x1 = 2
0
x1 = 2 = 1.5
x1 + xn 2
1.5+ 1.5
x2 = 2
1
x2 = 2 ≈ 1.4167
x2 + xn 2
1.4167+ 1.4167
x3 = 2
2
x3 = 2 ≈ 1.414216
x4 = · · ·

Dieses Verfahren bzw. Algorithmus kommt sehr schnell zu einem guten

(Näherungs-)Ergebnis (in der Fachsprache sagt man «der Algorithmus
konvergiert sehr schnell»). Weil in jedem Schritt genau das gleiche pas-
siert, eignet sich der Algorithmus von Heron besonders gut zur Berech-
nung mit dem Computer. In jedem Schritt wird das x nach dem Muster
n
xalt + xalt
xneu =
2
neu berechnet. Im nächsten Schritt wird dann das xneu natürlich zum
xalt – im Wesentlichen haben wir also nur ein x, das immer neu berech-
net wird.

Beim Programmieren lassen wir das «alt» und «neu» gleich ganz weg
und schreiben:
x = (x + n / x) / 2

Wichtig: Obwohl diese Zeile ein Gleichheitszeichen enthält, ist es keine

Gleichung! Python versteht Gleichungen nicht: Das Gleichheitszeichen
bedeutet für Python eine Zuweisung: Hier wird der Wert der Variable x
festgelegt.

Wenn eine Variable x links und rechts vom Gleichheitszeichen (eigent-

lich also «Zuweisungszeichen») vorkommt, dann nimmt Python immer
an, dass links ein xneu und rechts ein xalt gemeint ist. Das lässt sich
nicht ändern, sondern ist fest eingebaut.

c 2016, Tobias Kohn

5.10. VARIABLEN: AUS ALT MACH NEU 115

Das Programm Hier kommt nun Herons Algorithmus als ganzes

Programm, das die Wurzel einer Zahl n berechnet.
1 def sqrt_heron(n):
2 x = n / 2
3 repeat 10:
4 x = (x + n / x) / 2
5 return x
6
7 n = inputFloat("Wurzel berechnen aus:")
8 print "Die Wurzel aus", n, "ist", sqrt_heron(n)

Die wichtigsten Punkte Das Gleichheitszeichen bedeutet für Python

immer, dass der Variablen links ein neuer Wert zugewiesen wird. Den
neuen Wert kannst du dabei auch aus dem vorherigen Wert der Variable
berechnen. So bedeutet die Zeile
a = a * a - 3 * a

ausformuliert: aneu = aalt · aalt − 3 · aalt .

AUFGABEN

39. Schreibe die folgenden Programmzeilen nach Möglichkeit mit einer

der vier Kurzformen x += 1, x -= 1, x *= 2, x /= 2.

(a) x = x - 1 (d) x = x / 2 (g) x = x // 2

(b) x = 1 - x (e) x = 2 / x (h) x = x * 2
(c) x = 2 * x (f) x = 1 + x (i) x = x + 1

40. Ersetze im Programm oben die Zeile 4 durch folgende zwei (gleich-
wertige) Zeilen:
x_neu = (x + n / x) / 2
x = x_neu
Baue das Programm nun so aus, dass es die Schleife abbricht, wenn die
Änderung zwischen x und xneu kleiner ist als 0.001.
41. Programmiere folgenden Algorithmus: Starte mit einer beliebigen
natürlichen Zahl x und prüfe bei jedem Schritt: Wenn x gerade ist,
dann teile x durch 2, ansonsten rechne xneu = 3 · xalt + 1. Lass alle
diese Zahlen ausgeben.
Die Frage dazu lautet dann: Wie lange dauert es jeweils, bis der Algo-
rithmus zu x = 1 kommt? Es ist auch noch unbekannt, ob der Algorith-
mus tatsächlich für jeden Startwert zu 1 kommt.
Für den Startwert x = 7 ergibt sich z. B. folgende Ausgabe:
7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 -> 17
Was ist die längste solche Zahlenfolge, die du findest?

c 2016, Tobias Kohn

116 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

11 Algorithmen mit mehreren Variablen

Lernziele In diesem Abschnitt lernst du:

. Mehrere Variablen gleichzeitig zu ändern.

Einführung Algorithmen spielen eine zentrale Rolle in der Infor-

matik. Wir bauen daher den letzten Abschnitt aus und schauen uns
auch hier wieder einen solchen Algorithmus an. Im Unterschied zum
letzten Abschnitt funktioniert der Algorithmus hier mit mehreren Va-
riablen gleichzeitig: Aus zwei alten Werten xalt und yalt werden zwei
neue Werte xneu und yneu berechnet.

Kennst du die Fibonacci-Folge: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, . . .
Du siehst sicher sofort, wie diese Zahlen gebildet werden. Die nächste
Zahl ist immer die Summe der beiden letzten: 13 + 21 = 34. Weil wir
aber immer die zwei letzten Zahlen brauchen, reicht es nicht mehr, mit
x y x+y
nur einer Variablen zu arbeiten.
1 1 2
Wenn x und y jeweils die zwei letzten Zahlen der Finbonacci-Folge sind, . .
1 2 3
dann können wir den Algorithmus so darstellen:
. .
2 3 5
xneu = yalt
. .
yneu = xalt + yalt
··· ··· ···
Was nicht funktioniert ist eine der folgenden Lösungen. Warum funk-
tionieren sie nicht? Finde selber heraus, wo das Problem liegt!

x = y y = x + y
y = x + y x = y

Das Problem wird sofort ersichtlich, wenn du ein «alt» bzw. «neu» rich-
tig hinzusetzst.

xneu = yalt yneu = xalt + yalt

yneu = xneu + yalt xneu = yneu

Eine Lösung besteht darin, mit einer dritten Hilfsvariablen zu arbeiten:

summe = x + y
x = y
y = summe

In Python gibt es aber eine viel elegantere Variante. Du kannst zwei

Variablen gleichzeitig neue Werte zuweisen:
x, y = y, x+y

c 2016, Tobias Kohn

5.11. ALGORITHMEN MIT MEHREREN VARIABLEN 117

Erinnerst du dich, dass die Variablen links immer die «neuen» Werte
enthalten und rechts immer die «alten»? In der Schreibweise mit «alt»
und «neu» ist das also: xneu , yneu = yalt , xalt + yalt .

Das Programm Diese Funktion berechnet die n-te Fibonacci-Zahl

nach dem Muster, das oben beschrieben wurde.
1 def fibonacci(n):
2 x, y = 1, 1
3 repeat n-1:
4 x, y = y, x+y
5 return x

Die wichtigsten Punkte Python ist in der Lage, Berechnungen ne-

beneinander (im Prinzip also unabhängig und gleichzeitig) auszufüh-
ren. Dazu fasst du die verschiedenen Zuweisungen mit Komma zu einer
einzigen Zusammen – rechts vom Gleichheitszeichen werden immer die
aktuellen bzw. «alten» Werte der Variablen eingesetzt.

Du kannst also gleichzeitig die Differenz und die Summe zweier Zahlen
a und b berechnen mit:
a, b = a+b, a-b

AUFGABEN

42. Was bewirkt die Anweisung: «a, b = b, a»?

43. Der Algorithmus von Euklid ist ein Verfahren, um den ggT (grösster
gemeinsamer Teiler) zweier Zahlen a und b zu berechnen. Programmiere
diesen Algorithmus in Python.

• Zu Beginn muss a ≥ b gelten. Ansonsten vertausche a und b.

• Wenn a durch b teilbar ist (a % b == 0), dann ist b der ggT .
• Berechne a und b neu nach dem Muster (a % b ist hier der Rest der
Division a : b, z. B. 7 % 3 = 1):

a b a%b
490 252 238
aneu = balt . .
bneu = aalt % balt 252 238 14
. .
238 14 0

Prüfe dein Programm mit ggT (252, 490) = 14 und ggT (342, 408) = 6.

c 2016, Tobias Kohn

118 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

Quiz
12. Die folgenden vier Ausdrücke sollen eine zufällige Quadratzahl
zwischen 1 und 36 ziehen, wobei sq(x) die «Quadratfunktion»
ist. Welche dieser Ausdrücke ergibt tatsächlich auf jeden Fall
eine Quadratzahl zwischen 1 und 36?

2 a. randint(1, 6) * randint(1, 6)
2 b. randint(1, 6) ** 2
2 c. sq( randint(1, 6) )
2 d. randint(1, 36)

13. Welche dieser Funktionen quadriert eine Zahl x und liefert den
Rückgabewert x2 .

2 a. def sq(x): 2 c. def sq(x):

x**2 return x*x

2 b. def sq(x): 2 d. def sq(x):

y = x*x y = x**2
print x*x return y

14. Welche Bedingung prüft korrekt, ob eine Zahl durch 6 teilbar

ist?

2 a. if x % 2 and x % 3 == 0:
2 b. if x % 2 == x % 3:
2 c. if x % 3 == 0 or x % 2 == 0:
2 d. if x % 3 == 0 and x % 2 == 0:

15. Was bewirkt die folgende Funktion?

def foo(a, b):
if not (a < b):
a, b = b, a - b
return a

2 a. Sie liefert das Minimum der Zahlen a und b.

2 b. Sie liefert das Maximum der Zahlen a und b.
2 c. Sie vertauscht die beiden Zahlen a und b.
2 d. Sie berechnet die Differenz der beiden Zahlen a und b.

c 2016, Tobias Kohn

 KAPITELTEST 2

7. Wenn sich an einer Party n Gäste die Hände schütteln, dann gibt
es eine einfache Formel, um auszurechnen, wie oft Hände geschüttelt
werden:
n(n − 1)
h(n) =
2
Schreibe die Funktion handshake(n), die damit den entsprechenden
Wert berechnet und zurückgibt.

p
8. Der Graph der Funktion f (x) = r2 − x2 zeichnet einen Halbkreis
mit dem Radius r.

(a) Schreibe mit hilfe dieser Funktion einen Turtle-Befehl myCircle(r),

der einen Kreis mit dem angegebenen Radius r zeichnet.
(b) Erweitere deinen Befehl zu myCircle(mx, my, r), bei dem du
neben dem Radius noch die Koordinaten (mx , my ) des Mittelpunkts
angeben kannst.

1 2
9. Die Brücke im folgenden Bild basiert auf einer Parabel y = − x .
200
Zeichne mit der Turtle die Brücke, so dass der Bogen unten tatsächlich
eine Parabel ist. Je nach Grösse und Position der Brücke musst du die
Parabel natürlich anpassen.

c 2016, Tobias Kohn

120 KAPITEL 5. ALGORITHMEN UND FUNKTIONEN

10. Mit dem Algorithmus von Heron lassen sich Wurzeln sehr schnell
und genau berechnen. Der Algorithmus lässt sich auch einfach
√ abän-
3
dern, um die dritte Wurzel einer Zahl a zu berechnen, z. B. 64 = 4.
x + xa2
x0 =
2
Schreibe damit eine Funktion cbrt(a), die die dritte Wurzel einer Zahl
a berechnet und zurückgibt.

11. Zwei Zahlen a und b lassen sich auch alleine mit Addition, Subtrak-
tion und Schleifen dividieren: Ziehe die Zahl b so oft von a ab, bis das
nicht mehr möglich ist.

(a) Schreibe eine Funktion intDiv(a, b), die zwei natürliche Zahlen
a und b teilt und das Ergebnis der Ganzzahl-Division zurückgibt.
(b) Schreibe eine zweite Funktion intRest(a, b), die zwei natürli-
che Zahlen a und b teilt und den Rest der Ganzzahl-Division zu-
rückgibt.
(c) * Schreibe eine dritte Funktion numDiv(a, b), die zwei beliebige
Zahlen a und b durcheinander teilt und das Ergebnis als wissen-
schaftliche Zahl (mit Nachkommastellen) zurückgibt.
Hinweis: Hierzu brauchst du natürlich die Multiplikation bzw. Di-
vision durch 10. Weil dabei nur der Dezimalpunkt verschoben wird,
lässt sich diese Multiplikation/Division im Prinzip ohne Rechnen
durchführen und darf deshalb hier verwendet werden.

12.∗ Schreibe eine Zählerfunktion nextInt(), die der Reihe nach alle
natürlichen Zahlen zurückgibt. Beim ersten Aufruf von nextInt() ist
der Rückgabewert also 1, beim zweiten Aufruf 2, etc. Hinweis: Dazu
brauchst du globale Variablen.

c 2016, Tobias Kohn

K a p i t e l S e c h s

LISTEN

Listen enthalten nicht nur einen einzelnen Wert, sondern beliebig viele.
Sie sind wie Funktionen und Schleifen ein Kernaspekt der Programmie-
rung. Mit Listen kannst du nämlich grosse Datenmengen verwalten:
Zum Beispiel sind Musikstücke Listen von Tönen, Texte sind Listen von
Buchstaben, Bilder sind Listen von Farben und Filme sind wiederum
Listen von Bildern.

Zwei der wichtigsten Aufgaben im Zusammenhang mit Listen sind «Su-

chen» und «Sortieren». Entsprechend lernst du nicht nur, aus einer Liste
z. B. das grösste Element herauszusuchen, sondern auch, eine Liste zu
sortieren. Neben den mathematischen Anwendungen brauchen wir Lis-
ten in diesem Kapitel aber vor allem, um Bilder zu codieren. Mit diesen
Techniken kannst du dann viel kürzere Turtle-Programme schreiben.

c 2016, Tobias Kohn

122 KAPITEL 6. LISTEN

1 Listen erzeugen

Lernziele In diesem Abschnitt lernst du:

. Listen einzugeben und zu erweitern.
. Wie du prüfst, ob eine Zahl in einer Liste vorkommt.

Einführung In Python gibst du eine Liste immer mit eckigen Klam-

mern an und trennst die einzelnen Elemente (Zahlen) in der Liste durch
Kommata:
>>> primzahlen = [2, 3, 5, 7, 11, 13, 17, 19]

Mit in prüfst du, ob eine Zahl in der Liste vorkommt:

>>> 7 in primzahlen
True
>>> 12 in primzahlen
False
>>> 15 not in primzahlen
True

Schliesslich kannst du eine Liste auch fortlaufend ergänzen und neue

Elemente ans Ende anhängen (engl. «append»):
>>> [Link](23)
>>> [Link](29)

Eine Liste darf eine Zahl auch mehrfach enthalten. Du darfst sogar eine
Liste machen, die nur aus Einsen besteht: [1, 1, 1]. Wenn du möch-
test, dass jeder Wert nur einmal vorkommt, dann kombinierst du in mit
append:

>>> if 31 not in primzahlen:

[Link](31)

Das Programm Die Funktion factorize zerlegt die Zahl n in ihre

Primfaktoren und gibt alle Primfaktoren gleichzeitig zurück, und zwar
als Liste.

In Zeilen 2 und 3 beginnt die Funktion mit einer leeren Liste und dem
ersten Teiler 2. In der Schleife prüfen wir, ob n durch teiler teilbar
ist. Wenn ja, dann fügen wir diesen Teiler in Zeile 6 zur Liste hinzu und
teilen n. Ansonsten probieren wir den nächsten Teiler.
1 def factorize(n):
2 result = []

c 2016, Tobias Kohn

6.1. LISTEN ERZEUGEN 123

3 teiler = 2
4 repeat:
5 if n % teiler == 0:
6 [Link](teiler)
7 n //= teiler
8 else:
9 teiler += 1
10 if n == 1:
11 break
12 return result
13
14 print factorize(60)

Die wichtigsten Punkte Mit eckigen Klammern kannst du mehrere

Werte zu einer Liste zusammenfassen. Trenne die einzelnen Elemente
durch Kommata:
meineListe = [1, 1, 2, 3, 5]

Listen lassen sich beliebig erweitern, indem du mit append neue Werte
hinzufügst:
[Link](8)

Du prüfst mit in, ob ein Wert in einer Liste vorkommt oder nicht.

AUFGABEN

1. Schreibe ein Programm, dass alle Quadratzahlen von 12 bis 202 in

eine Liste schreibt und diese Liste am Ende ausgibt.

2. Du weisst bereits, wie du prüfst, ob eine Zahl eine Primzahl ist (vgl.
isPrime, p. 109). Schreibe damit ein Programm, das alle Primzahlen
bis 101 sucht und in eine Liste schreibt.

3.∗ Ändere das Programm aus der letzten Aufgabe so ab, dass es die
ersten hundert Primzahlen in einer Liste sammelt.

4. Mit randint aus dem Modul random kannst eine Zufallszahl ziehen
(vgl. p. 72). Schreibe ein Programm, das drei voneinander verschiedene
Zufallszahlen zwischen 1 und 9 zieht und in einer Liste sammelt. Wenn
also eine Zahl bereits in der Liste enthalten ist, dann musst du eine
neue Zufallszahl ziehen, bis du drei verschiedene Zufallszahlen hast.

5. Erweitere das Programm aus der letzten Aufgabe und schreibe ein
Programm, das eine zufällige Permutation (d. h. eine Anordnung) der
Zahlen von 1 bis 9 erzeugt. Eine solche Permutation könnte sein:
[5, 9, 1, 4, 2, 3, 8, 6, 7]

c 2016, Tobias Kohn

124 KAPITEL 6. LISTEN

2 Listen durchlaufen

Lernziele In diesem Abschnitt lernst du:

. Mit for einen weiteren Schleifentyp kennen.
. Für alle Werte in einer Liste die gleiche Berechnung durchzuführen.

Einführung Wie zählst du die Quadratzahlen von 1 bis 102 zusam-

men? Du programmierst eine Schleife, die die zehn Zahlen durchgeht:
zahl = 1
summe = 0
repeat 10:
summe += zahl**2
zahl += 1

Dieses Grundschema kommt so oft vor, dass es dafür eine andere Schreib-
weise mit Listen gibt: Die sogenannte for-Schleife.
summe = 0
for zahl in [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]:
summe += zahl

Zugegeben: Bei dieser Form mit Listen musst du die Quadratzahlen von
Hand eingeben, was mühsam sein kann. Der grosse Vorteil ist aber, dass
in der Liste keine Quadratzahlen sein müssen. Du kannst mit der for-
Schleife beliebige Zahlen durchgehen!

Das Programm (I) Auch hier verwenden wir die for-Schleife, um

die Summe zu berechnen. Im Unterschied zu oben ist die Berechnung
jetzt als Funktion verpackt und zählt die Zweierpotenzen zusammen.
1 def summe(liste):
2 resultat = 0
3 for zahl in liste:
4 resultat += zahl
5 return resultat
6
7 print summe([1, 2, 4, 8, 16, 32, 64])

Das Programm (II) Das Programm hier prüft, ob die angegebene

Zahl eine Primzahl ist. Wichtig sind hier vor allem die Zeilen 7 bis 9:
Dort setzt Python für p der Reihe nach jede Primzahl in der Liste ein
und prüft, ob zahl durch p teilbar ist. Weil die Liste der Primzahlen
unvollständig ist, funktioniert das Programm nur für Zahlen bis 840.

c 2016, Tobias Kohn

6.2. LISTEN DURCHLAUFEN 125

1 primzahlen = [2, 3, 5, 7, 11, 13, 17, 19, 23]

2
3 def isPrime(zahl):
4 global primzahlen
5 if zahl in primzahlen:
6 return True
7 for p in primzahlen:
8 if zahl % p == 0:
9 return False
10 return True

Die wichtigsten Punkte Bei einer for-Schleife setzt Python für eine
Variable der Reihe nach alle Werte in der Liste ein und führt damit die
Schleife aus. Hier wird für x zuerst der Wert 1 eingesetzt, dann 3, 6 und
schliesslich 10. Jedes Mal wird damit der «Code» ausgeführt.
for x in [1, 3, 6, 10]:
Code

AUFGABEN

6. Schreibe analog zur Summenfunktion oben eine Funktion produkt,

die das Produkt aller Zahlen in einer Liste bildet (also alle Zahlen mit-
einander multipliziert).

7. Schreibe eine Funktion last(liste), die das letzte Element in der

Liste zurückgibt.

8. Schreibe eine Funktion anzahl, die die Elemente zählt, die in einer
Liste sind. Auch hier verwendest du die gleiche Struktur wie bei der
Summenfunktion oben.

9. Den Mittelwert (engl. «average») einer Zahlenliste a, b, c berechnest

du, indem du alle Zahlen zusammenzählst und dann durch die Anzahl
teilst: M = a+b+c
3 . Schreibe eine Funktion average, die den Durschnitt
aller Zahlen in einer Liste berechnet. Ergänze dazu die Summenfunk-
tion so, dass sie nicht nur die Summe der Zahlen berechnet, sondern
gleichzeitig auch noch zählt, wie viele Zahlen in der Liste sind.

10. Ergänze die Funktion isPrime zu einem Programm, das alle Prim-
zahlen sucht, die kleiner sind als 1000. Beginne dafür mit der Liste
primzahlen = [2, 3]. Das Programm geht dann alle Zahlen bis 999
durch (verwende dazu die klassische repeat-Schleife). Wenn eine Zahl
eine Primzahl ist, wird sie mit append zur Liste der Primzahlen hinzu-
gefügt.

c 2016, Tobias Kohn

126 KAPITEL 6. LISTEN

3 Bilder aus Listen und Schleifen

Lernziele In diesem Abschnitt lernst du:

. Schleifen zu verwenden, um mit der Turtle unregelmässige Figuren
zu zeichnen.
. Bilder aus einzelnen Pixeln zu zeichnen.

Einführung Magst du dich erinnern, wie wir Schleifen mit repeat

eingeführt haben? Damals ging es darum, mit der Turtle ein regelmäs-
siges Polygon zu zeichnen, z. B. ein Sechseck:
repeat 6:
forward(100)
left(60)

Die for-Schleife ist flexibler als die repeat-Schleife, weil wir jetzt sehr
einfach die Strecken- bzw. Seitenlängen variieren können. Die Turtle
muss also nicht jedes Mal 100 Pixel vorwärts gehen. Damit lassen sich
sehr einfach auch Figuren zeichnen, die nicht regelmässig sind.

Das Programm (I) Das Programm hier zeichnet ein einfaches Häus-
chen. Dazu geht Python jede Zahl in der Liste durch: Zuerst bewegt sich
die Turtle um die angegebene Seitenlänge vorwärts, dann dreht sich die
Turtle um 45◦ nach links.
1 from gturtle import *
2 makeTurtle()
3 for seite in [100, 71, 0, 71, 100, 0, 100]:
4 forward(seite)
5 left(45)

Das Programm (II) Hier haben wir einen ganz anderen Ansatz ge-
wählt und lassen die Turtle ein Bild aus einzelnen Pixeln zeichnen. In
den Listen steht 1 für schwarz und 0 für weiss.
1 from gturtle import *
2
3 def drawLine(yPos, pixelListe):
4 setPos(0, yPos)
5 for pix in pixelListe:
6 if pix == 1:
7 dot(3)
8 forward(2)

c 2016, Tobias Kohn

6.3. BILDER AUS LISTEN UND SCHLEIFEN 127

9
10 makeTurtle()
11 setPenColor("black")
12 penUp()
13 right(90)
14 drawLine(12, [0, 0, 1, 1, 1, 0, 0])
15 drawLine(10, [0, 1, 0, 0, 0, 1, 0])
16 drawLine( 8, [1, 0, 1, 0, 1, 0, 1])
17 drawLine( 6, [1, 0, 0, 0, 0, 0, 1])
18 drawLine( 4, [1, 0, 1, 1, 1, 0, 1])
19 drawLine( 2, [0, 1, 0, 0, 0, 1, 0])
20 drawLine( 0, [0, 0, 1, 1, 1, 0, 0])
21 hideTurtle()

Die wichtigsten Punkte Mit for-Schleifen kannst du sehr einfach

einen Parameter (z. B. die Seitenlänge) bei jeder Wiederholung neu
wählen. for-Schleifen sind also dazu gedacht, etwas zu wiederholen
und dabei einen einzelnen Wert jedes Mal anders zu setzen.

AUFGABEN

11. Ergänze das Programm mit dem Häuschen so, dass es das vollstän-
dige Haus des Nikolaus zeichnet (siehe p. 11).

12. Ändere das Programm so ab, dass die Streckenlänge in forward

fest 10 Pixel ist. Dafür kann der Winkel beliebig verändert werden. Lass
die Turtle auch dann ein Häuschen zeichnen.

13.∗ Du kannst das Programm auch so anpassen, dass du sowohl den

Winkel als auch die Streckenlänge frei angeben kannst. Dazu kombi-
nierst du beide Werte zu einer einzelnen Zahl: Die «Tausender» geben
dann die Streckenlänge an, der Rest den Winkel. Das Häuschen liesse
sich dann mit der Liste [100045, 71090, 71045, 100090, 100090]
zeichnen. Schreibe das Programm dazu.

14. Baue das Pixel-Programm so aus, dass du neben schwarz und weiss
noch grau und einige Farben zur Verfügung hast. Dann könnte z. B. 1
für blau, 2 für rot, 3 für grün stehen, usw. Zeichne damit eigene kleine
Bilder!

15.∗ Schreibe ein Programm für Graustufenbilder. Für einen beliebigen

Wert x zwischen 0.0 und 1.0 (das .0 ist hier wichtig) erzeugst du das
«Grau» dazu über makeColor(x, x, x). Eine Pixelliste könnte dann
so aussehen: [0.0, 0.75, 1.0, 0.4]

c 2016, Tobias Kohn

128 KAPITEL 6. LISTEN

4 Polygone zeichnen

Lernziele In diesem Abschnitt lernst du:

. Dass Punkte in Python Tupel sind.
. Das erste Element einer Liste mit head abzufragen.

Einführung Im letzten Abschnitt hast du eine Form durch die Län-

ge der Seiten oder Winkel charakterisiert. Noch praktischer ist es aber
meistens, eine Form durch ihre Eckpunkte anzugeben. So könnte ein
Dreieck durch die Punkte A(30, 20), B(90, 30) und C(70, 90) gegeben
sein. Python und die Turtle können direkt mit solchen Punkten arbei-
ten – in Python heissen sie Tupel.
from gturtle import *
makeTurtle()
A = (30, 20)
B = (90, 30)
C = (70, 90)
setPos(A)
moveTo(B)
moveTo(C)
moveTo(A)

Punkte (Tupel) lassen sich auch zu einer Liste zusammenfassen:

dreieck = [(30, 20), (90, 30), (70, 90)]

Das erste Element einer Liste (der sogenannte «Kopf») lässt sich mit der
Funktion head ermitteln. head(dreieck) ergäbe hier also (30, 20).

Das Programm Dieses Programm zeichnet wieder ein kleines Haus,

das jetzt aber durch die Eckpunkte charakterisiert ist. Die eigentliche
Arbeit macht der Befehl drawPolygon.

Wie beim Dreieck oben müssen wir die Turtle zuerst mit setPos auf den
Anfangspunkt setzen. Die Funktion head(liste) gibt immer das erste
Element in der Liste an – hier also (40, −40). Danach gehen wir alle
Punkte in der Liste durch und zeichnen eine Linie zum neuen Punkt.
Weil das for wirklich alle Punkte durchgeht, zeichnet die Turtle zuerst
eine Linie von (40, −40) nach (40, −40), was eigentlich sinnlos ist, aber
nicht stört.
1 from gturtle import *
2

c 2016, Tobias Kohn

6.4. POLYGONE ZEICHNEN 129

3 def drawPolygon(shape):
4 setPos(head(shape))
5 for point in shape:
6 moveTo(point)
7 moveTo(head(shape))
8
9 haus = [(40, -40), (40, 40), (0, 80),
10 (-40, 40), (-40, -40)]
11 makeTurtle()
12 drawPolygon(haus)

Übrigens lassen sich aus einem Punkt wie A(30, 20) auch die beiden Ko-
ordinaten zurückgewinnen, und zwar mit x, y = A – hier wäre jetzt
x = 30 und y = 20. Damit könntest du die for-Schleife auch so schrei-
ben und damit die Figur um 10 Pixel nach rechts verschieben:
for (x, y) in shape:
moveTo(x + 10, y)

Die wichtigsten Punkte Bei jeder Liste gibt head(liste) das erste
Element zurück.

AUFGABEN

16. Du kannst eine Figur ausfüllen, indem du fillToPoint() verwen-

dest. Die Turtle nimmt dann den aktuellen Punkt und verbindet alle
weiteren Punkte mit diesem ersten Punkt, so dass eine Fläche entsteht.
setPos(72, 46)
fillToPoint() # Alle Punkte mit (72, 46) verbinden
moveTo(91, 64)
moveTo(118, 25)
fillOff() # Punkte nicht mehr verbinden
Verwende diese Technik, um einem Befehl fillPolygon zu schreiben,
der die gegebene Figur ausfüllt.

17. Verwende die Technik mit «for (x, y) in shape», um die Figur
zu skalieren und z. B. doppelt so gross zu zeichnen.

18.∗ Ein Tupel muss nicht aus Koordinaten bestehen, sondern kann be-
liebige Zahlen zusammenfassen, z. B. auch einen Winkel und eine Sei-
tenlänge. Nutze das aus, um eine Figur durch die Winkel und Seiten-
längen zu charakterisieren und dann mit for zu zeichnen.

c 2016, Tobias Kohn

130 KAPITEL 6. LISTEN

5 Minimum und Maximum

Lernziele In diesem Abschnitt lernst du:

. Das Minimum oder Maximum einer Liste zu finden.

Einführung Wie findest du das Minimum (oder Maximum) einer

Liste? Du weisst sicher noch, wie du das Minimum von zwei Zahlen fin-
dest. Und wie sieht es bei drei Zahlen aus? Eine Funktion dafür könnte
so aussehen:
def minimum(a, b, c):
result = a
if b < result:
result = b
if c < result:
result = c
return result

Erkennst du das Prinzip dahinter? Beantworte die folgenden zwei Fra-

gen: Was musst du ändern, damit die Funktion das Maximum zurück-
gibt? Was musst du ändern, damit die Funktion mit vier Zahlen arbei-
tet?

Jetzt dürftest du auch problemlos verstehen, wie du das Minimum einer

Liste findest:
def minimum(liste):
result = head(liste)
for x in liste:
if x < result:
result = x
return result

Das Programm Wieviel Platz braucht ein Bild bzw. eine Grafik? Stell
dir vor, du möchtest einen Rahmen um deine Grafik zeichnen. Wie gross
muss der Rahmen sicher sein?

Im letzten Abschnitt hast du ein Bild aus Punkten gezeichnet. Das kann
eine beliebige Figur sein und dazu bestimmen wir in diesem Programm
die linke untere Ecke, die der kleinste Rahmen um die Figur haben
müsste (dieser Rahmen heisst auch «Bounding Box»).
1 def lowerLeft(shape):
2 minX, minY = head(shape)
3 for (x, y) in shape:

c 2016, Tobias Kohn

6.5. MINIMUM UND MAXIMUM 131

4 if x < minX:
5 minX = x
6 if y < minY:
7 minY = y
8 return (minX, minY)
9
10 haus = [(40, -40), (40, 40), (0, 80),
11 (-40, 40), (-40, -40)]
12 print lowerLeft(haus)

Bei diesem Haus ist die linke untere Ecke natürlich (−40, −40). Versu-
che andere Figuren aus und vergleiche die Ergebnisse dann.

AUFGABEN

19. Schreibe eine zweite Funktion upperRight(shape), die die rechte

obere Ecke einer beliebigen Figur zurückgibt.

20. Schreibe noch eine Funktion, die die linke obere Ecke der Figur
ermittelt.

21. Schreibe einen Turtle-Befehl frame(shape), der einen möglichst

kleinen Rahmen um die gegebene Figur zeichnet. Dafür kannst du na-
türlich direkt die Funktionen lowerLeft und upperRight verwenden.
Dabei kannst du die beiden Koordinaten wiederum direkt übernehmen:
(x, y) = lowerLeft(shape)

22. Schreibe eine Funktion getWidth(shape), die die Breite der ge-
samten Figur ermittelt.

23.∗ Schreibe einen Befehl drawCentered(shape), der nicht nur die

Figur zeichnet. Vielmehr ermittelt dein Befehl zuerst die Bildgrösse und
verschiebt dann die ganze Figur so, dass sie in der Mitte des Fensters
gezeichnet wird.

24.∗ Schreibe einen Befehl drawBig(shape), der die Figur möglichst

gross zeichnet. Dein Befehl zentriert die Figur also nicht nur, sondern
streckt die einzelnen Koordinaten so, dass die Figur gerade noch ins
Turtlefenster hineinpasst.

c 2016, Tobias Kohn

132 KAPITEL 6. LISTEN

6 Einfache Zahlenlisten

Lernziele In diesem Abschnitt lernst du:

. Mit der range-Funktion Listen zu erzeugen.

Einführung Im Zusammenhang mit for-Schleifen sind Listen zwar

ganz nützlich. Aber du kommst oft in Situationen, in denen du nicht die
ganze Liste wirst aufschreiben wollen oder können. Ein solches Beispiel
wäre die Aufgabe: «Zähle alle Quadratzahlen von 12 bis 2002 zusam-
men.» – Die Liste wäre mit 200 Elementen viel zu gross zum Aufschrei-
ben.

Python hat für die einfachste Art von Listen eine Funktion parat, die dir
die Liste direkt erzeugt: range(n). Der Parameter n gibt die Anzahl der
Elemente an.
>>> range(7)
[0, 1, 2, 3, 4, 5, 6]
>>> range(12)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Die range-Liste beginnt immer mit 0 und hört bei n − 1 auf. Dass
range(12) von 0 bis 11 geht und nicht von 1 bis 12 führt leider im-
mer wieder zu Fehlern.

Das Programm Das Programm zählt alle ungeraden Quadratzah-

len von 12 bis 992 zusammen und gibt diese Summe aus. In Zeile 2
verwenden wir ein range(50), um die for-Schleife für alle Zahlen von
0 bis 49 durchzugehen und damit unsere Liste von ungeraden Zahlen
zu erzeugen.
1 ungeradeZahlen = []
2 for i in range(50):
3 [Link](1 + i*2)
4
5 summe = 0
6 for zahl in ungeradeZahlen:
7 summe += zahl ** 2
8 print summe

Im Prinzip hätten wir die ungeraden Zahlen auch so erzeugen können:

ungeradeZahlen = []
for i in range(100):
if i % 2 == 1:
[Link](i)

c 2016, Tobias Kohn

6.6. EINFACHE ZAHLENLISTEN 133

Die wichtigsten Punkte Die Funktion range(n) gibt dir direkt die
Liste mit den n Zahlen von 0 bis n − 1 zurück. Das ist in for-Schleifen
oft sehr hilfreich.

Tatsächlich gibt es repeat n-Schleifen nur in TigerJython! Alle ande-

ren Dialekte von Python verwenden immer ein for i in range(n)
dafür. Wenn du also einmal nicht mit TigerJython arbeitest, dann den-
ke daran, anstatt repeat die for-Schleifen zu verwenden.

Im Prinzip kannst du bei range(start, stop) auch einen Startwert

angeben. range(4, 9) erzeugt dann z. B. die Liste [4, 5, 6, 7, 8].

Für Profis: List-Comprehensions* Python kennt eine sehr kurze

Schreibweise, um mit range Listen zu erzeugen:
ungeradeZahlen = [i*2+1 for i in range(50)]

Diese Schreibweise heisst List-Comprehension.

AUFGABEN

25. Erzeuge mit der Hilfe von range die Liste:

[14, 17, 20, 23, 26, 29, 32, 35].

26. Verwende range, um eine Liste mit den Stammbrüchen 11 , 12 , 13 , . . . , 1

9
zu erzeugen.

27. Du kannst pythagoräische Zahlentripel auch in Python als Tripel

schreiben, z. B. (3, 4, 5). Verwende for-Schleifen mit range, um ei-
ne Liste mit allen pythagoräischen Zahlentripeln zu erstellen, wobei die
drei Zahlen alle zwischen 1 und 99 liegen sollen (0 < x < 100):
[(3, 4, 5), (5, 12, 13), ...]

c 2016, Tobias Kohn

134 KAPITEL 6. LISTEN

7 Elemente zählen

Lernziele In diesem Abschnitt lernst du:

. Lauflängen zu bestimmen.
. Binäre Listen zu komprimieren.

Einführung Auf Seite 127 hast du gesehen, dass Schwarz-Weiss-

Bilder aus binären Listen bestehen, also aus Listen, die nur aus 0 und
1 bestehen. Solche Listen lassen sich in den allermeisten Fällen viel
kürzer schreiben, indem du sie komprimierst.

Um eine binäre Liste zu komprimieren, zählst du jeweils, wie viele Nul-

len oder Einsen nacheinander stehen (das ist ein sogenannter «Lauf»,
engl. «run») und schreibst diese Zahl in eine neue Liste:

[0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0] → [3, 5, 1, 3, 5, 2, 3]

Damit diese Kompression eindeutig ist, vereinbaren wir, dass zuerst

immer die Nullen gezählt werden. Aus [1, 1, 0, 0, 0, 1] wird dann also
[0, 2, 3, 1].

Das Programm Es ist einfach, in einer Schleife alle Zahlen in einer

Liste durchzugehen und zu zählen. Die Schwierigkeit besteht darin zu
entdecken, ob die Zahlen von 0 nach 1 wechseln oder umgekehrt. Das
erreichen wir, indem wir in der Variable letzteZahl immer die letzte
Zahl speichern und dann vergleichen, ob die aktuelle Zahl noch gleich
ist wie die letzte.
1 def compress(binaryList):
2 result = [] # Enthaelt alle Lauflaengen
3 laufLaenge = 0 # Die aktuelle Lauflaenge
4 letzteZahl = 0 # Zuerst immer Nullen zaehlen
5 for zahl in binaryList:
6 if zahl != letzteZahl:
7 [Link](laufLaenge)
8 laufLaenge = 0
9 laufLaenge += 1
10 letzteZahl = zahl
11 [Link](laufLaenge)
12 return result
13
14 print compress([1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1])

c 2016, Tobias Kohn

6.7. ELEMENTE ZÄHLEN 135

Gehen wir in Gedanken einmal die Liste [0, 0, 0, 1, 1, 0] durch. Weil wir
sowieso mit Null beginnen, zählen wir bei den ersten drei Nullen ein-
fach eins zur Variable laufLaenge dazu. Wenn wir zur ersten 1 kom-
men, dann sind letzteZahl und zahl nicht mehr gleich. Die Variable
laufLaenge enthält den Wert 3, den wir jetzt an die Resultat-Liste an-
fügen. Dann setzen wir laufLaenge auf Null, um wieder von vorne zu
beginnen.

AUFGABEN

28. Was für einen Unterschied macht es, wenn du in der Zeile 4 schreibst:
letzteZahl = head(binaryList)

29. Schreibe eine Funktion get(liste, index), die aus einer Liste
das n-te Element heraussucht und zurückgibt. Zum Beispiel würde dann
get([2, 3, 5, 7, 11], 4) den Wert 7 zurückgeben.

30. Schreibe die Umkehrfunktion decompress(runListe), die aus ei-

ner Liste mit den Läufen wieder die ursprüngliche binäre Liste herstellt.

31. Schreibe einen Befehl drawPicture(breite, hoehe, pixelListe),

der analog zur Seite 127 ein Schwarz-Weiss-Bild aus den Pixeldaten
zeichnet. Die pixelListe wird hier allerdings komprimiert angegeben
und muss daher zuerst dekomprimiert werden.

32.∗ Schreibe eine Funktion longestOneRun(binList), die die längs-

te Lauflänge von Einsen aus der Liste zurückgibt. Dazu musst du zuerst
alle Lauflängen von Einsen in einer Liste sammeln und dann aus dieser
Liste das Maximum heraussuchen.

33.∗ Das Verfahren der Lauflängen-Kompression kannst du an sich nicht

nur auf binäre Listen anwenden (allerdings werden die meisten ande-
ren Listen nur geringfügig oder gar nicht kleiner). Es genügt dann aber
nicht mehr, nur die Lauflänge zu speichern, sondern du brauchst auch
die Zahl dazu:

[4, 4, 4, 6, 3, 3, 3, 3, 3, 1, 1, 4] → [(4, 3), (6, 1), (3, 5), (1, 2), (4, 1)]

Schreibe eine Funktion compressAny(liste), die eine Liste auf diese

Weise zusammenfasst und verwende Tupel für die Kombinationen aus
Zahl und Lauflänge.

c 2016, Tobias Kohn

136 KAPITEL 6. LISTEN

8 Sortieren

Lernziele In diesem Abschnitt lernst du:

. Eine Liste mit Zahlen zu sortieren.
. Ein Element aus einer Liste zu entfernen.
. Wichtige Listenfunktionen kennen.

Einführung Zwei der wichtigsten Aufgaben in der Informatik über-

haupt sind «suchen» und «sortieren». Das Sortieren ist unter anderem
deshalb wichtig, weil es viel schneller geht, etwas in einer sortierten
Liste zu suchen. Eines der mächtigsten Unternehmen der Welt – Google
– basiert darauf, die Webseiten im Internet sortieren und damit eine
Suchfunktion anzubieten.

Für das Sortieren gibt es sehr gute und schnelle Algorithmen. In diesem
Abschnitt schauen wir uns allerdings einen etwas langsameren Algo-
rithmus an, der dafür gut verständlich ist.

Das Programm Unser Algorithmus in der Funktion sortList sucht

zuerst das kleinste Element x in der Liste. Dieses kleinste Element wird
mit [Link](x) (Zeile 7) aus der Liste entfernt und ans Ende
der neuen Liste result angehängt. Das Sortier-Programm hat
in Python einen kleinen
1 def sortList(liste): Schönheitsfehler: Wenn du in
2 result = [] der Funktion sortList mit
3 repeat: [Link] Elemente
4 if liste == []: entfernst, dann werden diese
5 break Elemente auch in der Origi-
6 x = min(liste) nalliste entfernt (und nicht
7 [Link](x) nur in der Funktion). Du
8 [Link](x) kannst das beheben, indem
9 return result du die Liste zw. Zeilen 2 und
10 3 mit liste = liste[:]
11 print sortList([5, 8, 1, 3, 6]) kopierst.

Neben min gibt es noch andere Listenfunktionen. len gibt zum Beispiel
die Anzahl der Elemente in der Liste an. Damit hätten wir die Funktion
auch so programmieren können:
1 def sortList(liste):
2 result = []
3 repeat len(liste):
4 x = min(liste)

c 2016, Tobias Kohn

6.8. SORTIEREN 137

5 [Link](x)
6 [Link](x)
7 return result

Übrigens: Die Sortierfunktion arbeitet grundsätzlich auch mit Strings:

sortList(["Hund", "Zebra", "Fisch", "Ameise", "Katze"])

Die wichtigsten Punkte Während [Link](x) das Element x

zur Liste hinzufügt, entfernt [Link](x) das Element x aus der
Liste. Achtung: Wenn x nicht in der Liste vorkommt, dann gibt Python
einen Fehler aus.

Python kennt fünf wichtige eingebaute Funktionen für Listen:

• head(liste) gibt das erste Element der Liste an,

• len(liste) gibt die Länge (Anzahl der Elemente) der Liste an,
• min(liste) gibt das kleinste Element der Liste zurück,
• max(liste) gibt das grösste Element der Liste zurück,
• sum(liste) zählt alle Elemente in der Liste zusammen.

AUFGABEN

34. Ändere die Funktion sortList so ab, dass die Liste absteigend sor-
tiert wird, d. h. mit dem grössten Element beginnt.

35. Verwende die eingebauten Funktionen und schreibe damit eine Funk-
tion average(liste) (vgl. p. 125), die den Durchschnitt einer Liste
berechnet und zurückgibt, ohne eine Schleife zu verwenden.

36. Schreibe eine Funktion reverseList(liste), die die Reihenfol-

ge der Elemente in einer Liste umdreht. Aus [2, 4, 7, 3] wird also
[3, 7, 4, 2].

37. Schreibe eine Funktion rotate(liste), die das erste Element der
Liste wegnimmt und am Ende wieder anhängt. Aus [2, 4, 7, 3] wird
also [4, 7, 3, 2].

38.∗ Schreibe eine zusätzliche Funktion rotateMin(liste), die die

Liste solange «rotiert», bis sie mit dem kleinsten Element beginnt.

c 2016, Tobias Kohn

138 KAPITEL 6. LISTEN

9 Listen in Listen*

Lernziele In diesem Abschnitt lernst du:

. Listen und for-Schleifen zu verschachteln.
. Bilder zu laden und darzustellen.

Einführung Im Abschnitt 6.3 (Seite 126) haben wir im zweiten Pro-

gramm ein Bild aus einzelnen Pixeln gezeichnet. Dabei haben wir jede
Zeile als eine Liste von 0-1-Werten angelegt, die weiss und schwarz
symbolisiert haben. Dabei ist die Struktur
drawLine(12, [0, 0, 1, 1, 1, 0, 0])
drawLine(10, [0, 1, 0, 0, 0, 1, 0])
...
drawLine( 0, [0, 0, 1, 1, 1, 0, 0])

so regelmässig, dass es sich geradezu anbietet, hier mit einer for-Schleife

zu arbeiten. Dazu müssen wir die einzelnen Pixel-Zeilen wiederum in
eine Liste setzen:
bilddaten = [
[0, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 0, 0, 1, 0],
...
[0, 0, 1, 1, 1, 0, 0]
]
y = 12
for line in bilddaten:
drawLine(y, bilddaten)
y -= 2

Das Programm Die Turtle zeichnet in diesem Programm einen klei-

nen Farbverlauf aus einzelnen Pixeln. Das Bild wird ganz am Anfang als
Variable picture definiert: Eine Liste, in der jede Zeile wiederum eine In der hexadezimalen Notati-
Liste ist. Die einzelnen Farbwerte sind als hexadezimalwerte angegeben, on werden die drei Farbwerte
was für Farben eine sehr praktische Notation ist. rot, grün und blau mit jeweils
zwei «Ziffern» pro Farbe zu-
1 from gturtle import * sammengeschrieben. Dabei ist
2 picture = [ FF der höchste Wert und 00
3 [0xFF0000, 0xDD0000, 0xBB0000, 0x990000, 0x770000], der niedrigste. Diese Notation
4 [0xFFFF00, 0xDDDD00, 0xBBBB00, 0x999900, 0x777700], wird auch z. B. in «HTML»-
5 [0x00FF00, 0x00DD00, 0x00BB00, 0x009900, 0x007700], Dateien verwendet, dort al-
6 [0x00FFFF, 0x00DDDD, 0x00BBBB, 0x009999, 0x007777], lerdings als #C574A1 anstatt
7 [0x0000FF, 0x0000DD, 0x0000BB, 0x000099, 0x000077] 0xC571A1.
8 ]

c 2016, Tobias Kohn

6.9. LISTEN IN LISTEN* 139

9 makeTurtle()
10 speed(-1)
11 heading(90)
12 penUp()
13
14 y = 10
15 for line in picture:
16 setPos(-10, y)
17 for pixel in line:
18 setPenColor(makeColor(pixel))
19 dot(5)
20 forward(5)
21 y -= 5
22 hideTurtle()

Die Bilddaten, die wir hier in den Zeilen 2 bis 8 eingegeben haben,
kannst du auch direkt aus einer Bilddatei laden. Dazu gibt es die Funk-
tion loadImageData im Modul «tjaddons»:
from tjaddons import loadImageData

picture = loadImageData("[Link]")

Die wichtigsten Punkte Du darfst Listen und for-Schleifen auch

ineinander verschachteln. Das ist besonders bei Bildern sehr praktisch.
Die Funktion loadImageData("Dateiname") lädt dir direkt ein Bild
aus einer Datei als eine Liste von Listen, die du dann mit der Turtle
zeichnen kannst.

AUFGABEN

39. Lade mit loadImageData wie oben beschrieben ein Bild aus einer
Grafikdatei und lass es von der Turtle zeichnen. Verwende ein Bild, das
nicht zu gross ist!

40. Mit len(picture) erhältst du die Bildhöhe in Pixeln. Finde eine

Möglichkeit, um auch die Bildbreite zu bestimmen. Schreibe dann ein
Programm, das ein beliebiges Bild in der Fenstermitte zentriert anzeigt.

41. Du hast im Abschnitt 6.3 gesehen, wie du auch Grafiken bzw. Figu-
ren in einer Liste darstellen kannst. Entsprechend kannst du eine Folge
von Figuren als Liste von Listen darstellen. Verwende diese Technik, um
einen kurzen Text (z. B. deinen Namen) zu codieren und von der Turtle
zeichnen zu lassen.

c 2016, Tobias Kohn

140 KAPITEL 6. LISTEN

10 Histogramme zeichnen

Lernziele In diesem Abschnitt lernst du:

. Listen mit einem Histogramm zu visualisieren.

Einführung Ein typischer Anwendungsbereich für Listen ist die Sta-

tistik. Du weisst auch bereits, wie du den Durchschnitt der Zahlen in
einer Liste berechnen kannst. Jetzt geht es darum, die Zahlen in einer
Liste auch graphisch darzustellen und zwar mit einem Balkendiagramm
(Historgramm).

Das Programm Das Programm enthält zwei wesentliche Befehle.

drawBar zeichnen einen Balken mit der angegebenen Höhe an der Po-
sition (x, y). drawBars zeichnet das ganze Histogramm für die Zahlen
in der Liste. Dank Zeile 12 wird das Histogramm in der Mitte des Fens-
ter gezeichnet.
1 from gturtle import *
2
3 def drawBar(x, y, height):
4 setPenWidth(6)
5 setPenColor("maroon")
6 setPos(x, y)
7 moveTo(x, y + height * 10)
8 setPenColor("white")
9 moveTo(x, 300)
10
11 def drawBars(values):
12 x = -5 * len(values)
13 for v in values:
14 drawBar(x, 0, v)
15 x += 10
16
17 makeTurtle()
18 hideTurtle()
19 drawBars([5, 9, 2, 3, 7, 1, 16])

In den Zeilen 8 und 9 zeichnen wir über den eigentlichen Balken noch
einen weissen Balken bis ganz nach oben. Wenn du nämlich in den
Aufgaben nachher ein Histogramm mit einem neuen übermalst, dann
sollen die alten Balken entfernt werden.

c 2016, Tobias Kohn

6.10. HISTOGRAMME ZEICHNEN 141

AUFGABEN

42. Das Programm oben kann nur positive Zahlenwerte darstellen. Än-
dere das Programm so ab, dass es auch negative Zahlenwerte darstellen
kann. Die Balken gehen dann natürlich nach unten. Zeichne dazu auch
eine dünne horizontale Grundlinie.
Tipp: Der Grund, warum drawBar nur positive Zahlen darstellen kann,
liegt beim weissen Übermalen.

43. Gestalte die Balken interessanter, indem du einen Schatten oder

3D-Effekt hinzufügst. Einen Schatten kannst du z. B. so erzeugen:
setPenColor("black")
setPos(x+1, y+2)
moveTo(x+1, y+height+2)
setPenColor("maroon")
setPos(x-1, y)
moveTo(x-1, y+height)

44.∗ In Zeile 7 im Programm wird die Höhe mit 10 multipliziert, da-

mit die Balken besser sichtbar werden. Schreibe das Programm so um,
dass es diese Skalierung automatisch so wählt, dass der höchste Balken
ungefährt eine Höhe von 200 Pixeln erreicht.

45. Programmiere ein sich veränderndes Histogramm. Lade dazu aus

dem «time»-Modul den Befehl sleep(s). Mit sleep(0.5) wartet das
Programm dann eine halbe Sekunde, bevor es weiterfährt. Verwende
dann die folgende Idee, um ein Histogramm zu machen, das seine Bal-
ken mit der Zeit immer mehr angleicht, bis alle etwa gleich hoch sind:
drawBars([5, 9, 2, 3, 7, 1, 16])
sleep(0.5)
drawBars([5, 8, 3, 4, 6, 3, 14])

46.∗ Schreibe eine Programm, das den Wurf zweier Würfel simuliert
(verwende dazu randInt(), vgl. p. 72). Das Programm würfelt also
zehnmal mit zwei Würfeln und schreibt die geworfenen Zahlen nach-
einander in eine Liste wuerfe. Nach zehn Würfen wird die Liste aus-
gezählt: Wie viele Einsen, Zweien, Dreier etc. wurden geworfen? Das
ergibt eine neue Liste anzahlen, die genau sechs Elemente enthält.

[4, 6, 1, 1, 3, 1, 4, 4, 3, 2, 1, 6, 1, 3] → [5, 1, 3, 3, 0, 2]

Diese Liste anzahlen stellst du dann als Histogramm dar.

Ergänze jetzt das Programm so, dass es jede halbe Sekunde 10 neue
Zahlen würfelt und zur Liste wuerfe hinzufügt. Danach zählst du die
Augenzahlen neu aus und stellst sie wiederum graphisch dar. Du solltest
dann auf dem Bildschirm beobachten können, wie sich das Histogramm
mit den Würfelzahlen langsam entwickelt.

c 2016, Tobias Kohn

142 KAPITEL 6. LISTEN

11 Datenbanken*

Lernziele In diesem Abschnitt lernst du:

. In einer Liste eine kleine Datenbank anzulegen.

. Ein Quiz mit einer Datenbank zu programmieren.

Einführung Eine Liste kann weit mehr als nur Zahlen enthalten. In
diesem Abschnitt enthält unsere Liste eine kleine Datenbank.

Jeder Eintrag in der Liste ist ein Tupel mit genau den gleichen vier
Angaben. Natürlich kannst du genausogut eine Datenbank aufbauen,
in der jeder Eintrag nur zwei oder aber mehr als vier Angaben enthält.
Zum Beispiel könntest du die Datenbank in unserem Beispiel mit der
Bevölkerungszahl ergänzen.

Das Programm: Daten In diesem Programm definieren wir zuerst

eine kleine Datenbank mit einigen Ländern, deren Hauptstädten, den
Landesflächen in km2 und dem Kontinent. Die Funktion areaOfCountry
gibt dann die Fläche eines Landes zurück, indem die Funktion in der
Datenbank das entsprechende Land heraussucht. Dabei ignorieren wir
die Hauptstadt und den Kontinent.

1 # (Land, Hauptstadt, Fläche in km^2, Kontinent)

2 geoDatenbank = [
3 ("Frankreich", "Paris", 543998, "Europa"),
4 ("Grossbritannien", "London", 242900, "Europa"),
5 ("USA", "Washington", 9372614, "Amerika"),
6 ("Schweiz", "Bern", 41285, "Europa"),
7 ("Deutschland", "Berlin", 357026, "Europa"),
8 ("Österreich", "Wien", 83858, "Europa"),
9 ("Italien", "Rom", 301341, "Europa"),
10 ("Kanada", "Ottawa", 9970610, "Amerika")
11 ]
12
13 def areaOfCountry(country):
14 for (land, stadt, flaeche, kontinent) in geoDatenbank:
15 if land == country:
16 return flaeche
17 return 0
18
19 print areaOfCountry("Schweiz")

c 2016, Tobias Kohn

6.11. DATENBANKEN* 143

Das Programm: Filtern Dieses Programm verwendet wieder die glei-

che Datenbank wie oben. Hier geht es nun darum, die Daten zu filtern.
Dabei erstellen wir eine neue Liste mit allen Städten in Europa. Die
neue Liste enthält dann nur noch die Städte und das zugehörige Land.
1 staedte = []
2 for (land, stadt, flaeche, kontinent) in geoDatenbank:
3 if kontinent == "Europa":
4 [Link]((stadt, land))
5 print staedte

Das Programm: Quiz Dieses dritte Programm ist ein kleines Quiz,
das dich nach den Hauptstädten der Länder fragt. Achte beim Einge-
ben der Antworten darauf, dass auch die Gross- und Kleinschreibung
stimmen muss.
1 for (land, stadt, flaeche, kontinent) in geoDatenbank:
2 frage = "Wie heisst die Hauptstadt von " + land + "?"
3 antwort = input(frage)
4 if antwort == stadt:
5 print "Richtig!"
6 else:
7 print "Falsch! Richtig wäre " + stadt + "."

AUFGABEN

47. Schreibe eine Funktion countryOfCity(stadt), die zu einer ge-

gebenen Hauptstadt das Land sucht und zurückgibt.

48. Schreibe eine Funktion largerThan(groesse), die in einer Lis-

te alle Länder sammelt, die mindestens die angegebene Grösse haben.
Diese Liste wird dann mit return zurückgegeben.

49. Schreibe eine Funktion continentSize(kontinent), die die Flä-

chen aller Länder eines Kontinents zusammenzählt und zurückgibt. Rich-
tig Sinn ergibt die Funktion natürlich nur dann, wenn du die Datenbank
noch erweiterst.

50. Ergänze das Quiz so, dass es die Anzahl der richtigen Antworten
mitzählt und am Ende ausgibt.

51. Schreibe ein Programm, das die obige «geoDatenbank» nach der
Landesgrösse (Fläche) sortiert und dann die Länder so sortiert ausgibt,
angefangen bei der Schweiz bis hin zu Kanada.

c 2016, Tobias Kohn

144 KAPITEL 6. LISTEN

c 2016, Tobias Kohn

K a p i t e l S i e b e n

ANIMATION

Im Kapitel über Animation lernst du das Rüstzeug, um deine eigenen

kleinen Spiele zu programmieren. Dazu gehört zum Beispiel, dass du
deine Spielfigur mit der Tastatur steuern kannst oder dass du weisst,
wie du die Schwerkraft simulieren kannst. Mit der gleichen Technik
lassen sich aber auch physikalische Simulationen programmieren, etwa
das Sonnensystem in dem Planeten um die Sonne kreisen.

Die meisten Beispiele und Aufgaben sind hier mit einem «roten Ball»
geschrieben, den wir animieren und herumspringen lassen. Natürlich
kannst du aber jederzeit deine eigenen Figuren zeichnen und program-
mieren.

Besonders gegen Ende des Kapitels werden die Programme immer grös-
ser. Damit wirst du immer mehr selber programmieren und ausarbeiten
müssen. Achte dabei darauf, dass du deine Programme sauber struktu-
rierst und dokumentierst (aus Platzgründen mussten wir die Kommen-
tare oft weglassen).

c 2016, Tobias Kohn

146 KAPITEL 7. ANIMATION

1 Tastatursteuerung

Lernziele In diesem Abschnitt lernst du:

. Auf Tastatureingaben zu reagieren.
. Die Turtle mit der Tastatur zu steuern.

Einführung In diesem Abschnitt geht es noch nicht um die eigent-

liche Animation. Vielmehr zeigen wir dir, wie du deine Turtle mit den
Pfeiltasten auf deiner Tastatur steuern kannst. Das ist ganz nützlich,
wenn du später z. B. ein Spiel programmieren möchtest.

Das Kernstück ist die Funktion getKeyCodeWait(). Sie wartet bis du

eine Taste drückst und gibt dann den Code der Taste zurück. Zu jeder
Taste auf deiner Tastatur gehört eine eindeutige Zahl. Die «Enter»-Taste
hat z. B. den Code «10», die «Escape»-Taste oben links den Code «27».
Je nach Programm musst du jeweils zuerst kurz herausfinden, welchen
Code eine spezielle Taste hat, um damit arbeiten zu können.

Das Programm In diesem Programm steuerst du nun die Turtle mit

den Pfeiltasten. Zuerst definieren wir die Codes für die vier Pfeil- und
die Escapetaste. Danach kommt eine Endlos-Schleife, die jeweils auf
die Tasten reagiert. Die Werte für die Tasten hier
sind nicht zufällig! «ESCA-
1 from gturtle import * PE» hat immer den Wert
2 makeTurtle() «27» und im Prinzip könn-
3 ten wir auch direkt schreiben:
4 ESCAPE = 27 if key == 27:. Die Defini-
5 LEFT = 37 tionen am Anfang machen das
6 UP = 38 Programm aber lesbarer und
7 RIGHT = 39 leichter verständlich.
8 DOWN = 40
9
10 repeat:
11 key = getKeyCodeWait()
12 if key == ESCAPE: # Bei ESCAPE die
13 break # Schleife abbrechen
14 if key in [LEFT, UP, RIGHT, DOWN]:
15 if key == LEFT:
16 heading(-90)
17 elif key == UP:
18 heading(0)
19 elif key == RIGHT:
20 heading(90)

c 2016, Tobias Kohn

7.1. TASTATURSTEUERUNG 147

21 elif key == DOWN:

22 heading(180)
23 forward(10)
24 else:
25 print "Falsche Taste!"
26 dispose() # Turtle-Fenster schliessen

Falls du die Codes weiterer Tasten wissen möchtest, dann füge nach
Zeile 11 ein print key ein. Damit wird dir bei jeder gedrückten Taste
der Code ausgegeben.

Die wichtigsten Punkte Mit getKeyCodeWait() aus dem gturtle-

Modul kannst du eine Taste einlesen und dann auf die Taste reagieren,
indem du z. B. die Turtle bewegst.

AUFGABEN

1. Ergänze das Programm oben so, dass du mit den Tasten «Y», «R»,
«B», «G» eine der Farben gelb, rot, blau oder grün auswählen kannst
(natürlich kannst du auch andere oder weitere Farben verwenden).

2. Mit fillToPoint() und fillOff() (vgl. p. 129) kannst du sehr

einfach steuern, ob die Turtle nur Umrisse oder ausgefüllte Flächen
zeichnet. Ergänze das Programm so, dass du sowohl Linien als auch
Flächen zeichnen kannst.

3. Anstatt mit heading und forward zu arbeiten, kannst du die Turtle

auch steuern, indem du mit getX() und getY() ihre aktuelle Positi-
on ermittelst und dann moveTo verwendest. Schreibe das Programm
so um, dass es ohne heading und forward auskommt und dafür mit
moveTo arbeitet.

4.∗ Wenn du die Leertaste drückst, soll die Turtle in die gleiche Rich-
tung weitergehen wie im Schritt zuvor. Mit heading und forward ist es
sehr einfach, das einzuprogrammieren. Verwende aber getX(), getY()
und moveTo, um dieses Verhalten zu programmieren.

5.∗ Verwende den Zahlenblock rechts auf der Tastatur, um die Turtle
zu steuern, und zwar so, dass die Turtle auch schräg gehen kann. Achte
darauf, dass sie trotzdem im Gitter bleibt.

c 2016, Tobias Kohn

148 KAPITEL 7. ANIMATION

2 Ping Pong

Lernziele In diesem Abschnitt lernst du:

. Einen roten Ball zu animieren, der hin- und herspringt.
. Den Computer mit sleep zu verlangsamen.

Einführung Jede Animation beruht auf dem gleichen Grundprin-

zip: Du zeichnest deine Szene mindestens 25 Mal in der Sekunde neu.
Zwischen dem Neuzeichnen kannst du jeweils die Position oder Form
deiner Figuren verändern, so dass eine Bewegung entsteht.

Damit du die Animation siehst, darf sie aber auch nicht zu schnell sein.
Computer können im Prinzip das Bild mehrere Tausend Male pro Se-
kunde neu zeichnen. Das ist aber nicht sinnvoll. Deshalb verlangsamen
wir den Computer mit sleep(0.01) so, dass das Bild «nur» 100 Mal in
der Sekunde neu gezeichnet wird.

Das Programm In diesem Programm «rollt» ein roter Ball hin und
her. Links und rechts haben wir bei ±150 eine unsichtbare Wand ge-
setzt: Sobald der Ball dorthin kommt, kehren wir die Richtung um,
indem wir das Vorzeichen von speedX wechseln.

Mit paintBall("white") (Zeile 18) übermalen wir den Ball an der

aktuellen Position bevor wir ihn mit paintBall("red") (Zeile 20) neu
zeichnen. Dazwischen wird die Position posX um speedX verändert, so
dass sich der Ball bewegt.

In Zeile 25 verwenden wir eine Variante von getKeyCodeWait(): Das

wait im Namen fehlt und zeigt damit an, dass diese Funktion nicht
wartet, bis eine Taste gedrückt wird, sondern sofort zurückkehrt. Wenn
keine Taste gedrückt wird, dann ist das Ergebnis von getKeyCode()
Null. Damit können wir die Animation so lange fortsetzten bis du eine
beliebige Taste drückst.
1 from gturtle import *
2 from time import sleep
3
4 posX = 0
5 speedX = 2
6
7 def paintBall(color):
8 setPenColor(color)
9 setPos(posX, 0)

c 2016, Tobias Kohn

7.2. PING PONG 149

10 dot(21)
11
12 def update():
13 global posX, speedX
14 if posX >= 150:
15 speedX *= -1
16 if posX <= -150:
17 speedX *= -1
18 paintBall("white")
19 posX += speedX
20 paintBall("red")
21
22 makeTurtle()
23 hideTurtle()
24 repeat:
25 key = getKeyCode()
26 if key != 0:
27 break
28 update()
29 sleep(0.01)
30 dispose()

Die wichtigsten Punkte Das Kernstück jeder Animation ist eine Schlei-
fe, die unendlich lange wiederholt wird, in jedem Durchgang update()
aufruft, um alles zu bewegen und dann eine kurze Zeit wartet. Natür-
lich musst du den Befehl update() entsprechend definieren.
repeat:
update()
sleep(0.01)

AUFGABEN

6. Schreibe das Programm oben so um, dass sich der Ball nicht hori-
zontal sondern vertikal (nach oben und unten) bewegt.

7. Ergänze das Programm so, dass sich der Ball sowohl horizontal als
auch vertikal bewegt und in jeder Richtung (oben, unten, links, rechts)
eine unsichtbare Wand hat, an der er abprallt. Wähle als Anfangsrich-
tung z. B. speedX = 2 und speedY = 0.5.

8. Ergänze das Programm um eine globale Variable color mit der Far-
be des Balls und wechsle jedes Mal, wenn der Ball seine Richtung än-
dert die Farbe (verwende mehr als zwei Farben).

9. Schreibe ein Programm, in dem die Turtle die Rolle des Balls über-
nimmt und hin- und herläuft.

c 2016, Tobias Kohn

150 KAPITEL 7. ANIMATION

3 Alles fällt: Gravitation

Lernziele In diesem Abschnitt lernst du:

. Objekte zu beschleunigen und nach unten fallen zu lassen.

Einführung Im Einfluss der Gravitation (Schwerkraft) bewegt sich

unser Ball immer schneller nach unten. Das erreichst du, indem du die
vertikale Geschwindigkeit speedY in jedem Schritt veränderst.

Ein Ball, der sich im Fenster bewegt hat zwei Variablen posX und posY
für seine aktuelle Position und zwei Variablen speedX und speedY für
seine Geschwindigkeit. Wenn du hier in jedem Schritt von speedY eins
abziehst, dann entsteht bereits der Eindruck von Schwerkraft, die den
Ball nach unten zieht:
def update():
global posX, posY, speedY
# Hier den Ball löschen
speedY -= 1
posX += speedX
posY += speedY
# Hier den Ball neu zeichnen

Der tatsächliche Wert bei speedY -= 1 hängt davon ab, wie stark die
Gravitation sein soll. Meistens nimmst du hier einen viel kleineren Wert,
z. B. speedY -= 0.1. Eine wichtige Rolle spielt hier auch der Wert in
sleep(0.01): Je schneller die Animation läuft, umso kleiner musst du
die Schwerkraft machen!

Das Programm Du kennst das Programm an sich bereits: Es ist ein

roter Ball, der über den Bildschirm «fliegt». Neu ist hier nur die Schwer-
kraft, die wir in Zeile 15 eingebaut haben.
1 from gturtle import *
2 from time import sleep
3
4 posX, posY = -200, -100
5 speedX, speedY = 3, 4
6
7 def paintBall(color):
8 setPenColor(color)
9 setPos(posX, posY)
10 dot(21)
11

c 2016, Tobias Kohn

7.3. ALLES FÄLLT: GRAVITATION 151

12 def update():
13 global posX, posY, speedY
14 paintBall("white")
15 speedY -= 0.05
16 posX += speedX
17 posY += speedY
18 paintBall("red")
19
20 makeTurtle()
21 hideTurtle()
22 repeat:
23 if posY < -300:
24 break
25 update()
26 sleep(0.01)
27 dispose()

Übrigens beenden wir hier das Programm nicht, wenn du eine Taste
drückst, sondern wenn der Ball aus dem Fenster fliegt (Zeilen 23/24).

AUFGABEN

10. Lass den Ball vom Boden abspringen wie ein elastischer Gummi-
ball. Die Technik dazu kennst du bereits: Sobald die y-Koordinate klei-
ner ist als −200 kehrst du die y-Richtung um (vgl. p. 148). Schau, dass
der Ball auch links und rechts abprallt und nicht aus dem Fenster fliegt.
Und natürlich musst du die Abbruchbedingung wieder so ändern, dass
das Programm aufhört, wenn du eine Taste drückst.

11. Um es realistischer zu machen soll der Ball bei jedem Aufprall am

Boden einen Teil seiner Energie verlieren. Das erreichst du z. B. mit
speedY *= 0.95.

12. Programmiere einen nicht-elastischen Ball, der einfach nach unten

fällt, aber nur bis etwa y = −200 und dann stehen/liegen bleibt. Wenn
der Ball also den Boden erreicht hat, springt er nicht mehr nach oben,
fällt aber auch nicht mehr weiter nach unten.

13.∗ Setze den Boden auf den genauen Wert von y = −200. Dabei tritt
folgendes Problem auf: Je nach Geschwindigkeit kann es sein, dass der
Ball von der y-Position −198 direkt zu −205 geht, ohne −200 selber
zu erreichen. Damit der Ball nicht durch den Boden fällt, setzst du in
diesem Fall natürlich einfach posY = -200. Aber: Wenn jetzt der Ball
wieder nach oben springt, dann ist seine nächste Position −193 – er
springt dann also höher als vorher und hat irgendwie mehr Energie
erhalten. Löse dieses Problem und sorge dafür, dass der Ball nie höher
springt als am Anfang!

c 2016, Tobias Kohn

152 KAPITEL 7. ANIMATION

4 Mehrere Objekte bewegen

Lernziele In diesem Abschnitt lernst du:

. Mehrere Objekte gleichzeitig zu bewegen.

Einführung Die Animation wird gleich viel interessanter, wenn du

mehrere Bälle im Spiel hast, die sich bewegen. Natürlich könntest du
dazu für jeden Ball eigene Variablen ball1_posX, ball1_posY, etc.
verwenden, aber letztlich wäre das eine grausam mühsame Methode.
Viel einfacher geht es, wenn du alle Bälle in einer Liste hast.

Jeder Ball wird durch vier Werte repräsentiert: Zwei für die Position
und zwei für die Richtung und Geschwindigkeit. (30, 52, 1, -3)
steht für einen Ball an der Position (30, 52), der sich in Richtung (1, −3)
bewegt und daher als nächstes die Koordinaten (31, 49) haben wird.

Das Programm Die Grundstruktur ist dir bereits bestens vertraut.

Der Unterschied zu den vorherigen Programmen liegt darin, dass an
die Stelle der Variablen posX, speedY etc. jetzt eine Liste balls mit
Werten für alle Bälle getreten ist (du kannst diese Liste selber nach
Belieben ausbauen).

Weil wir nicht einfach einzelne Werte in einer Liste verändern können,
sammeln wir alle bewegten Bälle zuerst in einer neuen Liste balls2
und ersetzen erst ganz am Schluss der Berechnungen die alte Liste
balls durch die neue Liste balls2 mit den neuen Koordinaten der
Bälle (Zeilen 18 bis 27). Im Befehl paintBalls brau-
chen wir die Angaben speedX
1 from gturtle import *
und speedY eigentlich nicht.
2 from time import sleep
In Zeile 11 müssen wir sie aber
3
trotzdem dazu nehmen, weil
4 # Format: (posX, posY, speedX, speedY) sie fest zu den Werten in der
5 balls = [(-50, 100, 1.5, -1), Liste gehören.
6 (80, -40, -2, 3)]
7
8 def paintBalls(color):
9 global balls
10 setPenColor(color)
11 for (posX, posY, speedX, speedY) in balls:
12 setPos(posX, posY)
13 dot(21)
14
15 def update():
16 global balls

c 2016, Tobias Kohn

7.4. MEHRERE OBJEKTE BEWEGEN 153

17 paintBalls("white")
18 balls2 = []
19 for (posX, posY, speedX, speedY) in balls:
20 posX += speedX
21 posY += speedY
22 if posX < -250 or posX > 250:
23 speedX *= -1
24 if posY < -250 or posY > 250:
25 speedY *= -1
26 [Link]((posX, posY, speedX, speedY))
27 balls = balls2
28 paintBalls("red")
29
30 makeTurtle()
31 hideTurtle()
32 repeat:
33 if getKeyCode() != 0:
34 break
35 update()
36 sleep(0.01)
37 dispose()

AUFGABEN

14. Baue auch hier die Gravitation noch ein, so dass die Bälle nach
unten fallen und am Boden wieder hochspringen.

15. Zeichne zuerst eine Box, in der sich die Bälle bewegen und so dass
die Wände sichtbar sind, an denen die Bälle abprallen. Dazu musst du
aber auch sicherstellen, dass die Bälle nicht über die Wand hinausgehen
(z. B. mit if posX > 250: posX = 250). Beachte auch, dass die Bälle
selber eine Dicke haben und die Wand hier bei x = 260 sein müsste.

16. Schreibe das Programm so um, dass die Bälle links und rechts nicht
mehr an den Wänden anprallen. Wenn ein Ball rechts aus dem Bild
geht, soll er einfach von links her wieder hineinkommen.

17.∗ Im Programm oben besteht jeder Ball aus vier Werten für seine
Position und Geschwindigkeit. Ergänze die Liste mit einem fünften Wert
für die Ballfarbe und zeichne damit die Bälle in verschiedenen Farben.
Das ist eine grössere Änderung am Programm, weil du jetzt z. B. für
das Löschen (d. h. weiss übermalen) der Bälle einen eigenen Befehl
eraseBalls schreiben musst. Vergiss auch nicht, dass du die Farbe
auch in update() drin jeweils von der alten in die neue Liste über-
nehmen musst.

c 2016, Tobias Kohn

154 KAPITEL 7. ANIMATION

5 Plattformen und Schattenwurf*

Lernziele In diesem Abschnitt lernst du:

. Mit Plattformen (Böden) in verschiedenen Höhen zu arbeiten.

Einführung Du kennst sicher die Jump-and-Run-Spiele, bei denen

eine Spielfigur von Plattform zu Plattform springt. In diesem Abschnitt
zeigen wir dir das Grundprinzip dahinter: Du musst nicht nur die Platt-
formen zeichnen, sondern auch für jeden Punkt (x, y) herausfinden
können, welches die nächste Plattform darunter ist. Die Spielfigur soll
ja nicht durch den Boden fallen, sondern auf den Plattformen stehen
können.

Das Bild auf der Seite zeigt eine typische Situation. In diesem Fall spie-
len die Plattformen A und B keine Rolle. A ist zu hoch (über dem Ball)
und B ist auf der Seite (neben dem Ball). Von den Plattformen C und
D, die direkt unter dem Ball sind ist C die höher gelegene und damit
die gesuchte.

Das Programm In diesem Programm lassen wir den Ball noch nicht
an den Plattformen abprallen, sondern zeichnen jeweils einen Schatten
unter dem Ball. Die zentrale Funktion hier ist getGroundLevel(x, y).
Sie berechnet für jeden Punkt, auf welcher Höhe die nächste Plattform
darunter liegt. Das Programm hier ist so um-
fangreich, dass wir einige Zei-
1 from gturtle import *
len kürzen mussten. Du weisst
2 from time import sleep
aber aus den vorhergehenden
3
Programm bereits, wie du den
4 # Ball: Position und Geschwindigkeit: Ball zeichnest, wie die Schleife
5 posX, posY = 0, 100 am Ende aussieht, etc.
6 speedX, speedY = 2, 1
7
8 # Plattformen im Format (left, right, height):
9 platforms = [(-210, -150, -100), (-40, 160, -20)]
10
11 # Den Boden und die Platformen zeichnen:
12 def drawGround():
13 setPenColor("chocolate")
14 setPenWidth(10)
15 setPos(-250, -270)
16 moveTo(250, -270)
17 for left, right, height in platforms:
18 setPos(left, height)
19 moveTo(right, height)

c 2016, Tobias Kohn

7.5. PLATTFORMEN UND SCHATTENWURF* 155

20
21 # Die Höhe des Bodens unter (x, y) angeben.
22 def getGroundLevel(x, y):
23 result = -270
24 for left, right, height in platforms:
25 if (left < x < right) and (height < y):
26 if height > result:
27 result = height
28 return result
29
30 def drawBall(color):
31 ...
32
33 def drawShadow(color):
34 y = getGroundLevel(posX, posY)
35 setPenColor(color)
36 setPos(posX-10, y)
37 moveTo(posX+10, y)
38
39 def update():
40 global posX, posY, speedX, speedY
41 drawBall("white")
42 drawShadow("chocolate")
43 posX += speedX
44 ...
45 drawBall("red")
46 drawShadow("brown")
47
48 makeTurtle()
49 hideTurtle()
50 drawGround()
51 repeat:
52 ...

Übrigens: Wenn der Ball gerade über dem «Rand» einer Plattform ist,
dann wird der Schatten etwas über die Plattform hinausgezeichnet und
die Plattformen verlängern sich dadurch ein wenig. Wir nehmen das
hier in Kauf, damit das Programm nicht zu kompliziert wird.

AUFGABEN

18. Schreibe das Programm so um, dass der rote Ball an den einzelnen
Plattformen abprallt, anstatt einen Schatten zu zeichnen.

19.∗ Eine kleine Herausforderung: Programmiere ein kurzes «Labyrinth»,

in dem der Ball von den Wänden abprallt und so die Gänge entlang
springt. Dazu brauchst du natürlich horizontale und vertikale Plattfor-
men als Wände.

c 2016, Tobias Kohn

156 KAPITEL 7. ANIMATION

6 Objekte mit Variablen

Lernziele In diesem Abschnitt lernst du:

. Objekte zu erstellen und mit ihnen zu arbeiten.
. Die Variablen in einem Objekt zu verändern.

Einführung Wenn du mehrere Bälle animierst, dann hat jeder dieser

Bälle eine eigene Position und Geschwindigkeit. Du brauchst also für
jeden Ball eigene Variablen wie posX, posY, etc. Mit Objekten kannst
du genau das machen.

Ein Objekt ist wie eine Variable, die selber wiederum Variablen enthält.
Objekte sind also Container, die andere Variablen enthalten, aber sel-
ber keinen festen Wert haben. Mit makeObject erzeugst du ein neues
Objekt und gibst dabei die Variablen an, die es enthalten soll:
roterBall = makeObject( posX = -50, posY = 100 )

Anschliessend kannst du mit diesen Variablen [Link] und

[Link] wie gewohnt arbeiten:
Erstelle einige Objekte in der
[Link] += 5
interaktiven Konsole und sieh
print [Link], [Link] dir im Debuggerfenster rechts
an, wie diese Objekte tatsäch-
Auf den ersten Blick sieht es aus, als könntest du die Variablen auch lich Variablen enthalten.
einfach etwa «roterBallPosX» nennen. Im nächsten Abschnitt wirst
du aber sehen, dass Objekte viel mächtiger sind und einiges mehr kön-
nen.

Das Programm In den Zeilen 4 bis 7 definieren wir zwei Bälle als
Objekte. Jedes Objekt hat fünf Variablen für die Position, Geschwin-
digkeit und die Farbe. Das restliche Programm kennst du bereits von
früher: Wie bewegen die beiden Bälle über den Bildschirm. Neu ist viel-
leicht, dass wir in Zeile 12 das ganze Fenster löschen anstatt die Bälle
einzeln weiss zu übermalen.
1 from gturtle import *
2 from time import sleep
3
4 ball_1 = makeObject( posX = -50, posY = 100,
5 speedX = 1.5, speedY = -1,
6 color = makeColor("red") )
7 ball_2 = makeObject( posX = 50, posY = 120,
8 speedX = -1.2, speedY = -0.5,

c 2016, Tobias Kohn

7.6. OBJEKTE MIT VARIABLEN 157

9 color = makeColor("blue") )
10
11 def update():
12 clear()
13 ball_1.posX += ball_1.speedX
14 ball_1.posY += ball_1.speedY
15 setPos(ball_1.posX, ball_1.posY)
16 setPenColor(ball_1.color)
17 dot(21)
18 ball_2.posX += ball_2.speedX
19 ball_2.posY += ball_2.speedY
20 setPos(ball_2.posX, ball_2.posY)
21 setPenColor(ball_2.color)
22 dot(21)
23
24 makeTurtle()
25 hideTurtle()
26 repeat:
27 if getKeyCode() != 0:
28 break
29 update()
30 sleep(0.01)
31 dispose()

Die wichtigsten Punkte Mit makeObject() erzeugst du ein neu-

es Objekt, das (beliebig viele) eigene Variablen enthalten kann. Wenn
kugel ein Objekt ist, das eine Variable radius enthält, dann musst du
diesen Wert immer als [Link] ansprechen.

AUFGABEN

20. Füge den beiden Ball-Objekten eine sechste Variable radius hin-
zu, die die Grösse des Balls angibt und zeichne die Bälle dann auch
entsprechend.

21.∗ Ergänze update() so, dass sich die beiden Bälle gegenseitig an-
ziehen. Dazu berechnest du zuerst die Distanz in x- und y-Richtung
zwischen den beiden Bällen und änderst dann die Geschwindigkeit ent-
sprechend, z. B. so:
ball_1.speedX += distX / 100
ball_2.speedX -= distX / 100

22.∗ In der Physik lassen sich viele Anziehungskräfte (z. B. Gravitation)

zwischen zwei Dingen mit Abstand d soqberechnen:
dX dY
aX = C · 3 aY = C · 3 d = d2X + d2Y
d d
Dabei gibt die Konstante C die Stärke der Anziehung an. Programmiere
damit eine Anziehung zwischen den beiden Bällen.

c 2016, Tobias Kohn

158 KAPITEL 7. ANIMATION

7 Objekte als Parameter

Lernziele In diesem Abschnitt lernst du:

. Verschiedene Objekte mit der gleichen Funktion zu bearbeiten.

Einführung Objekte sind Container, die verschiedene Variablen ent-

halten. Wenn zwei Objekte die gleichen Variablen (aber mit unterschied-
lichen Werten) enthalten, dann kannst du beide Objekte mit dem glei-
chen Code bearbeiten. Darin liegt die grosse Stärke von Objekten.

In diesem Codestück enthalten die beiden Objekte ball_1 und ball_2

beide die Variablen posX und posY für die Position. Damit können wir
beide mit der gleichen Funktion paintBall zeichnen.
def paintBall(anyBall):
setPos([Link], [Link])
dot(21)

ball_1 = makeObject( posX = 30, posY = 50 )

ball_2 = makeObject( posX = 20, posY = 14 )
paintBall( ball_1 )
paintBall( ball_2 )

Das Programm Das Programm ist im Wesentlichen das gleiche Pro-

gramm wie im letzten Abschnitt. Jetzt nutzen wir aber aus, dass alle
Bälle die gleiche Struktur haben (sie enthalten Variablen für die Positi-
on und Geschwindigkeit) und verwenden eine Funktion (updateBall),
um einen beliebigen Ball zu zeichnen.
1 from gturtle import *
2 from time import sleep
3
4 def updateBall(ball):
5 [Link] += [Link]
6 [Link] += [Link]
7 setPos([Link], [Link])
8 setPenColor([Link])
9 dot(21)
10
11 def update():
12 clear()
13 updateBall(ball_1)
14 updateBall(ball_2)
15

c 2016, Tobias Kohn

7.7. OBJEKTE ALS PARAMETER 159

16 ball_1 = makeObject( posX = -50, posY = 100,

17 speedX = 1.5, speedY = -1,
18 color = makeColor("red") )
19 ball_2 = makeObject( posX = 50, posY = 120,
20 speedX = -1.2, speedY = -0.5,
21 color = makeColor("blue") )
22
23 makeTurtle()
24 hideTurtle()
25 repeat:
26 if getKeyCode() != 0:
27 break
28 update()
29 sleep(0.01)
30 dispose()

AUFGABEN

23. Erstelle eine Liste mit Ball-Objekten nach dem Muster:

balls = [makeObject(posX = -50, posY = 100),
makeObject(posX = 50, posY = 120)]
Und verwende dann in update() eine for-Schleife, um alle Bälle zu
bewegen und neu zu zeichnen.

24. Ändere das Programm so ab, dass die Bälle unterschiedliche Radien
haben. Zudem sollen sie liegen bleiben und sich nicht mehr bewegen,
wenn sie den unteren Bildschirmrand erreicht haben.

25. Ergänze das Programm so, dass auf Tastendruck neue Bälle erzeugt
werden, die ganz oben am Fenster beginnen, nach unten zu fallen. Je-
der Ball soll eine eigene zufällige Farbe und einen zufällig Radius ha-
ben.
Hier musst du mit einer Liste wie in der Aufgabe 7.23 arbeiten. Dann
kannst du neue Bälle mit append(makeObject(...)) hinzufügen.

26.∗ Baue das Programm schliesslich so aus, dass Bälle auch von den
Seitenwänden abprallen und die Gravitation sie nach unten zieht.

27.∗ Schreibe ein Programm mit mehreren Bällen, die sich beliebig be-
wegen. Berechne in jedem Schritt die Koordinaten des Schwerpunkts
und zeichne ihn mit einem Kreuz auf dem Bildschirm ein.
x1 + x2 + x3 + · · · + xn y1 + y2 + y3 + · · · + yn
sX = sY =
n n

c 2016, Tobias Kohn

160 KAPITEL 7. ANIMATION

8 Punkte fangen

Lernziele In diesem Abschnitt lernst du:

. Farbe zu animieren.

Einführung In diesem Abschnitt animieren wir nicht in erster Linie

eine Bewegung, sondern die Farbe unserer Punkte. Ein Punkt soll je-
weils hell aufleuchten und dann mit der Zeit im dunklen Hintergrund
verschwinden.

Dazu nutzen wir aus, dass Farben im Computer aus den drei Kanälen
«Rot», «Grün» und «Blau» bestehen. Jeder Farbkanal hat einen Wert
zwischen 0.0 (dunkel) und 1.0 (hell). Wir setzen also am Anfang die
Farbe z. B. auf (1.0, 1.0, 0.0) für «Gelb» und ziehen dann immer
1
100 ab. Dadurch wird die Farbe immer dunkler, bis wir mit (0, 0, 0)
Schwarz haben.

Das Programm In diesem Programm haben wir einen Punkt, den

wir mit einem Objekt modellieren. Die Variable ball_1.index gibt die
Helligkeit an.

In Zeile 8 ziehen wir vom Farbindex eins ab, damit die Farbe immer
dunkler wird. Wenn der Farbindex 0 erreicht hat, dann setzen wir ihn
zurück auf 100 % und wählen eine neue zufällige Position.
1 from gturtle import *
2 from time import sleep
3 from random import randint
4
5 ball_1 = makeObject(posX = 0, posY = 0, index = 100)
6
7 def updateBall(ball):
8 [Link] -= 1
9 if [Link] <= 0:
10 [Link] = 100
11 [Link] = randint(-300, 300)
12 [Link] = randint(-200, 200)
13 setPos([Link], [Link])
14 setPenColor(makeColor(0.0, [Link] / 100, 0.0))
15 dot(21)
16
17 def update():
18 updateBall(ball_1)
19

c 2016, Tobias Kohn

7.8. PUNKTE FANGEN 161

20 @onMouseClicked
21 def mouseClick(x, y):
22 print x, y
23
24 makeTurtle()
25 hideTurtle()
26 clear("black")
27 repeat:
28 update()
29 sleep(0.01)

In den Zeilen 20 bis 22 definieren wir eine Funktion mouseClick und

geben mit @onMouseClicked an, dass diese Funktion ausgeführt wer-
den soll, wenn du mit der Maus ins Turtlefenster geklickt hast. In den
Aufgaben wirst du diese Funktion dann ausbauen.

AUFGABEN

28. Ändere Zeile 15 ab zu dot(21 * (100 - [Link]) / 100).

Dadurch wird der Punkte mit der Zeit immer grösser. Programmiere
dann auch umgekehrt, dass der Punkt beim Verschwinden immer klei-
ner wird.

29. Ergänze das Programm so, dass es mit drei Punkten arbeitet, die
verschiedene Farben haben.
Damit nicht alle drei Punkte gleichzeitig verblassen und neu gesetzt
werden setzst du den Index auf unterschiedliche Anfangswerte.

30.∗ Schreibe das Programm so um, dass es mit einem weissen Hinter-
grund funktioniert und die Punkte immer heller/weisser werden.

31. Du sollst das Programm nun so erweitern, dass es erkennt, ob du

mit der Maus auf einen Punkt geklickt hast (am besten beginnst du dazu
mit einem einzelnen Punkt). Dazu musst du die Entfernung zwischen
dem Mausklick (x, y) und dem Mittelpunkt des farbigen Punkts ball_1
berechnen. Das machst du mit dem Satz des Pythagoras:
q
2 2
d = (x − xball ) + (y − yball )

Schreibe die Funktion mouseClick so, dass entweder «Treffer!» oder

«Daneben!» ausgegeben wird.

32. Erweitere das Punkte-Fangen-Programm so, dass es die Anzahl der

Punkte zusammenzählt, die du erwischt hast.

33.∗ Baue das Spiel mit dem Punkte-Fangen so aus, dass die Punkte zu
Beginn langsam sind und immer schneller werden. Dazu verwendest
du am besten eine neue Variable ball_1.speed.

c 2016, Tobias Kohn

162 KAPITEL 7. ANIMATION

9 Ping Pong spielen

Lernziele In diesem Abschnitt lernst du:

. Einen Ping-Pong-Schläger mit der Maus zu steuern.
. Einen Ball vom Ping-Pong-Schläger abprallen zu lassen.

Einführung Nachdem du die meisten Grundlagen für die Animation

jetzt hast, programmierst du in diesem Abschnitt ein einfaches Ping-
Pong, bei dem du selbst mit der Maus mitspielst.

Das Programm Der Ping-Pong-Schläger heisst hier «Shuttle» und

hat eine Variable x-Koordinate und eine feste y-Koordinate bei −150.
In den Zeilen 33 bis 36 sorgen wir dafür, dass der Schläger immer die
x-Koordinate der Maus hat, wenn sich die Maus bewegt.

Für das Programm zentral sind die Zeilen 12 bis 18. In Zeile 12 prüfen
wir, ob der Ball soweit nach unten gefallen ist, dass er jetzt auf der
Höhe des Schlägers oder darunter ist (der Schläger hat eine Breite von
6 Pixeln und der Ball einen Radius von 5 Pixeln; daher berührt der
Ball den Schläger bereits, wenn der Mittelpunkt des Balls bei −142 ist).
In der Zeile 13 testen wir, ob der Ball genau über dem Schläger (mit
Länge 40) liegt und damit wieder nach oben abprallt. Wenn nicht, dann
beenden wir das Programm in Zeile 18 mit dem exit.
1 from gturtle import *
2 from time import sleep
3 from sys import exit
4
5 shuttle_X = 0
6 ball = makeObject( posX = -50, posY = 200,
7 speedX = 0.5, speedY = -1.2 )
8
9 def updateBall():
10 [Link] += [Link]
11 [Link] += [Link]
12 if [Link] <= -142:
13 if shuttle_X - 20 <= [Link] <= shuttle_X + 20:
14 [Link] = -142
15 [Link] *= -1
16 else:
17 msgDlg("Ball verloren!")
18 exit()
19 setPos([Link], [Link])

c 2016, Tobias Kohn

7.9. PING PONG SPIELEN 163

20 dot(10)
21
22 def paintShuttle():
23 heading(90)
24 setPenWidth(6)
25 setPos(shuttle_X - 20, -150)
26 forward(40)
27
28 def update():
29 clear()
30 updateBall()
31 paintShuttle()
32
33 @onMouseMoved
34 def mouseMoved(x, y):
35 global shuttle_X
36 shuttle_X = x
37
38 makeTurtle()
39 hideTurtle()
40 repeat:
41 update()
42 sleep(0.01)
43 dispose()

AUFGABEN

34. Baue das Programm so aus, dass es bei einem Tastendruck been-
det wird und der Ball an den Seitenwänden und der Decke ebenfalls
abprallt. So kannst du länger spielen und denn Ball mit dem Schläger
mehrmals auffangen. Gib dem Ball und dem Schläger auch andere Far-
ben. Mit clear("black") (Zeile 29) kannst du auch die Hintergrund-
farbe ändern.

35. Ändere das Programm so ab, dass der Schläger nicht unten, son-
dern auf der rechten Seite ist und sich mit der Maus nach oben und
unten bewegt.

36. Schreibe das Programm so um, dass du den Schläger nicht mit der
Maus, sondern mit der Tastatur (Pfeiltasten) bewegst.
Füge dann einen zweiten Schläger hinzu, der sich z. B. mit den Tasten
«X» und «E» nach oben und unten bewegen lässt. Dann kannst du mit
einer Kollegin oder einem Kollegen zusammen Ping-Pong spielen.

37.∗ Füge zum Ball eine Gravitationskraft hinzu wie im Abschnitt 7.3.

38.∗ Spiele mit mehreren Bällen, wovon keiner nach unten fallen darf.

c 2016, Tobias Kohn

164 KAPITEL 7. ANIMATION

10 Steine entfernen*

Lernziele In diesem Abschnitt lernst du:

. Zu prüfen, ob ein Ball einen Steinen getroffen hat.

Einführung Beim bekannten Computer-Spiel «Break Out» schiesst

Du mit einem Ball auf farbige Steine, die dabei zerspringen. Das Ziel
des Spiels ist es, alle Steine abzuschiessen. Damit du das selber pro-
grammieren kannst, zeigen wir dir in diesem Abschnitt, wie du mit
einem Ball diese Steine treffen und entfernen kannst.

Die Steine sind hier alle rechteckig, haben eine Höhe von 10 Pixeln und
drei Koordinaten: Den linken und den rechten Rand sowie die Höhe der
Mitte. Als Objekt sieht ein solcher Stein also z. B. so aus:
Beim Prüfen, ob der Ball den
brick_1 = makeObject(left=-75, right=-42, height=120)
Stein berührt müssen wir den
Für unser Programm müssen wir prüfen, ob ein Ball mit den Koordina- Radius des Balls mit berück-
sichtigen.
ten posX und posY und einem Radius von 4 Pixeln diesen Stein gerade
berührt. Dazu müssen wir bei der x-Richtung den Radius des Balls und
bei der y-Richtung auch noch die Dicke des Steins berücksichtigen: Vergiss nicht, am Ende der
ersten Zeile einen Backslash
if (brick_1.left-4 <= posX <= brick_1.right+4) and \
«\» zu schreiben, damit Py-
(brick_1.height-9 <= posY <= brick_1.height+9):
thon weiss, dass das if auf
print "Stein berührt!" der nächsten Zeile noch weiter-
geht.

Das Programm Die Steine (bricks) erstellen wir mit for-Schleifen

in den Zeilen 6 bis 11. Die Funktion paintBricks() in Zeile 13 zeich-
net alle Steine als Rechtecke. Dazu zeichnen wir einfach jeweils eine
sehr breite Linie.

Das Kernstück ist dann in Zeilen 22 bis 26. Dort gehen wir alle Stei-
ne durch und prüfen, ob unser Ball gerade einen Stein berührt. Wenn
ja, dann wird dieser Stein aus der Liste entfernt und wir brechen die
Kollisionsprüfung ab (unser Ball kann nur einen Stein auf einmal be-
rühren/entfernen).
1 from gturtle import *
2 from time import sleep
3
4 ball = makeObject( posX = -50, posY = 200,
5 speedX = 1, speedY = -2.5 )
6 bricks = []
7 for i in range(-5, 6):
8 for j in range(1, 5):

c 2016, Tobias Kohn

7.10. STEINE ENTFERNEN* 165

9 newBrick = makeObject(left= 30*i-14,

10 right = 30*i+14,
11 height = 11*j+100)
12 [Link](newBrick)
13
14 def paintBricks():
15 for brick in bricks:
16 setPenWidth(10)
17 setPos([Link]+5, [Link])
18 moveTo([Link]-5, [Link])
19
20 def updateBall():
21 [Link] += [Link]
22 [Link] += [Link]
23 for brick in bricks:
24 if ([Link]-4<=[Link]<=[Link]+4) and \
25 ([Link]-9 <=[Link]<= [Link]+9):
26 [Link](brick)
27 break
28 setPos([Link], [Link])
29 dot(8)
30
31 def update():
32 clear()
33 updateBall()
34 paintBricks()
35 repaint()
36
37 makeTurtle()
38 hideTurtle()
39 enableRepaint(False)
40 repeat:
41 update()
42 sleep(0.05)
43 dispose()

Die Zeilen 35 und 39 sollen helfen, das Flackern etwas zu reduzieren.

AUFGABEN

39. Verwende das Ping-Pong-Programm aus dem letzten Abschnitt und

ergänze damit das Programm hier zu einem vollständigen Spiel. Wähle
auch die Farben etwas schöner und prüfe jeweils, ob bereits alle Steine
entfernt wurden.
Wenn der Ball einen Stein trifft, dann sollte er genauso wie beim Shuttle
seine Richtung ändern. Dazu musst du allerdings genauer prüfen, ob
der Ball einen Stein unten, oben, links oder rechts getroffen hat.

c 2016, Tobias Kohn

166 KAPITEL 7. ANIMATION

11 Rotationen und Pendel*

Lernziele In diesem Abschnitt lernst du:

. Eine Figur um ein Zentrum kreisen zu lassen.
. Mit den trigonometrischen Funktionen sin und cos zu arbeiten.

Einführung Nach der linearen Animation, in der ein Ball einfach

hin- und hersprang, lassen wir den Ball jetzt um ein Zentrum krei-
sen. Dazu verwenden wir die trigonometrischen Funktionen sin() und
cos().

Tatsächlich sind der Sinus und der Cosinus wie geschaffen für diese
Aufgabe. In Bezug auf das Kreiszentrum sind die x- und y-Koordinaten
des Balls auf dem Kreis (vgl. Abbildung nebenan):

x = r · cos(α) y = r · sin(α)

Wenn das Kreiszentrum nicht im Koordinatenursprung (0, 0) liegt, dann

rechnest du die Koordinaten des Zentrums (xZ , yZ ) einfach dazu: Die x- und y-Koordinaten des
Punkts auf dem Kreis lassen
x = xZ + r · cos(α) y = yZ + r · sin(α) sich aus dem Radius r und
dem Winkel α berechnen.

Das Programm Du kennst das Programm an sich bereits aus dem

letzten Abschnitt. Die einzige Änderung liegt darin, dass der Ball jetzt
um das Zentrum (50, 20) kreist. Dazu verwenden wir die beiden Funk-
tionen sin und cos aus dem math-Modul. Weil der Computer hier aber
nicht mit Grad rechnet, sondern im Bogenmass (engl. radian), müssen
wir die Winkel mit radians vom Grad- ins Bogenmass umrechnen.
1 from gturtle import *
2 from math import *
3 from time import sleep
4
5 centerX, centerY = 50, 20
6 angle = 0
7 angleSpeed = 2
8
9 def paintBall(color):
10 x = 70 * cos(radians(angle))
11 y = 70 * sin(radians(angle))
12 setPenColor(color)
13 setPos(centerX + x, centerY + y)
14 dot(21)
15

c 2016, Tobias Kohn

7.11. ROTATIONEN UND PENDEL* 167

16 def update():
17 global angle
18 paintBall("white")
19 angle += angleSpeed
20 paintBall("red")
21
22 makeTurtle()
23 hideTurtle()
24 setPos(centerX, centerY)
25 dot(10)
26 repeat:
27 if getKeyCode() != 0:
28 break
29 update()
30 sleep(0.01)
31 dispose()

AUFGABEN

40. Programmiere eine Simulation von Erde, Mond und Sonne aus der
«Astronautenperspektive». Die Erde kreist um die Sonne in der Bildmit-
te und der Mond kreist um die Erde. Beachte dabei auch, dass sich der
Mond etwa zwölf Mal so schnell um die Erde dreht wie die Erde um die
Sonne.

41. Wahrscheinlich weisst du aus dem Physikunterricht, dass du auch

Federn und Pendel mit den trigonometrischen Funktionen beschreiben
kannst. Ändere dazu im Programm oben Zeile 10 ab zu x = 0.
Ergänze das Programm nun so, dass neben dem Ball auch die Feder sel-
ber gezeichnet wird (siehe Bild nebenan). Die Feder hat immer gleich
viele «Zacken», die je nachdem näher zusammen oder weiter auseinan-
der liegen.

42. Im Programm oben ist die Winkelgeschwindigkeit angleSpeed kon-

stant. Wenn wie diese Winkelgeschwindigkeit selber mit dem Cosinus
ändern, ergibt sich eine hübsche Pendelbewegung. Dazu brauchst du
eine zusätzliche Variable time und ersetzst Zeile 19 durch:
time += 2
angleSpeed = cos(radians(time))
angle += angleSpeed
Programmiere damit das vollständige Pendel mit «Schnur».

43.∗ Programmiere eine vollständige Pendeluhr und stimme die Be-

wegungen so ab, dass das Pendel jede Sekunde einmal hin- bzw. her-
schwingt und sich auch der Sekundenzeiger entsprechend bewegt.

c 2016, Tobias Kohn

168 KAPITEL 7. ANIMATION

12 Figuren drehen*

Lernziele In diesem Abschnitt lernst du:

. Ein beliebiges Polygon um sein zentrum zu drehen.

Einführung Im letzten Abschnitt hast du einen Punkt um ein ge-

gebenes Zentrum kreisen lassen. Wenn du den Radius und den Winkel
des Punkts kennst, dann ist das dank Sinus und Cosinus relativ einfach.
Wie lässt du aber einen Punkt kreisen, wenn du Winkel und Radius
nicht kennst?

Mit der Funktion atan2(y, x) kannst du aus den x- und y-Koordinaten

eines Punkts den entsprechenden Winkel ϕ ausrechnen.
p Den Radius
findest du über den Satz des Pythagoras mit r = x2 + y 2 .

Wenn das Zentrum der Drehung nicht im Ursprung (0, 0) liegt, dann
nimmst du nicht direkt die Koordinaten (xP , yP ) des Punkts, sondern
die Differenz zum Zentrum (xZ , yZ ):
 
yP − yZ p
ϕ = arctan r = (xP − xZ )2 + (yP − yZ )2
xP − xZ

Das Programm Für die beiden Polygone (ein Dreieck und ein Qua-
drat) brauchen wir drei Funktionen. drawPolygon zeichnet ein Poly-
gon mit der angegebenen Farbe, getCenter berechnet den Mittelpunkt
(Schwerpunkt) des Polygons und turnPolygon dreht alle Punkte des
Polygons um dessen Mittelpunkt.
1 from gturtle import *
2 from math import *
3 from time import sleep
4
5 polygon1 = [(-100, -20), (-140, -20), (-120, 20)]
6 polygon2 = [(100, -20), (140, -20), (140, 20), (100, 20)]

c 2016, Tobias Kohn

7.12. FIGUREN DREHEN* 169

7
8 def drawPolygon(polygon, color):
9 setPenColor(color)
10 setPos(head(polygon))
11 for x, y in polygon:
12 moveTo(x, y)
13 moveTo(head(polygon))
14
15 def getCenter(polygon):
16 cX, cY = 0, 0
17 for x, y in polygon:
18 cX += x
19 cY += y
20 return (cX / len(polygon), cY / len(polygon))
21
22 def turnPolygon(polygon, angleSpeed):
23 cX, cY = getCenter(polygon)
24 result = []
25 for x, y in polygon:
26 radius = sqrt((x - cX)**2 + (y - cY)**2)
27 angle = atan2(y - cY, x - cX)
28 angle += radians(angleSpeed)
29 [Link]((cX + radius * cos(angle),
30 cY + radius * sin(angle)))
31 return result
32
33 def update():
34 global polygon1, polygon2
35 clear()
36 polygon1 = turnPolygon(polygon1, -2)
37 polygon2 = turnPolygon(polygon2, 4)
38 drawPolygon(polygon1, "blue")
39 drawPolygon(polygon2, "red")
40
41 makeTurtle()
42 hideTurtle()
43 repeat:
44 update()
45 sleep(0.05)
46 dispose()

AUFGABEN

44. Programmiere einen Pfeil, der immer in die Richtung der Maus
zeigt. Dazu verwendest du das @onMouseMoved von Seite 163.

c 2016, Tobias Kohn

170 KAPITEL 7. ANIMATION

Quiz
16. Ein Animations-Programm enthält den folgenden Code, um
einen Ball über den Bildschirm zu bewegen.
repeat:
posX += 20
paint() # Alles zeichnen
sleep(0.02)
Wie kann die Geschwindigkeit des Ball verdoppelt werden?

2 a. posX += 40
2 b. sleep(0.04)
2 c. posX += 40 und sleep(0.04)
2 d. sleep(0.01)

17. Welchen Effekt haben die beiden Codezeilen für einen Ball, der
mit speedX und speedY bewegt wird?
speedX *= -1
speedY = -speedY

2 a. Der Ball prallt von einer Seitenwand ab.

2 b. Der Ball prallt vom Boden oder von der Decke ab.
2 c. Der Ball kehrt seine Richtung um 180◦ .
2 d. Das hängt von den Werten von speedX und speedY ab.

c 2016, Tobias Kohn

K a p i t e l A c h t

STRINGS

Texte heissen beim Programmieren «Strings» oder «Zeichenketten». In

diesem Kapitel geht es um einfache Textverarbeitung. Du lernst zum
Beispiel, einen Text in einzelne Wörter oder Buchstaben zu zerlegen
und diese zu zählen.

Ein wichtiges Ziel ist aber auch die Kryptographie – die Ver- und Ent-
schlüsselung von Texten. So kannst du einen Text relativ einfach ver-
schlüsseln, wenn du alle Buchstaben veränderst. Das Zählen von Buch-
staben hingegen hilft dir, einen verschlüsselten Text zu knacken.

c 2016, Tobias Kohn

172 KAPITEL 8. STRINGS

1 Bruchterme ausgeben

Lernziele In diesem Abschnitt lernst du:

. Strings zusammenzusetzen.
. Zahlen in Strings umzuwandeln.
. Zeilenumbrüche einzubauen.

Einführung Du weisst längst, dass du Textstücke in Python in Gän-

sefüsschen setzen musst. Solche Textstücke heissen in der Fachsprache
String. Python kann mit Strings «rechnen», allerdings heisst das einfach,
dass Python die verschiedenen Stücke aneinanderhängt oder vervielfäl-
tigt. Sieh dir die Beispiele hier an: Probiere diese kurzen Beispiele
in der interaktiven Konsole sel-
"16"+"3" → "163" ber kurz aus und gewinne ein
"16"*3 → "161616" Gefühl dafür, wie Python mit
"Hallo"+"Welt" → "HalloWelt" Strings umgeht.
"x"*7 → "xxxxxxx"

Es gibt auch immer wieder Situationen, in denen du eine Zahl in einen

String einbauen möchtest. Zum Beispiel, um das Resultat einer Rech-
nung anzugeben. In diesem Fällen musst du die Zahl zuerst mit str
ebenfalls in einen String umwandeln.
msgDlg("Das Resultat ist: " + str(x))

Eine kurze Quizfrage: Was ist der Unterschied zwischen str(18 + 19)
einerseits und str(18) + str(19) andererseits? Was ist das Resultat
dieser beiden Ausdrücke?

Schliesslich kennt Python auch noch die Möglichkeit, einen Zeilenum-

bruch in den String einzubauen. In jedem String steht "\n" für «new
line» bzw. «neue Zeile».
msgDlg("Erste Zeile\nZweite Zeile")

Natürlich funktioniert das auch mit print.

Das Programm Für dieses Programm nutzen wir gleich mehrere

Techniken, um einen Bruch ab auch als Bruch auszugeben. Zum einen Zur Erinnerung: Wenn wir ei-
wandeln wir die Zahlen mit str in Strings um und ermitteln dann mit ne Anweisung auf mehrere Zei-
len die Anzahl Ziffern. Der Bruchstrich soll zwei Zeichen länger sein len verteilen, dann müssen wir
jeweils am Zeilenende mit ei-
als die längere der beiden Zahlen. In Pyhon können wir diesen Bruch-
nem Backslash zeigen, dass es
strich sehr einfach erzeugen (Zeile 5), indem wir den Bindstrich mit noch weitergeht (Zeilen 6 bis
8).
c 2016, Tobias Kohn
 8.1. BRUCHTERME AUSGEBEN 173

der gewünschten Länge multiplizieren. Schliesslich setzen wir alles zu-

sammen und verwenden "\n" als Zeilenumbrüche.
1 def printFraction(a, b):
2 zaehler = str(a)
3 nenner = str(b)
4 laenge = max(len(zaehler), len(nenner))
5 bruchstrich = "-" * (laenge + 2)
6 ausgabe = " " + zaehler + "\n" + \
7 bruchstrich + "\n" + \
8 " " + nenner + "\n"
9 print ausgabe
10
11 printFraction(355, 113)

Übrigens: Du kannst anstatt print in Zeile 9 auch msgDlg(ausgabe)

verwenden, wenn dir das besser gefällt.

Die wichtigsten Punkte Strings bezeichnen (kurze) Texte oder Text-

stücke. Du kannst einzelne Strings mit + aneinanderhängen oder einen
String mit * vervielfältigen. Wenn du eine Zahl in einen String einbauen
möchtest, dann musst du diese Zahl zuerst mit str ebenfalls in einen
String umwandeln.

AUFGABEN

1. Schreibe eine Funktion rechnung, die eine Rechnung mit Resultat

ausgibt. Zum Beispiel würde rechnung(4, 7) dann ausgeben:
«4 + 7 = 11».

2. Schreibe ein Programm, das eine «Sternchenpyramide» ausgibt wie

* nebenan. Das Programm fragt zuerst mit inputInt, wie viele Stufen die
*** Pyramide haben soll und erzeugt diese dann mit den neuen Techniken
***** aus diesem Abschnitt.

3. Ergänze das Beispielprogramm mit den Bruchtermen so, dass die

Brüche zentriert ausgegeben werden.

4.∗ Eine etwas schwierigere Aufgabe: Schreibe ein Programm, das ei-
ne vollständige Addition mit Brüchen ausgibt, z. B. 21 + 56 = 43 . Hier
gibt man dem Programm die beiden ersten Brüche 12 und 56 vor (na-
türlich als die vier Zahlen 1, 2, 5, 6). Dein Programm berechnet dann
selbständig das Resultat und gibt die ganze Rechnung aus wie im Bei-
spielprogramm (das Resultat muss nicht gekürzt sein).

c 2016, Tobias Kohn

174 KAPITEL 8. STRINGS

2 Buchstaben und Wörter

Lernziele In diesem Abschnitt lernst du:

. Die einzelnen Buchstaben in einem String durchzugehen.
. Einen String in Wörter aufzuteilen.

Einführung Aus der Sicht von Python sind Strings einfach Listen
von Buchstaben und Zeichen. Deshalb kannst du die for-Schleifen auch
mit Strings verwenden und damit jedes Zeichen in einem String einzeln
durchgehen: Der englische Begriff für ein
Zeichen (Buchstaben, Satzzei-
for zeichen in "Ein Beispiel":
chen etc.) ist «character». Du
print zeichen
wirst daher oft auch auf die
Bezeichnung «char» für ein
Das ist aber nicht immer, was du auch wirklich möchtest. Oft unter-
einzelnes Zeichen stossen.
teilen wir Texte ja nicht in Buchstaben, sondern in Wörter. Auch das
beherrscht Python:
wortliste = "Ein Beispiel".split()
for wort in wortliste:
print wort

Falls du einmal einen längeren Text in einzelne Sätze unterteilen möch-

test, dann gibst du bei split einfach, dass Python den Text bei Punkten
teilen soll:
meinText = "Python ist toll. Es macht Spass."
print [Link](".")

Das Programm: Ersetzen Das Kernstück dieses Programms ist eine

Funktion, die den Umlaut «ä» durch die Kombination «ae» ersetzt. Dazu
geht die Funktion jedes Zeichen im String durch und prüft, ob es ein
«ä» ist und ersetzt werden muss. Schliesslich wird der String result
Zeichen für Zeichen zusammengesetzt und am Schluss zurückgegeben.
1 def replaceUmlaut(text):
2 result = ""
3 for zeichen in text:
4 if zeichen == "ä":
5 result += "ae"
6 else:
7 result += zeichen
8 return result
9
10 print replaceUmlaut("Bär")

c 2016, Tobias Kohn

8.2. BUCHSTABEN UND WÖRTER 175

Das Programm: Filtern Es kommt immer wieder vor, dass du einzel-

ne Zeichen aus einem String herausfiltern solltest. Die Technik dahinter
ist im Wesentlichen die gleiche wie beim Ersetzen oben. Unsere Funk-
tion filtert hier die üblichen Satzzeichen aus dem Text heraus.
1 def filterText(text):
2 result = ""
3 for z in text:
4 if z not in [".", ",", "!", "?"]:
5 result += z
6 return result
7
8 print filterText("Hallo! Wie geht es dir?")

AUFGABEN

5. Baue das erste Beispielprogramm so aus, dass es auch die anderen

Umlaute «ö» und «ü» korrekt ersetzt.

6. Schreibe eine Funktion, die alle Vokale «a, e, i, o, u» aus einem

String herausfiltert und aus «Kamel» z. B. «Kml» macht.

7. Schreibe ein Programm, das zwischen alle Zeichen einen Punkt setzt
und aus «Kamel» ein «K.a.m.e.l» macht. Achte darauf, dass es nicht ganz
am Anfang oder am Ende einen überflüssigen Punkt hat.

8. Schreibe eine Funktion stringReverse, die einen String umkehrt

und aus dem «Kamel» ein «lemaK» macht.
Tipp: Schreibe das result += z aus zu result = result+z und än-
dere das dann ab.

9. Schreibe eine Funktion countE, die alle «e» in einem String zählt
und diese Anzahl zurückgibt.

10.∗ Eine kleine Herausforderung: Schreibe ein Programm, das die Kom-
bination «en» zählt.

11. Schreibe ein Programm, bei dem du eine ganze Summe als String
eingeben kannst, z. B. «12+3+5+39». Dein Programm rechnet dann
diese Summe aus und gibt das Resultat aus. Verwende dazu split.
Hinweis: Zur Funktion str gibt es auch die Umkehrungen int und
float, die einen String in eine Zahl umwandeln: int("123")→123.

12.∗ Baue das Summenprogramm so aus, dass es auch mit Minus um-
gehen kann, z. B. «3 + 4 − 6». Tipp: Ersetze zuerst alle Minuszeichen
durch die Kombination «+-».

c 2016, Tobias Kohn

176 KAPITEL 8. STRINGS

3 Gross und Klein

Lernziele In diesem Abschnitt lernst du:

. Mit Gross- und Kleinschreibung zu arbeiten.
. Welche Reihenfolge das Alphabet im Computer hat.

Einführung Zur Gross- und Kleinschreibung gehören zwei Aspek-

te. Zum einen wirst du immer wieder einen String in Grossbuchstaben
umwandeln wollen und aus dem «Elefanten» einen «ELEFANTEN» ma-
chen. Das ist in Python sehr einfach:
print "Elefant".upper() # Alles gross
print "Elefant".lower() # Alles klein

Zum anderen musst du manchmal auch prüfen, ob ein Buchstabe ein

Gross- oder Kleinbuchstabe ist. Für die lateinischen Buchstaben (d. h.
ohne Umlaute, Akzente etc.) geht auch das relativ einfach, wenn du die
Reihenfolge der Buchstaben kennst.

Das Alphabet der Computer ist historisch gewachsen (dazu später mehr).
Ursprünglich gab es nur Grossbuchstaben. Die Kleinbuchstaben kamen
erst später dazu und die Umlaute noch viel später. Daher erklärt sich,
dass die Computer beim Alphabet folgende Reihenfolge haben:

A < B < . . . < Z < a < b < . . . < z < Ä < Ö < Ü < ä < ö < ü

Damit kannst du nun folgendermassen prüfen, ob ein Zeichen ein Gross-

buchstabe ist:
if ("A" <= char <= "Z") or (char in ["Ä", "Ö", "Ü"]):
print "Ein Grossbuchstabe"

Das Programm Mit «TitleCase» bezeichnet man einen Text, in dem

jedes Wort gross geschrieben wird (das wird vor allem für Liedtitel
etc. gerne verwendet, daher der Name). Unser Programm besteht also
aus einer Funktion, die jedes Wort im Text mit einem Grossbuchstaben
schreiben soll.

Die Idee, einen String Zeichen für Zeichen durchzugehen und so das
Resultat zusammenzusetzen hast du bereits einige Male gesehen. Neu
hinzu kommt eine zweite Variable lastChar, die immer den Wert des
vorhergehenden Zeichens hat. Damit können wir nämlich alle Buchsta-
ben gross schreiben, die gleich nach einem Leerzeichen kommen.

c 2016, Tobias Kohn

8.3. GROSS UND KLEIN 177

1 def titleCase(text):
2 result = ""
3 lastChar = " "
4 for char in text:
5 if lastChar == " ":
6 result += [Link]()
7 else:
8 result += [Link]()
9 lastChar = char
10 return result
11
12 print titleCase("jedes WORT gross!")

Die wichtigsten Punkte Indem du bei einem String ein .upper()

oder .lower() anhängst, werden alle Buchstaben in Gross- bzw. Klein-
buchstaben umgewandelt. Weil der Computer die Gross- und Klein-
buchstaben strikt trennt, kannst du einfach prüfen, ob ein Zeichen ein
Gross- oder Kleinbuchstabe ist.

AUFGABEN

13. Schreibe eine Funktion, die jeden zweiten Buchstaben in einem

Text gross und den Rest klein schreibt.

14. Schreibe eine Funktion, die zählt, wie viele Grossbuchstaben in ei-
nem Text vorkommen.

15. Manchmal bilden die Grossbuchstaben in einem Text wieder eine

Nachricht. Schreibe ein Programm, das alle Grossbuchstaben aus einem
Text heraussucht und zu einem neuen Text zusammensetzt.

16. Ein häufiger Tippfehler ist, dass in einem Wort nicht nur der erste,
sondern die ersten zwei Buchstaben gross geschrieben sind (z. B. «KA-
mel»). Schreibe eine Funktion, die einen String auf solche doppelten
Grossbuchstaben hin überprüft und True zurückgibt, wenn der String
tatsächlich zwei Grossbuchstaben zusammen enthält.

17.∗ Nicht immer sind zwei Grossbuchstaben auch wirklich ein Fehler.
Es gibt auch Wörter, die ganz bewusst nur aus Grossbuchstaben beste-
hen, etwa «EU» oder «USA». Berücksichtige diese Fälle in deiner Funk-
tion, indem du zwei Grossbuchstaben nur dann als Fehler anschaust,
wenn danach noch ein Kleinbuchstabe kommt bzw. wenn nicht das gan-
ze Wort aus Grossbuchstaben besteht.

c 2016, Tobias Kohn

178 KAPITEL 8. STRINGS

4 Alles ist Zahl

Lernziele In diesem Abschnitt lernst du:

. Buchstaben in Zahlencodes umzuwandeln.

Einführung Im Computer hat jeder Buchstabe, jede Ziffer und je-

des Zeichen eine feste Nummer. Das «A» trägt z. B. die Nummer 65, das
«B» die Nummer 66, «a» die Nummer 97 und «ü» schliesslich die Num-
mer 252 (du erinnerst dich sicher, dass alle Grossbuchstaben vor den
Kleinbuchstaben kommen und daher kleinere Nummern haben). Wel-
che Nummer ein Zeichen hat zeigt dir Python mit der Funktion ord:
Ordnungszahlen sind Zahlen
der Reihenfolge, also «erstes»,
print ord("A") # Funktioniert nur für einzelne Zeichen! «zweites», «drittes» etc. Der
Grossbuchstabe «A» ist also
Umgekehrt gibt es auch eine Funktion chr, die dir das Zeichen zum das «fünfundsechzigste» Zei-
Zahlenwert angibt (das chr steht hier für «character»): chen und daher ist ord("A")
= 65.
print chr(252) # Schreibt ein ’ü’ ins Ausgabefenster.

Diese Codierung werden wir in den kommenden Abschnitten intensiv

nutzen, um Texte zu ver- und entschlüsseln.

Kurzer Exkurs: Codierungen Der erste solche Zeichencode für Com-

puter war der ASCII-Code, der für die Übertragung englischer Nachrich-
ten gedacht war. Daher gibt es in ASCII keine Umlaute, dafür aber ei-
gene Codes für «klingeln» und «besetzt». Ausserhalb der USA hat fast
jedes Land diesen ASCII-Code anders erweitert, um auch Zeichen wie
die Umlaute zu codieren. Damit ist ein ziemliches Chaos entstanden bis
man sich dann auf eine einheitliche internationale Codierung einigen
konnte: Den Unicode. Leider werden immer noch verschiedenste Codie-
rungen verwendet, so dass Buchstaben mit Akzenten manchmal völlig
falsch dargestellt werden. Gerade auch Python hat hier oft Mühe!

Das Programm In diesem Programm haben wir eine kurze Nach-

richt mit Zahlenwerten codiert. Dabei haben wir aber nicht den Unico-
de oben verwendet, sondern 0 für den Leerschlag verwendet, 1 für «A»,
2 für «B» etc. Diese vereinfachte Codierung ist manchmal viel prakti-
scher als die eigentliche Codierung.

Weil aber «A» eigentlich den Code 65 hat und nicht 1, «B» den Code
66 anstatt 2, etc. müssen wir in Zeile 9 immer noch 64 zu unseren

c 2016, Tobias Kohn

8.4. ALLES IST ZAHL 179

eigenen Zahlen dazurechnen, bevor wir mit chr das eigentliche Zeichen
bestimmen.
1 msgList = [16, 25, 20, 8, 15, 14, 0,
2 9, 19, 0, 6, 21, 14]
3
4 message = ""
5 for code in msgList:
6 if code == 0:
7 message += " "
8 else:
9 message += chr(code + 64)
10 print message

Die wichtigsten Punkte Jedes Zeichen, das der Computer über-

haupt darstellen kann, hat einen festen Zahlencode. Diesen Code kannst
du mit der Funktion ord bestimmen. Umgekehrt bekommst du mit der
Funktion chr zu einem Code das Zeichen.

AUFGABEN

18. Das Beispielprogramm oben entschlüsselt eine Nachricht, die mit

Zahlenwerten codiert ist. Schreibe das entsprechende Programm zum
Verschlüsseln einer Nachricht. Verwende dazu den gleichen Code wie
wir hier: Leerschläge werden zu Null, «A» zu 1, «B» zu 2 etc. Der Ein-
fachheit halber sollte dein Text dann nur Grossbuchstaben und Leer-
schläge enthalten, aber keine anderen Satzzeichen.

19. Baue dein Programm so aus, dass du auch Texte mit Kleinbuchsta-
ben und Umlauten codieren kannst. Dazu soll dein Programm den Text
allerdings in Grossbuchstaben umwandeln und alle Umlaute nach dem
Schema ersetzen: «Ä»→«AE».

20. Du kannst die «Quersumme» eines Namens berechnen, indem du

zuerst alle Buchstaben in Zahlen umwandelst (nach dem gleichen Sche-
ma wie oben mit «A» = 1). Schreibe ein Programm, bei dem du deinen
Namen eingeben kannst und das dir dann diese Namens-Quersumme
berechnet.

c 2016, Tobias Kohn

180 KAPITEL 8. STRINGS

Quiz
18. Welche dieser Ausdrücke geben das Ergebnis "15" zurück?

2 a. str(3 * 5)
2 b. str(3) * str(5)
2 c. str(3) * 5
2 d. str(1) + str(5)

c 2016, Tobias Kohn

A n h a n g A

LÖSUNGEN

Vorbemerkung Die Programme in den Lösungen hier zeigen jeweils

einen möglichen Weg auf. Es gibt aber bei fast allen Aufgaben eine ganze
Reihe von Programmen, die die Aufgabe korrekt lösen.

Lösungen zu den Quizfragen

1. d 7. b 13. c, d

2. b, c 8. a 14. d

3. b 9. a 15. a

4. a 10. c 16. a, d

5. c 11. b 17. c

6. d 12. b, c 18. a, d

c 2016, Tobias Kohn

182 ANHANG A. LÖSUNGEN

1 Kapiteltest 2

7. def handshake(n):
h = n * (n-1) // 2
return h

8. from gturtle import *

from math import *

def myCircle(mx, my, r):

# Die Kreisfunktion:
def f(x):
return sqrt(r**2 - x**2)

x = -r
setPos(mx-r, my)
# Oberen Kreisbogen zeichnen:
repeat 2*r:
x += 1
y = f(x)
moveTo(mx + x, my + y)
# Unteren Kreisbogen zeichnen:
repeat 2*r:
x -= 1
y = -f(x)
moveTo(mx + x, my + y)

9. from gturtle import *

def f(x):
return -x**2/200

makeTurtle()
setPenColor("black")
# Das gerade Stück zeichnen:
setPos(-125, 10)
moveTo(125, 10)
# Den Bogen zeichnen:
x = -120
setPos(x, f(x))
repeat 241:
moveTo(x, f(x))
x += 1
# Die vertikalen Verstrebungen zeichnen:
x = -120
repeat 13:
setPos(x, 10)
moveTo(x, f(x))
x += 20

c 2016, Tobias Kohn

A.1. KAPITELTEST 2 183

10. def cbrt(a):

x = a / 3
repeat 50:
x = (x + a / (x**2)) / 2
return x

11. (a) def intDiv(a, b):

result = 0
repeat:
if a >= b:
a -= b
result += 1
else:
break
return result

(b) def intRest(a, b):

repeat:
if a >= b:
a -= b
else:
break
return a

(c) def numDiv(a, b):

result = 0
x = 1
repeat:
if a >= b:
a -= b
result += x
else:
b /= 10
x /= 10
if x < 0.0000001:
break
return result

12. zaehler = 0

def nextInt():
global zaehler
zaehler += 1
return zaehler

c 2016, Tobias Kohn

 INDEX

3n+1-Vermutung, 57 Beschleunigung, 150

Betrag, 97
abbrechen, 60 Bild
abs, 97 Aus Datei laden, 138
Abstand, 99 Graustufen-, 127
Algebra Pixel-, 127, 138
boolsche, 112 binär, 101
Algorithmus, 106, 114, 116 Bogen, 22
Euklid, 117 Bogenmass, 105, 166
Herons, 114 Boolean, 108, 112
Alternativen, 56 break, 60
and, 80, 112 Break-Out, 164
andernfalls, 56 Buchstaben, 174
Anordnung, 123
Anweisung Callback, 88
definieren, 14 case, 176
Anzahl, 20 char, 174
append, 122, 136 character, 174
arctan, 168 chr, 178
Argument, 16 clear, 82, 163
ASCII, 178 clrScr, 47
Ascii-Art, 47 Code, 178
atan2, 168 Tasten-, 146
Ausführung Collatz-Vermutung, 57
bedingte, 54 compress, 134
ausfüllen, 18, 36, 129 Console, 34
Ausgabe, 58 cos, 166
average, 125
Datenbank, 142
Balkendiagramm, 140 Debugger, 30
bar, 65 def, 14, 68
Bedingung, 54, 55 definieren
Befehl Anweisung, 14
definieren, 14 Diagramm
Berechnungsverfahren, 106 Balken-, 140

c 2016, Tobias Kohn

INDEX 185

Distanz, 99 fill, 18
dividieren, 26 fillOff, 36
Division fillToPoint, 36, 129
ganzzahlige, 44 filtern, 142
Division durch Null, 104 Fläche, 18, 129
Divisionsrest, 44 Flächen, 36
dot, 36, 52, 71, 73 float, 40, 175
Drehung, 168 foo, 65
Dreieck for, 124, 132, 138, 174
rechtwinkliges, 26 forward, 10
Durchschnitt, 125 Funktion, 96, 98, 100
Graph, 102, 104
Effizienz, 110 trigonometrische, 166
Eingabe, 42, 58
Einrückung, 14 Gänsefüsschen, 46
Einzelschritt, 31 getKeyCode, 148
Element, 122 getKeyCodeWait, 146
erstes, 128 getPixelColorStr, 84
grösstes, 130 getX, 76
kleinstes, 130 getY, 76
elif, 84, 100 ggT, 117
else, 56, 68, 84, 100 Gleichung
Endlos-Schleife, 106 quadratische, 63
Erde, 167 global, 82
Euklid, 117 Grad, 105
exit, 92 Gradmass, 166
Graph, 102, 104
Exponent, 40
grau, 52
füllen, 18, 36, 129 Graustufen, 52, 127
Fallunterscheidung, 54, 56 Gravitation, 150
falsch, 108, 112 Gross-/Kleinschreibung, 176
False, 108, 112 gturtle, 10
Farbe, 12, 18, 70, 73
Haus
Regenbogen, 77
Nikolaus, 11
Regenbogen-, 97
head, 128, 136
Spektrum, 77 heading, 75
Farben Heron, 114
Graustufen, 52 hideTurtle, 72
Regenbogen-, 52 Histogramm, 140
Farbnamen, 12
Farbstift, 12 if, 54, 56, 68, 84, 100
Farbverlauf, 70, 79 import, 10
Feder, 166 in, 122, 124
Fehler, 32 input, 42, 58
fehlerfrei, 62 inputFloat, 42, 58
Fermat, 113 inputInt, 42, 58
Fibonacci, 116 inputString, 58

c 2016, Tobias Kohn

186 INDEX

int, 40, 175 Maximum, 130, 136

Integer, 40 min, 136
isnan, 104 Minimum, 130, 136
Mittelwert, 125
Keyboard, 146 Modul, 10
Kollisionen, 164 Modulo, 44
Kommentar, 90 Mond, 167
Kompression, 134 Mouse, 80
Konsole, 34 mouseHit, 80
Koordinaten, 76, 102 mouseHitX, 86
Koordinatensystem, 74 moveTo, 74, 80, 102
Kopf, 128 msgDlg, 58
korrekte Programme, 62 multiplizieren, 26
Kreis, 22
Kreisbogen, 22 NaN, 104
kreisen, 166 newline, 46, 172
Kreissektor, 24 nicht, 112
Kreiszahl, 48 not, 112
Kuchen, 24 not a number, 104
Kugel, 71 not in, 122

Länge, 136 Objekt, 156

label, 89, 103 oder, 112
Lauf, 134 onClick, 80
left, 10 onMouseClicked, 161
len, 136 onMouseDragged, 88
Linienbreite, 12 onMouseHit, 80
List-Comprehension, 133 onMouseMoved, 88, 162
Liste, 122, 142 onMousePressed, 88
Anzahl, 136 onMouseReleased, 88
binäre, 134 Operator
Länge, 136 Rechnungs-, 40
leere, 136 Vergleichs-, 55
range, 132 or, 112
Zahlen, 132 ord, 178
Logikfehler, 32 Osterformel, 57
long, 40
lower, 176 Parameter, 16, 28
mehrere, 28
makeColor, 52, 70, 97 strecken, 26
makeObject, 156 pen, 12
makeTurtle, 10, 80 Pendel, 166
Mantisse, 40 penDown, 12
math, 48 penUp, 12
Maus, 80, 88, 161, 162 Permutation, 123
Mausbewegung, 88, 162 Physik, 167
Mausklick, 80, 161 Pi, 48
max, 136 Ping-Pong, 148, 162

c 2016, Tobias Kohn

INDEX 187

Pixel Endlos-, 106

-bild, 127, 138 for, 50, 124, 132, 138
Plattformen, 154 repeat, 20
Polstelle, 104 verschachtelt, 78
polyCircumference, 22, 36 Schnitt
Polygon, 24 goldener, 49
Potenz, 48 Schreibweise
prüfen, 54, 62 wissenschaftliche, 40
Primzahl, 109, 110, 125 Schwerkraft, 150
Fermatsche, 113 setCursor, 88
print, 40, 41, 45, 46, 58 setFillColor, 18
Programm beenden, 92 setLineWidth, 12
Programmablauf, 30 setPenColor, 12, 70
Punkt, 128 setPenWidth, 36, 71
Pythagoras, 133 setPos, 74, 102
showTurtle, 72
Quadratische Gleichung, 63
Shuttle, 162
Quiz, 142
sin, 166
Rückgabewerte skalieren, 102
Mehrere, 130 sleep, 84, 141, 148
radian, 105 sortieren, 136
radians, 166 speed, 11
Radius, 22 Spezialfall, 54
rainbow, 52, 77, 97 Spirale, 53
randint, 72 split, 174
random, 72 sqrt, 48
range, 132 square root, 48
Regenbogen, 52, 77, 97 Statistik, 140
remove, 136 str, 172
repeat, 20, 50, 52, 78, 106, 132 String, 46, 172
Repetition, 20 string, 58
return, 96, 98, 100, 106, 108 sum, 136
RGB, 70 Summe, 51, 124, 136
Richtung, 75 Summieren, 51
right, 10 Syntaxfehler, 32
Rotation, 166, 168 sys
round, 48 exit, 92
run, 134
Runden, 46, 48 Tabelle, 100
Rundungsfehler, 40 Tabulator, 46
tan, 105
Satz Tangens, 105
Pythagoras, 49, 99 Tastatur, 146
Schaltjahr, 55 Teiler, 117
Schatten, 154 Terminal, 34
Schleife, 20, 50, 52, 60, 78 testen, 54, 62
abbrechen, 60 time, 84, 110

c 2016, Tobias Kohn

188 INDEX

sleep, 148 Zeichen, 174

Trigonometrie, 166 Zeichencodierung, 178
Tripel Zeichenkette, 172
Zahlen-, 133 Zeilen
True, 108, 112 fortsetzen, 112
Tupel, 128, 142 verbinden, 112
Turtle, 10, 68 Zeilenumbruch, 46, 172
Typumwandlung, 172, 175 Zeit, 110
Zufall, 72, 123
Umfang, 22 Zufallszahl, 72
und, 112 Zuweisung, 43, 114
Unicode, 178 erweiterte, 50
upper, 176 mehrere Variablen, 116

Variable, 50, 156

globale, 82
lokale, 82
Wert ändern, 50, 114
Variablen, 42
Verfahren
Algorithmus, 106
Heron, 114
Vergleich, 55, 108
verlassen
Schleife, 60
Verzweigung, 54, 56
Vieleck, 24, 27

Wörter, 174
Würfel, 73
wahr, 108, 112
warten, 148
Werte
boolsche, 108
undefinierte, 104
Wiederholung, 20, 52, 78
Winkel, 24, 166
Winkelmass, 166
wissenschaftliche Schreibweise, 40
Wurzel, 48, 54, 106, 114

Zahlen
Fermat-, 113
ganze, 40
gebrochene, 40
perfekte, 109
wissenschaftliche, 40
zufällige, 72

c 2016, Tobias Kohn