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

===== Listen =====

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:
<code python>
L = [2,4,6,8]
</code>
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:
<code python>
L = [2,4,6,8]
L.append(10)
</code>

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
<code python>
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
</code>

Es ist ganz einfach, alle Elemente einer Liste durchzugehen. Mit einer `while`-Schleife könnte das so aussehen:
<code python>
i = 0
while i < len(L):
    print(L[i])
    i = i + 1
</code>

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>

==== Aufgaben H ====

=== Aufgabe H1 ===

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.
   - 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]`.
   - 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.
   - 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!
   - 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.
   - 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.
   - 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//.

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

=== Aufgabe H2 ===

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.

<nodisp 1>
++++Lösung:|
<code python>
def zero_list(n):
    result = []
    while n > 0:
        n = n - 1
        result.append(0)
    return result

print(zero_list(7))
</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 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.

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

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

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

=== Aufgabe H5 ===

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

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

=== Aufgabe H6 (optional) ===

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.


===== 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 gturtle 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.

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

#### 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 `rightArc`-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: 

`['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>