Programmieren III: Listen, for-Schleifen

2023_listen.pdf

Bisher haben wir in Variablen einzelne Werte gespeichert. Kann man auch mehrere Werte in einer Variablen speichern? Ja! Mit Listen!

Eine Liste wird erstellt, indem die Elemente in [ eckigen Klammern ] (en: brackets) eingeschlossen werden:

alphabet = ['a','b','c','d','e']

Die Liste im Beispiel oben hat die fünf Elemente 'a', 'b', 'c', 'd' und 'e'. Jedes dieser Elemente hat einen bestimmten Index, seine Position in der Liste:

Beachte, dass das erste Element den Index 0 hat!

Über den Index kann man auf ein Element zugreifen, das Element wird ausgewählt oder selektiert. Dazu schreibt man zuerst den Namen der Liste und dann den Index in eckigen Klammern:

print(alphabet[2]) # gibt 'c' aus
 
alphabet[3] = 'z'  # ändert Element an Position 3 (also 'd') zu 'z'
print(alphabet)    # Ausgabe: ['a','b','c','z','e']

Einer Liste kann man Elemente hinzufügen und entfernen

alphabet.append('f')   # Fügt Element hinten an, Liste nachher: ['a','b','c','z','e','f']
alphabet.insert(1,'q') # Fügt Element 'q' an Position 1 ein, Liste nachher: ['a','q','b','c','z','e','f']
alphabet.pop(3)        # Entfernt Element an Position 3, Liste nachher: ['a','q','b','z','e','f']
alphabet.pop()         # Entfernt letztes Element, Liste nachher: ['a','q','b','z','e']

Die Länge einer Liste bestimmt man wie folgt:

len(alphabet) # Anzahl Elemente in Liste

Oft möchte man durch alle Elemente einer Liste durchgehen und etwas mit diesen machen, z.B. sie in die Konsole printen:

alphabet = ['a','b','c','d','e']
i = 0                     # Startindex, 0, weil wir zuerst das vorderste Element (hier 'a') auslesen möchten
while i < len(alphabet):  # Bedingung while-Schleife
    print(alphabet[i])    # lese Element aus Liste aus, alphabet[i], und printe dieses
    i = i + 1             # erhöhe Index

In der Bedingung i < len(alphabet) ermitteln wir mit len(alphabet) die Länge der Liste. Wichtig ist auch, dass der Index i kleiner (und nicht kleiner gleich) ist als diese Länge, da sonst versucht wird, auf Element zuzugreifen, welches nicht existiert.

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)

Mit folgendem Code überprüft man, ob ein Element in einer Liste steht:

if 'b' in ['a','c','e','g']:
    print('kommt in Liste vor')
else:
    print('kommt nicht in Liste vor')

Betrachte die Liste alphabet = ["B","C","X","D","Z","F","G","I","J"]. Korrigiere die Liste, indem du mit den entsprechenden Funktionen:

• am Anfang ein „A“ einfügst
• das „X“ entfernst
• dem Element mit Wert „Z“ den korrekten Wert „E“ zuweist
• am richtigen Ort ein „H“ einfügst
• am Ende ein „K“ anhängst

alphabet = ["B","C","X","D","Z","F","G","I","J"]
 
alphabet.insert(0,"A")
alphabet.pop(3) # oder: alphabet.remove("X")
alphabet[4] = "E"
alphabet.insert(7,"H")
alphabet.append("K")
 
print(alphabet)

Betrachte die Liste:

likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"]

1. Gehe mit einer Schleife der Reihe nach durch alle Elemente der Liste durch und gebe sie aus.
2. Die Bayern haben nichts in dieser Liste verloren. Bitte entferne sie, danke! Füge weiter deinen Lieblingsklub hinzu.

likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"]
 
# 1)
 
i = 0
while i < len(likeable_football_clubs):
    print(likeable_football_clubs[i])
    i = i + 1
 
# 2)
likeable_football_clubs.pop(3)
likeable_football_clubs.append("winterthur")
print(likeable_football_clubs)

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 Elemente mit geradem Index (also mit Index 0, 2,…) 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.

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

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

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

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

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

ist der Output

2
9
1

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

Definiere eine Funktion mittelwert(numbers), 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(numbers):
    summe = 0
    for elem in numbers:
        summe = summe + elem
    return summe / len(numbers)
 
print("Der Mittelwert ist " + str(mittelwert([3.8, 4.2, 5.7, 4.8])))

Programmiere eine Funktion liste_haeufigste(liste): 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 turtle 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.

Statt immer bei null zu starten, kann der Startwert auch angegeben werden:

for m in range(10,20):
    print(m)

Mit zwei Parametern interpretiert range den ersten als Start- und den zweiten als (exklusiven) Endwert.

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 drei Parameter verwenden:

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, solange er kleiner ist als der Endwert 101. 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 circle-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. Nutze eine for ... in range Schleife, bei der die range über die Länge der Liste geht, wie hier erklärt.

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

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

Teil 1: Schreibe eine Funktion reihensumme(), die die Summe aller Zahlen der Siebnerreihe zurückgibt, also $7 + 14 + 21 + \ldots + 63 + 70 = 385$. Verwende dazu eine for zahl in range(...) Schleife.

Teil 2: Ändere die Funktion so, dass der Teiler über ein Funktionsargument gewählt werden kann. Der Aufruf reihensumme(5) soll beispielsweise die Summe der Fünferreihe von 5 bis 50 berechnen und 275 zurückgeben. Der Aufruf ohne Argument soll weiterhin die Siebnerreihe addieren.

def reihensumme(n=7):
    """Berechnet die Summe der n-er-Reihe."""
    summe = 0
    for zahl in range(n, 11*n, n):  # Das Ende-Argument von range ist exklusiv, also reicht 10*n nicht!
        summe = summe + zahl
    return summe
 
print(reihensumme())
print(reihensumme(5))

Teil 1: Schreibe eine Funktion reverse(liste), die eine neue Liste erstellt und die Elemente von liste in umgekehrter Reihenfolge darin abspeichert und die umgekehrte Liste zurückgibt. Die eingebauten Funktionen reverse und reversed dürfen nicht benützt werden - verwende stattdessen eine negative Schrittweite für range.

def reverse(liste):
    result = []
    # range erzeugt eine Zahlenfolge n, n-1, ... 3, 2, 1, 0:
    #       Beginne mit dem letzten Index (len(liste) - 1)
    #       Der letzte Index ist 0, das exklusive Ende damit -1
    #       Die Schrittweite ist -1 (wir zählen ja rückwärts)
    for index in range(len(liste) - 1, -1, -1):
        result.append(liste[index])
    return result
 
names = ['Cebraham', 'Debraham', 'Bebraham', 'Abraham']
print(reverse(names))