Beispiel 1: Liste mit Farben

Die Liste colors enthält 6 Farben. Mit for c in colors: geht man die Liste durch, zeichnet mit jeder Farbe einen gefüllten Kreis und verschiebt die Turtle um 40 Schritte.

#Tu13.py

from gturtle import *

makeTurtle()

colors = ["red", "blue", "yellow", "green", "black", "cyan"]
for c in colors:
    setPenColor(c)
    dot(40)
    forward(40)
hideTurtle() 

Mit dem Befehl append kann eine Liste mit weiteren Elementen erweitert werden.
colors.append("magenta") fügt eine weitere Farbe hinzu.
Mit print(colors) werden alle Elemente der Liste im Ausgabefenster angezeigt:

['red','blue','yellow','green','black','cyan','magenta']

Mit einem Index kann man auf die einzelnen Elemente der Liste zugreifen. Das erste Element hat den Index 0. colors[0] ist die Farbe red, colors[1] die Farbe blue usw.
Mit print(colors[2]) wird im Ausgabefenster yellow angezeigt.
Anzahl Elemente der Liste kann man mit len(colors) abfragen.

#Tu13a.py

from gturtle import *

makeTurtle()

colors = ["red", "blue", "yellow", "green", "black", "cyan"]
colors.append("magenta")
print(colors)
for c in colors:
    setPenColor(c)
    dot(40)
    forward(40)
hideTurtle() 

print(colors[2])
print(len(colors))

Beispiel 3: Liste mit Punkt-Koordinaten (Tupels)

Die Liste house enthält die Koordinaten der Eckpunkte der neben stehenden Figur. Die Elemente der Liste sind Tupels (x, y). Im Programm geht man mit einer for-Schleife die Liste durch und verbindet die nacheinanderfolgende Punke.

Auf die Elemente eines Tupels kann man gleich zugreifen, wie auf Elemente einer Liste. p[0] liefert das erste Element (x-Koordinate), p[1] liefert die y- Koordinate.

#Tu13b.py

from gturtle import *

makeTurtle()

house = [(0, 60), (50, 110), (100, 60), (100, 0), (0, 0)]

for p in house:
    moveTo(p)
    
p = house[2]
print(p)
print(p[0])
print(p[1])
   

Die Anzahl Elemente einer Liste kann während der Programmausführung verändert werden. Es ist sogar möglich eine ganze Liste dynamisch zu erzeugen. Die Liste points ist zu Beginn leer. Mit jedem Mausklick wird ein Punkt mit den Koordinaten des Mausklicks erzeugt und gezeichnet.
Der neu erzeugte Punkt wird danach unter Verwendung einer for-Schleife, die alle Elemente der Liste points durchgeht, mit allen vorhandenen Punkten verbunden. Anschliessend wird der Punkt zu Liste hinzugefügt und die aktuelle Liste mit print(points) im Ausgabefenster angezeigt.

#Tu13c.py

from gturtle import *

def onMousePressed(x, y):
    p = (x, y)
    setPos(p)
    dot(10)
    for q in points:
        setPos(p)            
        moveTo(q)  
    points.append(p)
    print(points)  
                
makeTurtle(mousePressed = onMousePressed)
hideTurtle()
points = []

Bereits im Kapitel Zufallszahlen wurde die Monte Carlo-Methode verwendet, um die Zahl Pi zu berechnen. Ähnlich kann man auch die Fläche eines beliebigen Polygons bestimmen. Die Eckpunkte des Polygons werden mit dem linken Mausklick festgelegt. Mit dem rechten Mausklick wird die Polygonfläche grau gefüllt und der "Zufallsregen" gestartet, h.d. man lässt z.B. n = 100 000 Zufallstropfen auf das Turtlefenster fallen.

Mit der Funktion getPixelColorStr() kann man herausfinden, ob die Farbe unter einem zufällig gewählten Punkt weiss oder grau ist. Die Tropfen in der grauen Fläche werden als Hits gezählt und rot markiert, die übrigen grün. Da es vorkommen kann, dass ein Punkt mehrmals getroffen wird, müssen bei den Treffern auch die bereits rot gefärbten Punkte als Hits gezählt werden.

Aus dem Verhältnis der Anzahl Treffer zu Anzahl aller Punkte, die man auf das Turtlefenster fallen lässt, lässt sich die Polygonfläche berechnen. Eine höhere Genauigkeit erreicht man, wenn man die Anzahl der Zufallspunkte erhöht. Das Ergebnis wird in der Statuszeile angezeigt.

Wenn d ie Funktion startRandomRain() im Callback der rechten Maustaste aufgerufen wird, erscheinen die Zufallspunkte alle gleichzeitig nach dem alle 100 000 Zufallstropfen gelandet sind. Unter verwendung von putSleep() und wakeUp() werden die Zufallstropfen "animiert" eins nach dem anderen dargestellt. Der Befehl startRundomRain() wird im Hauptprogramm mit putSleep() angehalten und gestartet, nach dem im Callback der rechten Maustaste wakeUp() aufgerufen wurde. Testen Sie den Unterschied, indem Sie startRandomRain() im Callback aktivieren und die wakeUp() und die letzten zwei Zeilen im Hauptprogramm deaktivieren.

