Programmieren III: Listen, for-Schleifen

Bisher haben wir Resultate entweder mit print() direkt in der Konsole ausgegeben oder als einzelne Zahlen in Variablen gespeichert. Oft macht es Sinn, Werte in Listen zu speichern. Dies geht ganz einfach:

Eine Liste erstellt man wie folgt:

L = [2,4,6,8]

Eine Liste besteht aus Elementen, die Position eines Elements wird Index genannt. Die Elemente einer Liste kann man über ihren Index auslesen. Das erste Element hat den Index 0, das zweite den Index 1 usw. print(L[2]) gibt also 6 in der Konsole aus. Ganz ähnlich kannst du auch einen Wert ändern: L[2] = 7.

Elemente hinten hinzufügen kann man mit append:

L = [2,4,6,8]
L.append(10)

Nach dem append-Befehl sieht die Liste wie folgt aus: [2, 4, 6, 8, 10]. Mit print(L) kannst du dich selbst davon überzeugen. Weitere wichtige Befehle sind

L.insert(2,5) # fügt an Index-Position 2 den Wert 5 ein
L.pop(4) # Entfernt das Element mit Index 4
len(L) # Gibt an, wieviele Elemente sich in der Liste befinden. Diesen Wert kann man z.B. printen oder in einer Variablen speichern

Es ist ganz einfach, alle Elemente einer Liste durchzugehen. Mit einer while-Schleife könnte das so aussehen:

i = 0
while i < len(L):
    print(L[i])
    i = i + 1

Noch etwas eleganter geht dasselbe mit einer for-Schleife (mehr dazu im nächsten Kapitel). Dabei wird die Schleifen-Variable (im Beispiel e) in jedem Durchgang der Schleife auf das nächste Element der Liste gesetzt.

for e in L:
    print(e)

Diese Aufgabe besteht aus vielen kleinen Teilaufgaben, in denen die Grundlagen der Listen geübt werden. Du kannst alle Teilaufgaben in einer py-Datei lösen.

1. Erstelle die Liste A = [0,1,2,3,4,5,6]. Füge der Liste hinten den Wert 7 hinzu. Entferne dann weiter das erste Element 0. Printe die bearbeitete Liste in die Konsole und vergewissere dich, dass sie wie folgt ausschaut: [1, 2, 3, 4, 5, 6, 7].
2. Erstelle eine leere Liste B = []. Nun sollen alle Werte von 0 bis 99 darin gespeichert werden. Erstelle dazu eine while-Schleife, die von 0 bis 99 zählt. In jedem Durchlauf der Schleife soll das nächste Element hinzugefügt werden.
3. Kopiere die folgende Liste ins TigerJython: C = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]. Bestimme dann mithilfe von deinem Wissen über Listen, aus wievielen Elementen diese Liste besteht. Selbst zählen zählt nicht!
4. Kopiere die Liste [0,2,4,6,8,10,12,16,18,20] ins TigerJython. In ihr fehlt die Zahl 14! Füge diese am richtigen Ort ein.
5. Kopiere die Liste [0,2,3,6,8,10,13,14,16,19,20] ins TigerJython. In ihr sind drei Zahlen falsch! Ändere diese, in dem du direkt die Werte anpasst. Du darfst also weder pop noch insert verwenden. Wähle also zum Beispiel das Element mit Index 2 aus und ändere seinen Wert.
6. Die folgende Liste sollte eigentlich ausschlisslich aus Zahlen der 5er-Reihe bis und mit 50 bestehen: E = [5,10,12,15,20,27,30,31,35,36,40,50]. Kopiere diese Liste ins TigerJython und bearbeite sie so, dass sie stimmt: Entferne falsche Elemente und füge fehlende Elemente ein. Arbeite also ausschliesslich mit pop und insert.

A = [0,1,2,3,4,5,6]
A.append(7)
A.pop(0)
print(A)
 
B= []
i = 0
while i < 100:
    B.append(i)
    i = i + 1
print(B)
 
C = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]
print(len(C))
 
D = [0,2,4,6,8,10,12,16,18,20]
D.insert(7, 14)
 
