Wiederholungen sind ein wichtiger Bestandteil vieler Algorithmen. Sie ermöglichen es uns mit wenig Code komplexe Probleme zu lösen und auf unterschiedliche Inputs zu reagieren.
Bevor wir aber die Wiederholungen anschauen, lernen wir einen neuen Datentyp von Python kennen – die Liste:

# Listen

Eine Liste ist ein zusammengesetzter Datentyp – er besteht aus mehreren einfachen Datentypen, z.B. Zahlen oder Text. Wir können aber auch eine Liste von Objekten, z.B. vom Typ Actor haben.

Bevor man eine Liste verwenden kann, muss diese erzeugt werden. Python muss wissen, dass es sich bei der Variablen um ein Liste handelt.

# eine Liste mit Werten definieren

Eine Liste wird durch eckige Klammern gekennzeichnet. Listen-Elemente werden durch Komma getrennt:

zahlen = [12.50, 4.25, 9.90, 2.50]
1

# leere Liste definieren

Lässt man die Klammer leer, erhält man eine leere Liste. Wir können anschliessend mit dem Unterprogramm append() der Liste Elemente anhängen:

zahlen = []
zahlen.append(12.50)
zahlen.append(4.25)
1
2
3

# einzelnes Element ansprechen

Mit dem sogenannten Index können wir ein einzelnes Element der Liste ansprechen:

zahlen = [12.50, 4.25, 9.90, 2.50]
summe = zahlen[0] + zahlen[1] + zahlen[2] + zahlen[3]
print(summe)
1
2
3

Wir können das Element auch ändern:

zahlen = [12.50, 4.25, 9.90, 2.50]
zahlen[0] = 12.2
print(zahlen)
1
2
3

Hinweis

  • Das erste Element der Liste hat den Index 0!
  • Wir sollten nicht auf ein Element zugreifen das gar nicht existiert!

# Länge einer Liste

Mit len können wir die aktuelle Länge einer Liste abfragen (also die Anzahl Elemente darin).

zahlen = [12.50, 4.25, 9.90, 2.50]
laenge = len(zahlen)
print(laenge)
1
2
3

# Beispiel

Wir wollen Schneefall simulieren: Dazu erstellen wir viele Schneeflocken-Actors und verteilen diese zufällig auf dem Bildschirm:

import random

flocken = []

flocke1 = Actor("snowflake_1")
flocke1.x = random.randint(0, WIDTH)
flocke1.y = random.randint(0, HEIGHT)    
flocken.append(flocke1)

flocke2 = Actor("snowflake_1")
flocke2.x = random.randint(0, WIDTH)
flocke2.y = random.randint(0, HEIGHT)    
flocken.append(flocke2)

...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Da müssten wir wohl sehr viel Code kopieren. Zum Glück gibt es While-Schleifen:

# While-Schleifen

While-Schleife
While-Schleife

Solange Bedingung wahr ist, mache etwas

# Syntax

while True/False:
    mache_etwas()
    
mach_weiter()
1
2
3
4

# Beispiel

Wir füllen unsere Liste mit 200 zufällig positionierten Schneeflocken-Actors.

import random

WIDTH = 800
HEIGHT = 600

flocken = []

while len(flocken) < 200:
    flocke = Actor("snowflake_1")
    flocke.x = random.randint(0, WIDTH)
    flocke.y = random.randint(0, HEIGHT)    
    flocken.append(flocke) 
1
2
3
4
5
6
7
8
9
10
11
12

Hinweis : Zufallszahlen

Mit dem Modul random können wir verschiedene Zufalls-Werte generieren. Mit dem Unterprogramm randint(a, b) wird eine zufällige ganze Zahl erzeugt, so dass .

Die Flocken sind nun da. Gezeichnet werden sie aber noch nicht.

# for-in-Schleife

Mit einer for-in-Schleife werden Elemente aus einer Liste genommen. Für jedes Element wird der Schleifeninhalt ausgeführt. Das aktuelle Element ist im Schleifeninhalt mit dem im Schleifenkopf gesetzten Namen ansprechbar:

for-In-Schleife
for-In-Schleife

# Syntax

for element in liste:
    mache_etwas_mit(element)

mach_weiter()
1
2
3
4
liste
ist der Name der Variable woraus die Elemente genommen werden sollen
element
ist der Name welche die Elemente im Schleifeninhalt erhalten

für jedes Element der Liste mache…

# Beispiel

Damit wir die Flocken sehen, müssen wir im Unterprogramm draw für jedes Listen-Element den draw-Befehl aufrufen:

def draw():
    screen.clear()
    for flocke in flocken:
        flocke.draw()
1
2
3
4

Es spielt keine Rolle, ob wir 3 oder 3000 Flocken in unserer Liste haben – alle werden gezeichnet!

# Aufgaben

Aufgabe : Schneeflocken

Erzeuge eine Schnee-Szene

  • erstelle eine (oder mehrere Listen) mit Schneeflocken
  • stelle diese im Unterprogramm draw dar

Zwei Bilder für Schneeflocken in jeweils 3 Grössen mit Transparenz:

Inverse

Aufgabe : Animation

Wie können wir nun die Schneeflocken animieren? Wir müssen die y-Koordinaten jeder Flocke etwas vergrössern und das Bild neu zeichnen:

  • Das Neu-Zeichnen übernimmt Pygame Zero für uns
  • Für die Verschiebung von Actors gibt es die update()-Funktion

Wir gehen also in der update()-Funktion die Liste der Schneeflocken durch und verschieben jede Flocke in y-Richtung.

Aufgabe : Hintergrund

  • Suche ein passendes Hintergrund-Bild für den Schneefall
  • Zeichne das Bild als erstes im Unterprogramm draw mit dem blit-Befehl
def draw():
    screen.blit("winter.jpg", (0,0))
    ...
1
2
3
  • passe deine Fenstergrösse oder das Hintergrundbild an, damit beides zusammenpasst

Hinweis : blit(file, pos)

Du könntest das Hintergrund-Bild auch mit einem unbeweglichen Actor machen. Dann brauchst du aber eine PNG-Datei. Der blit-Befehl zeichnet auch JPG-Dateien.
Beim zweiten Argument handelt es sich übrigens um die Position der oberen linken Ecke des Bildes.

Aufgabe : Endlosschnee

Schaffst du es, das Programm umzuschreiben, so dass es immer weiter schneit?

Aufgabe (optional) : Erweiterungen

Versuche eine oder mehrere vorgeschlagene Erweiterungen umzusetzen:

  1. Flocken auch etwas in x-Richtung verschieben
  2. nicht alle Flocken gleich weit verschieben
  3. grössere Flocken schneller fallen lassen (3D-Effekt, weiter vorne)
  4. leichte Zufallswerte bei der Verschiebung verwenden
  5. zusätzlich die Flocken leicht drehen
Letzte Änderung: 18.12.2019, 08:58:41