Der Befehl X11Color.RAINBOW_COLORS() liefert eine Liste mit 40 Farben. Diese wird als Liste colors gespeichert. Mit einer for-Schleife geht man diese Liste duch und zeichnet jeweils eine senkrechte Linie mit der Breite 10 Pixel.

# Tu13f.py

from gturtle import *

makeTurtle()
colors = X11Color.RAINBOW_COLORS
hideTurtle()
setPenWidth(10)
x = -200
for i in range(40):
   setPenColor(colors[i])
   setPos(x + 10 * i, -200)
   forward(400)

Erstelle eine Liste mit 8 Farben. Zeichne ein regelmässiges 8-eck, bei dem jede Seite eine andere Farbe hat und mit etwas dickeren Linien gezeichnet wird.

Mit dem linken Mausklick werden beliebig viele Punkte gezeichnet und in einer Liste gespeichert. Klickt man mit der rechten Maustaste, so werden vom Punkt des Mausklicks aus Verbindungslinien zu allen gespeicherten Punkten gezeichnet.

Im Beispiel 4 wird die Liste points per Mausklick mit neuen Punkten ergänzt und jeder neue Punkt mit allen Punkten der Liste verbunden. Ergänze das Programm so dass bei jedem Mausklick auch die Anzahl der Verbindungslinien gezänlt wird. Die Zählervariable n wird im Hauprogramm mit n = 0 initialisiert beim Zeichnen jeder Verbindungslinie um 1 erhöht.
Da n in der Funktion onMousePressed(x, y) verändert wird, muss sie als global definiert werden. Du muss also die Zeile global n einfügen.

def onMousePressed(x, y):
    global n
    p = (x, y)
    setPos(p)
    ......

Vergleiche das Ergenbis mit der kombinatirischen Formel n * (n - 1) / 2.

Erstelle eine Liste colors mit 8 Farben. Definiere eine Funktion line(color, length), der eine farbige Linie zeichnet. Zeichnen Sie eine Spirale, so wie im Bild rechts. Nach jeder gezeichneten Strecke wird die nächste Farbe aus der Liste colors genommen. Nach dem man die letzte farbe genommen hat, beginnt man wieder mit der ersten Farbe. 

colors = X11Color.RAINBOW_COLORS
liefert eine Liste mit 40 Regebogenfarben. Gehe diese Liste mit einer for-Schleife durch und zeichne für jede Farbe eine 10 Pixel breite senkrechte Linie.

Beispiel 7: Grafische Darstellung des BubbleSort-Algorithmus

n zufällig gewählte Zahlen zwischen 1 und 500 werden mit dem BubbleSort-Algorithmus sortiert. Um den Sortiervorgang grafisch darzustellen, zeichnet man für jede Zahl einen Balken, dessen Höhe in Pixel der Zufallszahl entspricht. Danach wird die Liste sortiert und die Balken nach jedem Sortierungsschritt neu dargestellt.

Die Funktion drawBar(s) zeichnet einen Balken der Länge s.
Die Funktion drawAllBars() zeichnet alle Balken.

Beispiel 8: n Farbkugeln mit BubbleSort nach Regebogen-Spektrum sortieren

Zu Beginn werden n Kugeln in zufällig gewählten Regenbogenfarben gezeichnet. Damit die Farben nach dem Regebogenspektrum sortiert werden können, müssen sie in das HSB-Format konvertiert werden. Im HSB-Format wird jede Farbe mit den folgenden drei Komponenten angegeben: H: Farbton, S: Sättigung, B: Helligkeit. Für die Sortierung braucht man nur den Farbton (hsb[0]). Dieser wird mit einem Winkel im HSB-Farbkreis definiert (0° entspricht der Farbe rot). Ergebnis:

HSB-Farbraum

Beispiel 9: QuickSort-Algorithmus

Der BubbleSort-Algorithmus ist einfach nachvollziehbar, ist aber nicht so effizient. In der Praxis werden deshalb effizientere Sortierverfahren verwendet, wie z.Bsp. QuickSort.

Der Programmcode ist einiges komplizierter als bei BubbleSort und wird an dieser Stelle nur als Demonstration aufgeführt, damit man die die Geschwindigkeit beider Sortierverfahren vergleichen kann. Eine Beschreibung des Algorithmus findet man beispielsweise auf Wikipedia. [https://de.wikipedia.org/wiki/Quicksort]

In Python gibt es eine eingebaute Funktion sort().
li.sort() sortiert die Liste li.
Verwende im Beispiel 7 (BubbleSort2.py) die Funktion sort() anstelle des BubleSort-Algorithmus. Du kannst allerdings nur die Start- und End-Situation darstellen. Auf die fortlaufende Animation muss du verzichten.

colors = X11Color.RAINBOW_COLORS
liefert eine Liste mit 40 Regenbogenfarben. Ändere das unten stehenden Programm, so dass die Grafik in Regenbogenfarben gezeichnet wird.

from gturtle import *
makeTurtle()
hideTurtle()
s = 5
repeat 200:    
   forward(s)
   left(70)
   s = s + 1

Du gehst die Liste colors durch und zeichnest jeweils 5 Strecken mit der gleichen Farbe.

colors1 = list(reversed(colors))
liefert eine Liste, in der die Faben in der umgekehrten Reihenfolge angeordnet sind. Zeichne eine Grafik, die die Farben der Liste colors1 durchläuft.