D = [0,2,3,6,8,10,13,14,16,19,20]
D[2] = 4
D[6] = 12
D[9] = 18
 
E = [5,10,12,15,20,27,30,31,35,36,40,50]
E.pop(2)
E.pop(4)
E.insert(4, 25)
E.pop(6)
E.pop(7)
E.insert(8, 45)
print(E)

Definiere eine Funktion zero_list(n). Dieser wird als Argument eine Zahl übergeben. In der Funktion wird dann eine Liste erstellt, die n-mal die Zahl 0 enthält. Diese Liste wird dann zurückgegeben. Mit dem Befehl print(zero_list(7)) soll man dann also den Output [0, 0, 0, 0, 0, 0, 0] erhalten.

def zero_list(n):
    result = []
    while n > 0:
        n = n - 1
        result.append(0)
    return result
 
print(zero_list(7))

Betrachte die Liste [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]

1. Berechne die Summe aller Elemente in der Liste in einer for-Schleife.
2. Berechne die Summe aller Elemente in der Liste in einer while-Schleife.
3. Berechne die Summe aller ungerader Elemente (also das erste, dritte,…) in der Liste.

Natürlich sollen sämtliche Schritte voll automatisiert ablaufen. Tauscht man die Liste mit einer anderen Liste, so soll der Code auch funktionieren.

L = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]
 
summe = 0
for elem in L:
    summe = summe + elem
print(summe)
 
summe2 = 0
i = 0
while i < len(L):
    summe2 = summe2 + L[i]
    i = i + 1
print(summe2)
 
summe3 = 0
i = 0
while i < len(L):
    summe3 = summe3 + L[i]
    i = i + 2
print(summe3)

Implementiere einige Funktionen, welche einem helfen sollen, Listen zu analysieren:

• Funktion liste_anzahl(L,x): Nimmt eine Liste L und eine Zahl oder ein String x entgegen. Die Funktion bestimmt dann, wie oft das Element x in L vorkommt und gibt diese Anzahl zurück.
• Funktion liste_max(L): Bestimmt das grösste Element einer List (welche aus Zahlen besteht) und gibt dieses zurück.
• Funktion liste_min(L): Ähnlich wie liste_max(L), gibt aber das kleinste Element zurück.

Für die Liste A = [3,1,5,4,9,4,8,3,1,2,4,9] und die Aufrufe

print(liste_anzahl(A,3))
print(liste_max(A))
print(liste_min(A))

ist der Output

2
9
1

def liste_anzahl(L, x):
    count = 0
    for elem in L:
        if elem == x:
            count = count + 1
    return count
 
def liste_max(L):
    maximum = L[0]  # Achtung, funktioniert nicht für leere Listen!
    for elem in L:
        if elem > maximum:
            maximum = elem
    return maximum
 
def liste_min(L):
    minimum = L[0]
    for elem in L:
        if elem < minimum:
            minimum = elem
    return minimum
 
A = [3,1,5,4,9,4,8,3,1,2,4,9]
print(liste_anzahl(A,3))
print(liste_max(A))
print(liste_min(A))

Definiere eine Funktion mittelwert(L), welcher eine Liste mit Zahlen übergeben wird. Von diesen Zahlen wird dann der Mittelwert berechnet und zurückgegeben. Übergibt man zum Beispiel eine Liste mit Schulnoten, so erhält man den Notendurchschnitt zurück. Zeige den Durchschnittswert dann in einem formatierten String an, z.B. „Der Mittelwert ist 4.46“.

def mittelwert(L):
    summe = 0
    for elem in L:
        summe = summe + elem
    return summe / len(L)
 
print("Der Mittelwert ist {0}".format(mittelwert([3.8, 4.2, 5.7, 4.8])))

Programmiere eine Funktion liste_haeufigste(L): Gibt eine Liste zurück, die alle Elemente enthält, die am häufigsten vorkommen. Neben dieser Liste wird auch eine Zahl ausgegeben, die angibt, wie oft diese Elemente in der Liste vorkommen.

