====== Programmieren III: Listen, for-Schleifen ======

===== Listen =====

{{ :gf_informatik: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:

<code python>
alphabet = ['a','b','c','d','e']
</code>

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:

^ Position / Index ^  `0` ^  `1` ^  `2` ^  `3` ^  `4` ^
|Element| `'a'` | `'b'` | `'c'` | `'d'` | `'e'` |

Beachte, dass das erste Element den **Index 0** hat!

==== Selektion und Modifikation ====

Ü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:
<code python>
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']
</code>

Einer Liste kann man Elemente **hinzufügen** und **entfernen**
<code python>
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']
</code>

Die Länge einer Liste bestimmt man wie folgt:
<code python>
len(alphabet) # Anzahl Elemente in Liste
</code>

==== Iteration ====

Oft möchte man durch alle Elemente einer Liste **durchgehen** und etwas mit diesen machen, z.B. sie in die Konsole printen:
<code python>
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
</code>
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.
<code python>
for e in L:
    print(e)
</code>

Mit folgendem Code überprüft man, ob ein Element in einer Liste steht:
<code python>
if 'b' in ['a','c','e','g']:
    print('kommt in Liste vor')
else:
    print('kommt nicht in Liste vor')
</code>

==== Aufgaben H ====

=== Aufgabe H1 ===
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

<nodisp 1>
++++Lösung:|
<code python>
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)
</code>
++++
</nodisp>

=== Aufgabe H2 ===

Betrachte die Liste:

<code python>
likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"]
</code>

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

<nodisp 1>
++++Lösung:|
<code python>
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)
</code>
++++
</nodisp>

=== Aufgabe H3 ===

Betrachte die Liste `[68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]`
   - Berechne die Summe aller Elemente in der Liste in einer `for`-Schleife.
   - Berechne die Summe aller Elemente in der Liste in einer `while`-Schleife.
   - 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.

<nodisp 1>
++++Lösung:|
<code python>
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)
</code>
++++
</nodisp>
=== Aufgabe H4 ===

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 
<code python>
print(liste_anzahl(numbers, 3))
print(liste_max(numbers))
print(liste_min(numbers))
</code>
ist der Output
<code bash>
2
9
1
</code>

<nodisp 1>
++++Lösung:|
<code python>
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))
</code>
++++
</nodisp>

=== Aufgabe H5 ===

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".

<nodisp 1>
++++Lösung:|
<code python>
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])))
</code>
++++
</nodisp>

=== Aufgabe H6 (optional) ===

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.


===== For-Schleife =====

==== Theorie ====

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:

<code py>
repeat 4:
    fritz.forward(150)
    fritz.right(90)
</code>

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

<code python>
for i in range(4):
    fritz.forward(150)
    fritz.right(90)
</code>

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?

<code python>
for i in range(4):
    print(i)
</code>

* Was ist der Output des folgenden Codeblocks?

<code python>
for k in range(4):
    print(5 + k*10)
</code>

**Beispiel:**

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

<code python>
from turtle import *
fritz = Turtle()

for j in range(30):
    fritz.forward(j*10)
    fritz.left(90)
</code>

* Ü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.

=== Startwert ===

Statt immer bei null zu starten, kann der Startwert auch angegeben werden:
<code python>
for m in range(10,20):
    print(m)
</code>

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

=== Schrittweite ===
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:
<code python>
for m in range(0,101,10):
    print(m)
</code>

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`.

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

<code python>
numbers = [2, 5, 42, 17]

for index in range(len(numbers)):
    element = numbers[index]
    print(index, ":", element)
</code>

==== Aufgaben I ====

*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.

=== Aufgabe I1 ===

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.

{{ :gf_informatik_1m_20_21:spiralen_duo.png?250 |}}

=== Aufgabe I2 ===

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

{{ :gf_informatik_1m_20_21:spirale.png?200 |}}

=== Aufgabe I3 (optional) ===

Zeichne folgende Figur:

{{ :gf_informatik_1m_20_21:spirale_rechteckig.png?250 |}}

=== Aufgabe I4 ===
Wandle in `while`-Schleife um:
<code python>
for i in range(4,12):
    print(i)
</code>

<nodisp 1>
++++Lösung:|
<code python>
i = 4
while i < 12:
    print(i)
    i = i + 1
</code>
++++
</nodisp>
=== Aufgabe I5 ===
Wandle in möglichst kurze for-Schleife (max. 2 Zeilen) um:
<code python>
i = 10
while i < 29:
    print(i)
    i = i + 3
</code>

<nodisp 1>

++++Lösung|
<code python>
for i in range(10, 29, 3):
    print(i)
"""
OUTPUT:
10
13
16
19
22
25
28
"""
</code>
++++
</nodisp>

=== Aufgabe I6 ===
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 [[#positionen_einer_liste_aufzaehlen|hier]] erklärt.

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

<nodisp 1>
++++Lösung|
<code python>
names = ['Cebraham', 'Debraham', 'Bebraham', 'Abraham']
for index in range(len(names)):
    if names[index] == 'Bebraham':
        print(index)
</code>
++++
</nodisp>

=== Aufgabe I7 ===
**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.

<nodisp 1>
++++Lösung|
<code python>
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))
</code>
++++
</nodisp>

=== Aufgabe I8 ===
**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 [[#schrittweite|negative Schrittweite]] für `range`.

<nodisp 1>
++++Lösung|
<code python>
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))</code>
++++
</nodisp>