Wir haben bereits die while-Schleife kennengelernt, aber auch, dass wir die Elemente einer Liste mit for viel eleganter besuchen können. Die for-Schleife kann zusammen mit der range Funktion auch sonst äusserst praktisch sein. range(n) erzeugt eine Liste der Zahlen von $0$ bis $n-1$.

Man kann damit einen Codeblock mehrfach hintereinander ausführen lassen. Zum Beispiel kann man mit dem folgenden Code ein Turtle ein Quadrat ablaufen lassen:

repeat 4:
    fritz.forward(150)
    fritz.right(90)

Genau das Gleiche kann man auch mit einer for-Schleife erreichen:

for i in range(4):
    fritz.forward(150)
    fritz.right(90)

Doch es gibt einen grossen Unterschied: In der for-Schleife hat man eine Variable (hier i), die in jedem Durchlauf einen anderen Wert hat: Im ersten Durchlauf den Wert 0, im nächsten 1, dann 2 und im letzten 3.

Quiz:

• Was ist der Output des folgenden Codeblocks?

for i in range(4):
    print(i)

• Was ist der Output des folgenden Codeblocks?

for k in range(4):
    print(5 + k*10)

Beispiel:

Mit einer for-Schleife können wir unsere Turtle jetzt interessantere Wege ablaufen lassen. Betracht zum Beispiel folgenden Code:

from gturtle import *
fritz = Turtle()
 
for j in range(30):
    fritz.forward(j*10)
    fritz.left(90)

• Überlege dir zuerst, wie die Figur aussieht. Stelle eine Vermutung auf.
• Implementiere nun den Code (Selbst tippen, nicht copy-paste!) und überprüfe deine Vermutung. Hattest du recht?
• Modifiziere nun deinen Code so, dass der Abstand zwischen den Linien (a) enger oder (b) grösser wird.

In den bisherigen for-Schleifen wurde der Parameter in jedem Durchlauf um 1 erhöht. Möchten wir, dass grössere Schritte gemacht werden, können wir wie folgt vorgehen:

for m in range(0,101,10):
    print(m)

Der Parameter m hat im ersten Durchlauf den Wert 0. In jedem weiteren Durchlauf wird er um 10 erhöht, bis zum maximalen Wert 100. Ersetzen wir die Zahl 101 durch 110, so ist das Resultat genau das gleiche. Erst mit 111 ist die grösste ausgegebene Zahl 110.

range() ist zusammen mit len() äusserst praktisch, um alle gültigen Positionen (Indices) einer Liste aufzuzählen:

numbers = [2, 5, 42, 17]
 
for index in range(len(numbers)):
    element = numbers[index]
    print(index, ":", element)

Tipp: Für die Aufgaben kann es jeweils eine Weile dauern, bis der Turtle den Weg abgelaufen ist. Verwende die hideTurtle-Funktion vor der for-Schleife, um gleich das Resultat anzuzeigen.

Du hast hoffentlich herausgefunden, wie man in einer quadratischen Spirale die Abstände zwischen den Linien kleiner und grösser machen kann. Zeichne nun in eine Figur zwei solche Spiralen ähnlich wie im Bild. Zeichne dazu mit einer for-Schleife die eine. Versetze dann die Position deiner Turtle mit setX und setY (oder setPos) und zeichne die Zweite Spirale mit einer neuen for-Schleife.

Verwende eine for-Schleife und die rightArc-Funktion um eine Spirale zu erzeugen, ähnlich wie diejenige im Bild.

Zeichne folgende Figur:

Wandle in while-Schleife um:

for i in range(4,12):
	print(i)

i = 4
while i < 12:
    print(i)
    i = i + 1

Wandle in möglichst kurze for-Schleife (max. 2 Zeilen) um:

i = 10
while i < 29:
    print(i)
    i = i + 3

for i in range(10, 29, 3):
    print(i)
"""
OUTPUT:
10
13
16
19
22
25
28
"""

Finde den Index (die Position) von "Bebraham" in der folgenden Liste:

['Cebraham', 'Debraham', 'Bebraham', 'Abraham']

names = ['Cebraham', 'Debraham', 'Bebraham', 'Abraham']
for index in range(len(names)):
    if names[index] == 'Bebraham':
        print(index)