Programmieren II: Weiterführende Programmierkonzepte [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Programmieren II: Weiterführende Programmierkonzepte ======

===== - Listen =====

++++Lernziele|

Grundsätzlich muss man alles können, was wir hier behandelt haben. Die Lernziele dienen als Orientierungshilfe beim Lernen.

   * Ich kann erklären, was Listen in Python sind und wofür diese nützlich sind.
   * Ich kann erklären, was die Elemente einer Liste sind und was deren Positionen / Indices sind.
   * Ich kann die Länge einer Liste ermitteln.
   * Ich kann die Elemente einer Liste einzeln ansteuern um diese zum Beispiel zu ändern oder auszugeben.
   * Ich kann Listen verändern, indem ich Elemente entferne, anfüge oder einfüge.
   * Ich kann über eine bestehende Liste iterieren.
   * Ich kann Werte aus Listen aufsummieren.
   * Ich kann eine Liste erstellen und dann in einer while-Schleife Elemente ein-/anfügen.
   * Ich kann Listen miteinander verbinden.
   * Ich kann eine Schleife abbrechen.

++++

{{ :gf_informatik:programmieren_ii_01_listen.pdf |Slides Listen}}
==== - Elemente auslesen und Listen manipulieren ====

Eine **Liste** ist eine Variable, in der man *mehrere Werte* speichern kann, z.B.:
<code python>
faves = ['Pizza',42,'Muzak']
</code>
Eine Liste besteht aus **Elementen**, wobei jedes Element an einer bestimmten **Position / Index** steht.
Achtung: Man beginnt Positionen **bei 0** zu zählen! Im Beispiel oben ist also 'Pizza' das Element an Position 0, 42 das Element mit Index 1 und 'Muzak' das Element an Position 2. Die Liste besteht aus 3 Elementen, wir sagen, dass sie **Länge** 3 hat.

Die **wichtigsten Befehle für Listen** sind in der Tabelle unten aufgeführt. Für die Beispiele starten wir mit der Liste `faves = ['Pizza',42,'Muzak']`. In den beiden rechten Spalten wird angegeben, welchen Wert das Beispiel annimmt resp. wie die Liste nach der Bearbeitung aussieht. Diese beziehen sich immer auf das Resultat der vorhergehenden Zeile.

^ **Erklärung** ^ **Code** ^ **Beispiel** ^ **Wert** ^ **Liste danach** ^
| **Länge** der Liste / Anzahl Elemente ermitteln | `len(liste)` | `len(faves)` | `3` | Liste unverändert |
| **Element** an Position **ermitteln** | `liste[index]` | `faves[2]` | `'Muzak'` | Liste unverändert |
| Element an Position **verändern** | `liste[index] = new_element`  | `faves[2] = 'Music'` | | `['Pizza',42,'Music']` |
| Element an Position **entfernen** | `pop()`  | `faves.pop(1)` | | `['Pizza','Music']` |
| Element hinten **anfügen** (engl. ‘append’)  | `append()` | `faves.append('Football’)` | | `['Pizza','Music','Football']` |
| Element an bestimmter Position **einfügen**  | `insert()` | `faves.insert(2,'Pasta')` | | `['Pizza','Music','Pasta','Football']` |



==== Aufgaben A ====

Löse alle Aufgaben in dieser Serie **auf Papier**. In jeder Aufgabe starten wir mit einer Liste, die vorgegeben wird. Diese Liste muss *nicht* abgeschrieben werden.

=== Aufgabe 1 ===

Notiere neben jedem print-Befehl dessen Ausgabe.

<code python>
buchstaben = ['c','g','a','z','w']
print(buchstaben)        # 1.
buchstaben.pop(3)
print(buchstaben)        # 2.
print(buchstaben[0])     # 3.
buchstaben.append('q')
print(buchstaben)        # 4.
buchstaben.insert(4,'e')
print(buchstaben)        # 5.
buchstaben[1] = 'k'
print(buchstaben)        # 6.
print(len(buchstaben))   # 7.
</code>

=== Aufgabe 2 ===

Notiere neben jedem print-Befehl dessen Ausgabe.

<code python>
cities = ["Bern", "Basel", "Zurich", "Genf", "Lausanne"]

print(len(cities)) # 1.
print(cities[3])   # 2.
cities.append("Winti")
cities.pop(1)
cities.insert(2,"Biel")
print(cities)      # 3.
</code>

=== Aufgabe 3 ===
 
Starte mit der folgenden Liste:
<code python>
fruits = ["Spaghetti", "Apfel", "Banane", "Schockolade", "Orane", "Birne"]
</code>

Notiere nun die Befehle, welche folgende Punkte umsetzen:

   1. Entferne alle Elemente, die (leider) nicht in diese Liste gehören.
   1. Füge ganz hinten eine "Mango" an.
   1. Füge zwischen "Apfel" und "Banane" eine Kiwi ein.
   1. Ooops, bei der "Orange" hat sich ein Fehler eingeschlichen. Korrigiere diesen, in dem du das Wort an Wort "Orane" durch "Orange" ersetzt.
   1. Füge ganz am Anfang eine "Blaubeere" ein.
   1. Befehl, welcher die Anzahl Früchte, die in der finalen Liste stehen, ermittelt.
   1. Notiere zum Schluss die Liste so, wie sie am Schluss aussieht.

=== Aufgabe 4 ===

Starte mit folgender Liste:
<code python>
days = ['Donnerstag', 'Freitag', 'Montag', 'Mittwoch', 'Dienstag', 'Sonntag', 'Samstag']
</code>
Das Ziel ist, die Wochentage in die korrekte Reihenfolge zu bringen (beginnend am 'Montag').

Verwende dazu die bisher gelernten Befehle `append(), insert(), pop()`, wobei jeder dieser Befehlemindestens einmal (sinnvoll) verwendet werden muss. Achtung: Es ist verboten, selbst die Wochentage zu schreiben. Möchte man z.B. den 'Montag' vorne einfügen, muss man das Element mit Index 2 ('Montag') aus der Liste auslesen und ganz vorne einfügen. 


++++Lösungen|

**Aufgabe 1:**
<code>
['c', 'g', 'a', 'z', 'w']       # 1.
['c', 'g', 'a', 'w']            # 2.
c                               # 3.
['c', 'g', 'a', 'w', 'q']       # 4.
['c', 'g', 'a', 'w', 'e', 'q']  # 5.
['c', 'k', 'a', 'w', 'e', 'q']  # 6.
6                               # 7.
</code>

**Aufgabe 2:**
<code>
5    # 1.
Genf # 2.
['Bern', 'Zurich', 'Biel', 'Genf', 'Lausanne', 'Winti'] # 3.
</code>

**Aufgabe 3:**
<code python>
fruits = ["Spaghetti", "Apfel", "Banane", "Schockolade", "Orane", "Birne"]

# 1.
fruits.pop(0)
fruits.pop(2)
# 2.
fruits.append("Mango")
# 3.
fruits.insert(1,"Kiwi")
# 4.
fruits[3] = "Orange"
# 5.
fruits.insert(0,"Blaubeere")
# 6.
len(fruits)
# oder
print(len(fruits))
# 7.
['Blaubeere', 'Apfel', 'Kiwi', 'Banane', 'Orange', 'Birne', 'Mango']
</code>

**Augabe 4:**
<code python>
days = ['Donnerstag', 'Freitag', 'Montag', 'Mittwoch', 'Dienstag', 'Sonntag', 'Samstag']
days.insert(0,days[2])
days.pop(3)
days.insert(1,days[4])
days.pop(5)
days.insert(2,days[4])
days.pop(5)
days.append(days[5])
days.pop(5)
print(days)
</code>


++++


==== - Listen iterieren ====

=== Aufgaben B ===

=== Aufgabe 1 ===

Betrachte die Liste `alphabet = ["B","C","X","D","Z","F","G","I","J"]`. Korrigiere die Liste, indem du:
   * 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

=== Aufgabe 2 ===

Die folgende Liste soll einige europäische Hauptstädte beinhalten:
<code python>
capitals = ["Berlin","Paris","Wien","Romanshorn","Ammsterdam","Konstanz","Prag"]
</code>
Korrigiere die Liste mithilfe der bisher gelernten Befehle:

   1. Ersetze "Romanshorn" direkt durch die Schweizer Hauptstadt.
   1. Entferne die deutsche Stadt, die nichts in der Liste verloren hat.
   1. Füge hinten die Hauptstadt von Norwegen ein.
   1. Füge zwischen "Berlin" und "Paris" noch "Rom" ein.
   1. Korrigiere den Schreibfehler in der holländischen Hauptstadt.

=== Aufgabe 3 ===

Betrachte die Liste:
<code python>
likeable_football_clubs = ["BVB", "Liverpool", "St. Gallen", "Bayern München", "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.

=== Aufgabe 4 ===

In der folgenden Liste sind alle Monate gespeichert: `months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]`.

   1. Gib einen nach dem anderen aus. Der Output soll also sein:<WRAP>
<code>
Januar
Februar
März
April
Mai
Juni
Juli
August
September
Oktober
November
Dezember
</code></WRAP>
   1. Gleich wie 1., jeder zweite Monat soll aber ausgelassen werden. Output:<WRAP>
<code>
Januar
März
Mai
Juli
September
November
</code></WRAP>

=== Aufgabe 5 ===

Gib von allen Zahlen, die in der Liste `primes = [2,3,5,7,11,13,17,19]` gespeichert sind, die jeweiligen Quadratzahlen aus. Ausgabe:
<code>
4
9
25
49
121
169
289
361
</code>

=== Aufgabe 6 ===

Erstelle eine Liste, welche alle geraden Zahlen von $2$ bis und mit $100$ enthält. Starte mit einer *leeren* Liste, `even = []`. Erzeuge dann in einer while-Schleife alle geraden Zahlen und füge sie dieser Liste hinzu. Printe am Schluss die Liste, um sie zu überprüfen: `print(even)`.

=== Aufgabe 7 ===

Monika hat insgesamt $5$ verschiedene Konten. In der Liste hat sie die Beträge notiert, die sie auf den jeweiligen Konten hat:
<code python>
money = [503,27,1366,242,961]
</code>
Wie viel Geld hat Monika? Berechne ihr Vermögen, indem du die einzelnen Beträge aufsummierst. Führe das Aufsummieren selbst in einer while-Schleife durch und verwende keine vordefinierte Funktion, die dies für dich erledigt. Monika überlegt sich, noch weitere Konten zu eröffnen, von denen sie die Beträge dann einfach der Liste anfügen würde. Dein Code soll dann nach wie vor funktionieren.

=== Aufgabe 8 ===

Speichere in einer Liste einige Noten, z.B. `grades = [5.5,4.75,6,3.5,5,5.5]`. Schreibe nun einen *eigenen* Code, der Notendurchschnitt berechnet, verwende also keine vordefinierte Funktion. Der Code soll auch funktionieren, wenn Noten entfernt oder hinzugefügt werden.

**Zusatzaufgabe:** Gib die note korrekt auf halbe Noten gerundet aus. Schreibe einen eigenen Code für entsprechende Berechnung.

=== Aufgabe 9 ===

Gegeben seien zwei gleich lange Listen. Der Code soll nun eine neue Liste erstellen, welche die beiden ursprünglichen wie folgt zusammenführt (merged):

`list_1 = ['R','M','N','H','R']` und `list_2 = ['o','a','s','o','n']` werden zu `['R', 'o', 'M', 'a', 'N', 's', 'H', 'o', 'R', 'n']`

=== Aufgabe 10 ===

Gegeben sei eine beliebige Liste `numbers`, welche ausschliesslich ganze Zahlen enthalten soll. Das Ziel ist nun, eine Liste zu erhalten, die die gleichen Werte in der gleichen Reihenfolge beinhaltet, mit Ausnahme aller Elemente mit Wert 7.
Beispiel: Für die Liste `numbers = [7,1,7,7,2,3,7,4,5,7,6,7,7,7,8,9,7,10]` soll das Resultat sein `[1, 2, 3, 4, 5, 6, 8, 9, 10]` sein.

Wähle eine der beiden Optionen:

   1. *Einfacher:* Speichere die erwünschten Zahlen in einer *neuen Liste*. Starte dazu mit einer leeren Liste, z.B. `numbers_wo_7 = []` und füge dann die erwünschten Zahlen eine nach der anderen hinzu.
   2. *Anspruchsvoller:* Erstelle *keine* weitere Liste sondern entferne diejenigen Elemente, die nicht in der Liste bleiben sollen.

=== Aufgabe 11 ===

Gegeben sei eine Liste mit Strings, z.B. `words = ["Elefant","Affe","Erdbeere","Esel","Schule","Tiger","Esstisch","Computer"]`. Ziel ist, eine Liste zu erhalten, welche die gleichen Strings in der gleichen Reihenfolge beinhaltet, mit Ausnahme derjenigen Strings, die mit "E" beginne.

Man hat hier wieder die beiden Optionen wie in einer Aufgabe vorher:

   1. *Einfacher*: Mit neuer Liste
   1. *Anspruchsvoller:* Ohne neue Liste, Lösche entsprechende Strings aus der Liste heraus.

*Tipp:* Falls `s` ein String ist, kann man mit `s[0]` auf den vordersten Buchstaben zugreifen.

=== Fertig mit Aufgaben? ===

   1. Einige Aufgaben haben anspruchsvollere Optionen, stelle sicher, dass du diese gelöst hast.
   1. Erstelle einen Account auf [[https://www.codewars.com/|CodeWards]], folge dazu dem [[gf_informatik:programmieren_training_websites#codewars|Tutorial]]. Löse selbst Aufgaben dort. Wähle z.B. den *Tag* "Fundamental".

==== Lösungen ====

<nodisp 1>

++++Lösungen|

**Lösung Aufgabe 1:**
<code python>
alphabet = ["B","C","X","D","Z","F","G","I","J"]

alphabet.insert(0,"A")
alphabet.pop(3)
alphabet[4] = "E"
alphabet.insert(7,"H")
alphabet.append("K")

print(alphabet)
</code>

**Lösung Aufgabe 2:**
<code python>
capitals = ["Berlin","Paris","Wien","Romanshorn","Ammsterdam","Konstanz","Prag"]

capitals[3] = "Zürich"
capitals.pop(5)
capitals.append("Oslo")
capitals.insert(1,"Rom")
capitals[5] = "Amsterdam"

print(capitals)
</code>

**Lösung Aufgabe 3:**
<code python>
likeable_football_clubs = ["BVB", "Liverpool", "St. Gallen", "Bayern München", "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("FC Romanshorn")

print(likeable_football_clubs)
</code>

**Lösung Aufgabe 4:**
<code python>
months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]

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

print() # leere Linie, damit Output der beiden Teilaufgaben unterscheiden kann

# 2)
i = 0
while i < len(months):
    print(months[i])
    i = i + 2
</code>

**Lösung Aufgabe 5:**
<code python>
primes = [2,3,5,7,11,13,17,19]

i = 0
while i < len(primes):
    print(primes[i]**2)
    i = i + 1
</code>

**Lösung Aufgabe 6:**
<code python>
even = []

i = 2
while i <= 100:
    even.append(i)
    i = i + 2 # die Erhoehung der Variable sollte am ENDE des Blocks stehen 
    
print(even)
</code>

**Lösung Aufgabe 7:**
<code python>
money = [503,27,1366,242,961]

total = 0
i = 0
while i < len(money):
    total = total + money[i]
    i = i + 1

print(total)
</code>

**Lösung Aufgabe 8:**
<code python>
grades = [5.5,4.75,6,3.5,5,5.5]

summe = 0
i = 0
while i < len(grades):
    summe = summe + grades[i]
    i = i + 1

average = summe / len(grades)

print(f"Der Notendurchschnitt ist {average}.")

# Zusatzaufgabe:
print(f"Der Notendurchschnitt auf 4tel-Noten gerundet ist {int(average * 4)/4}.")

# Alternative Berechnung der Rundung
# Idee: gehe alle moeglichen Noten 1,1.5,2,...,5,5.5,6 durch und schaue, ob Abstand von average genuegend klein ist.
grade = 1
while grade <= 6:
    if abs(grade - average) <= 0.25:
        average_rounded = grade
        break # kann Schleife Abbrechen, sobald korrekte Note gefunden hat
    grade = grade + 0.5

print(average_rounded)
</code>

**Lösung Aufgabe 9:**
<code python>
list_1 = ['R','M','N','H','R']
list_2 = ['o','a','s','o','n']

list_merged = []
i = 0
while i < len(list_1):
    list_merged.append(list_1[i])
    list_merged.append(list_2[i])
    i = i + 1

print(list_merged)
</code>

**Lösung Aufgabe 10:**
<code python>
# OPTION 1 (einfacher)
numbers = [7,1,7,7,2,3,7,4,5,7,6,7,7,7,8,9,7,10]

numbers_wo_7 = []

i = 0
while i < len(numbers):
    if numbers[i] != 7:
        numbers_wo_7.append(numbers[i])
    i = i + 1

print(numbers_wo_7)
    
# OPTION 2 (anspruchsvoller)
numbers = [7,1,7,7,2,3,7,4,5,7,6,7,7,7,8,9,7,10]

i = 0
while i < len(numbers):
    if numbers[i] == 7:
        numbers.pop(i)
    else: # Achtung: Darf i nur erhoehen, wenn kein Element entfernt wurde. Grund: Wenn Element entfernt, ruecken alle nachherigen um eine Position zurueck
        i = i + 1
 
print(numbers)
</code>

**Lösung Aufgabe 11:**
<code python>
## OPTION 1 (einfacher)
words = ["Elefant","Affe","Erdbeere","Esel","Schule","Tiger","Esstisch","Computer"]

words_wo_E = []
i = 0
while i < len(words):
    if words[i][0] != "E":
        words_wo_E.append(words[i])
    i = i + 1

print(words_wo_E)
        
## OPTION 2 (anspruchsvoller)
words = ["Elefant","Affe","Erdbeere","Esel","Schule","Tiger","Esstisch","Computer"]

i = 0
while i < len(words):
    if words[i][0] == "E":
        words.pop(i)
    else:
        i = i + 1
 
print(words)
</code>


++++

</nodisp>

===== - For-Schleifen =====

++++Lernziele|

**Lernziele:**

   * For-Schleifen mit while-Schleifen vergleichen: Was sind die Gemeinsamkeiten, was die Unterschiede? Welche Vorteile hat die for-Schleife?
   * Mit einer for-Schleife die Elemente einer Liste durchgehen und mit diesen etwas machen. Bsp.: Zahlen in Liste aufsummieren.
   * Mit einer for-Schleife die Symbole eines Strings durchgehen und mit diesen etwas machen.
   * For-Schleifen mit range verwenden.
   * Wissen, wann man range verwenden sollte und wann nicht.
   * Eine while-Schleife in eine for-Schleife 'übersetzen' und umgekehrt.
   * Mit einer for-Schleife eine leere Liste befüllen: Starte mit einer leeren Liste und füge dieser in jedem Durchlauf der Schleife ein Element hinzu.
   * Mit einer for-Schleife einen leeren String befüllen: Starte mit einem leeren String und füge diesem in jedem Durchlauf der Schleife ein Symbol hinzu. Achtung: Funktioniert etwas anders als bei Listen.
   * Anspruchsvoll: Code mit zwei ineinander verschachtelten for-Schleifen.

**Tipps zur Vorbereitung:**

   * Aufgaben im Stile der Aufgaben im Wiki lösen.
   * Lasse dir neue Aufgaben generieren von ChatGPT, Prompt z.B.: "Generiere mir einige Aufgaben, die ich mit for-Schleifen in Python lösen kann".

**Typische Aufgaben:**

   * Werte einer Liste aufsummieren.
   * Zählen, wie oft ein Element in einer Liste/String vorkommt.
   * Position(en) von Element in Liste/String bestimmen.
   * Leere Liste/String mit Werten befüllen. Zum Beispiel:
     * Generiere Liste mit allen vielfachen von Drei von 3 bis und mit 999.
     * Generiere Liste mit Werten von Zahlenfolge (z.B. Fibonacci).
   * For-Schleife in while übersetzen und umgekehrt.

   * For-Schleifen mit while-Schleifen vergleichen: Was sind die Gemeinsamkeiten, was die Unterschiede? Welche Vorteile hat die for-Schleife?
   * Mit einer for-Schleife die Elemente einer Liste durchgehen und mit diesen etwas machen. Bsp.: Zahlen in Liste aufsummieren.
   * Mit einer for-Schleife die Symbole eines Strings durchgehen und mit diesen etwas machen.
   * For-Schleifen mit range verwenden.
   * Wissen, wann man range verwenden sollte und wann nicht.
   * Eine while-Schleife in eine for-Schleife 'übersetzen' und umgekehrt.
   * Mit einer for-Schleife eine leere Liste befüllen: Starte mit einer leeren Liste und füge dieser in jedem Durchlauf der Schleife ein Element hinzu.
   * Mit einer for-Schleife einen leeren String befüllen: Starte mit einem leeren String und füge diesem in jedem Durchlauf der Schleife ein Symbol hinzu. Achtung: Funktioniert etwas anders als bei Listen.
   * Anspruchsvoll: Code mit zwei ineinander verschachtelten for-Schleifen.

Tipps zur Vorbereitung:

   * Aufgaben im Stile der Aufgaben im Wiki lösen.
   * Lasse dir neue Aufgaben generieren von ChatGPT, Prompt z.B.: "Generiere mir einige Aufgaben, die ich mit for-Schleifen in Python lösen kann".

Typische Aufgaben:

   * Werte einer Liste aufsummieren.
   * Zählen, wie oft ein Element in einer Liste/String vorkommt.
   * Position(en) von Element in Liste/String bestimmen.
   * Leere Liste/String mit Werten befüllen. Zum Beispiel:
     * Generiere Liste mit allen vielfachen von Drei von 3 bis und mit 999.
     * Generiere Liste mit Werten von Zahlenfolge (z.B. Fibonacci).
   * For-Schleife in while übersetzen und umgekehrt.

++++
==== Theorie I: Über Listen und Strings iterieren ====

{{ :gf_informatik:programmieren_ii_02_for_schleifen.pdf |Slides For-Schleife}}

Eine **for-Schleife** wird verwendet, um **alle Elemente einer Sequenz** (wie eine Liste, String usw.) durchzugehen. Man nennt dies auch *über eine Sequenz iterieren*.

For-Schleifen haben die Form:
<code python>
for element in sequence:
    # Aktion, die für jedes Element ausgeführt wird
</code>

Um zum Beispiel alle **Elemente einer Liste** auszugeben, schreibt man einfach:
<code python>
fruits = ["Apfel", "Banane", "Kirsche"]
for fruit in fruits:
    print(fruit)
</code>

++++Äquivalente while-Schleife|
<code python>
fruits = ["Apfel", "Banane", "Kirsche"]
i = 0
while i < len(fruits):
    print(fruits[i])
    i = i + 1
</code>
++++

Ganz ähnlich kann man alle **Zeichen eines Strings** durchgehen:
<code python>
word = "Python"
for letter in word:
    print(letter)
</code>
Der Output wird dann sein:
<code bash>
P
y
t
h
o
n
</code>

++++Äquivalente while-Schleife|
<code python>
word = "Python"
i = 0
while i < len(word):
    print(word[i])
    i = i + 1
</code>
++++

==== Aufgaben A ====

=== Aufgabe 1 ===

Die Noten der letzten Franz-Prüfung einer Klasse sind:
`grades = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]`

   1. Berechne den Klassendurchschnitt selbst mithilfe einer while-Schleife.
   1. Berechne den Klassendurchschnitt nun nochmals, aber mithilfe einer for-Schleife. Verwende in der Schleife eine sinnvolle Variable.

=== Aufgabe 2 ===

Finde mithilfe einer for-Schleife in der folgenden Liste die grösste Zahl und gib diese aus: `numbers = [3, 6, 2, 8, 4, 10, 1]`. Der Code soll auch für alle anderen Listen mit Zahlen funktionieren.

Wende deinen Code nun auf diese längere Liste an: `numbers = [14, 41, 136, 38, 120, 24, 8, 129, 115, 117, 122, 1, 147, 39, 24, 94, 61, 26, 2, 26, 4, 73, 44, 78, 35, 156, 85, 116, 121, 106, 49, 131, 145, 32, 118, 118, 148, 19, 156, 25, 11, 3, 32, 102, 129, 129, 7, 20, 92, 35]` (Resultat: 156)

=== Aufgabe 3 ===

Schreibe einen Code, der mithilfe einer for-Schleife ermittelt, wie oft der Buchstabe 'S' in einem Wort (gespeichert in Variable `word`) vorkommt. Teste deinen Code für `WORD = "MISSISSIPPI"`.

=== Aufgabe 4 ===

Wandle mithilfe einer for-Schleife einen String in eine Liste um, die die Buchstaben des Wortes beinhaltet. Aus `word = "Python"` soll dann also `letters = ['P','y','t','h','o','n']` werden.

Starte wie folgt:
<code python>
word = "Python"
letters = [] # starte mit leerer Liste. Füge in for-Schleife nacheinander Buchstaben hinzu.

for ...
</code>

=== Aufgabe 5 ===

Gegeben sei eine Liste mit Zahle `numbers = [5,3,7,1,2]`. Erstelle mithilfe einer for-Schleife eine neue Liste `doubles`, die von den Zahlen aus `numbers` jeweils das Doppelte beinhalten soll. `doubles` soll dann also `[10,6,14,2,4]` sein-

=== Aufgabe 6 ===

Kombiniere die folgenden beiden String `s1 = "IFRAI"` und `s2 = "nomtk"` zu einem einzigen String `"InFoRmAtIk` mithilfe einer for-Schleife.

++++Tipps|

   * Verwende eine for-Schleife, um auf die Buchstaben von `s1` zuzugreifen.
   * Das Problem ist, wie man jetzt auf die Buchstaben von `s2` zugreift: Mache dies wie bei der while-Schleife (aber ohne eine solche). Definiere eine Variable `i=0`, die du am Ende der for-Schleife um $1$ erhöhst. Verwende dann das `i` um auf die Buchstaben von `s2` zuzugreifen.


++++


=== Aufgabe 7 ===

Gegeben ist die Liste `numbers = [24, 40, 16, 10, 7, 26, 15, 7, 25, 23, 25, 41, 38, 13, 21, 33, 10, 42, 13, 9, 20, 35, 5, 39, 15, 36, 35, 1, 27, 42]`. Erstelle eine neue, leere Liste `even = []`. Füge dieser Liste in einer for-Schleife alle *geraden* Zahlen aus numbers hinzu.

*Tipp:* Mit `x % 2 == 0` kann man herausfinden, ob `x` gerade ist (also durch $2$ teilbar ist) oder nicht.

=== Aufgabe 8 ===

Der König im Buch 'Die wilde Sophie' hat panische Angst vor dem Buchstaben 'E'. Er verlangt von seinen Untertanen, dass sie in ihrer Sprach den Buchstaben 'E' einfach auslassen. Anstelle "ESEL ESSEN GERNE ERDBEEREN, BESONDERS BEI EINEM ELEGANTEN ELEFANTENESSEN." sollen sie sagen und schreiben: "SL SSN GRN RDBRN, BSONDRS BI INM LGANTN LFANTNSSN."

Schreibe einen Code mit einer for-Schleife, der von einem gegebenen String eine neue Version *ohne* E's erstellt:
<code python>
text = "ESEL ESSEN GERNE ERDBEEREN, BESONDERS BEI EINEM ELEGANTEN ELEFANTENESSEN."
text_ohne_E = "" # hier füge in for-Schleife Buchstaben (ausser E) von Text hinzu

for ...
</code>

++++Tipps|

Zwei Strings kann man mit `+` zusammenfügen, z.B.:
<code python>
s = "Hallo " + "Welt" # hat dann den Wert "Hallo Welt"
</code>

++++

=== Aufgabe 9 ===

Diese und weitere Aufgaben weiter unten sollen mit **ineinander verschachtelten for-Schleifen** gelöst werden, also Code im Stil:
<code python>
for ...:
    for ...:
        ...
    ...
...
</code>

Mit zwei unterscheidbaren Würfeln wird gleichzeitig gewürfelt. Gib alle möglichen Resultate aus, also:
<code>
11
12
13
..
21
...
</code>
Tipp: Verwende verschachtelte for-Schleifen (for-Schleife in for-Schleife ...).

=== Aufgabe 10 ===

Kleines Einmaleins: Gib alle Multiplikationen von allen einstelligen natürlichen Zahlen aus.

**Variante 1 (einfach):**

Das Resultat soll also wie folgt aussehen:
<code>
0 * 0 = 0
0 * 1 = 0
0 * 2 = 0
0 * 3 = 0
0 * 4 = 0
0 * 5 = 0
0 * 6 = 0
0 * 7 = 0
0 * 8 = 0
0 * 9 = 0
1 * 0 = 0
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
1 * 4 = 4
...
9 * 9 = 81
</code>

**Variante 2 (anspruchsvoll):**

Das Resultat soll wie folgt ausgegeben werden:
<code>
  | 0| 1| 2| 3| 4| 5| 6| 7| 8| 9|
--|--|--|--|--|--|--|--|--|--|--|
0|| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0|
1|| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9|
2|| 0| 2| 4| 6| 8|10|12|14|16|18|
3|| 0| 3| 6| 9|12|15|18|21|24|27|
4|| 0| 4| 8|12|16|20|24|28|32|36|
5|| 0| 5|10|15|20|25|30|35|40|45|
6|| 0| 6|12|18|24|30|36|42|48|54|
7|| 0| 7|14|21|28|35|42|49|56|63|
8|| 0| 8|16|24|32|40|48|56|64|72|
9|| 0| 9|18|27|36|45|54|63|72|81|
</code>

Tipps:
   * Verwende die Liste `nrs = [0,1,2,3,4,5,6,7,8,9]` (resp. `range()` falls du dies bereits kennst).
   * Verwende wieder verschachtelte for-Schleifen.
   * Verwende f-Strings.




==== Theorie II: Range ====

{{ :gf_informatik:programmieren_ii_03_for_schleifen_ii.pdf |Slides For-Schleifen II}}

Oft möchte man durch eine Liste mit Zahlen wie `[1,2,3,4,5,...]` iterieren. Eine solche kann man mit der **range-**Funktion einfach erstellen: `range(<start>,<stop>,<step>)`, wobei:

   * `<start>` der Startwert ist.
   * `<end>` der Schlusswert ist (Achtung: nicht inklusive!)
   * `<step>` die Schrittweite zwischen zwei Zahlen ist.

Beispiel:
<code python>
for i in range(3,15,2):
    print(i) # Output: 3,5,7,9,11,13. Achtung OHNE 15!
</code>

Range kann mit **1-3 Inputs** verwendet werden:
   * `range(<start>,<stop>,<step>)`
   * `range(<start>,<stop>) = range(<start>,<stop>,1)`
   * `range(<stop>) = range(0,<stop>,1)`

Kann auch *rückwärts* iterieren: `range(10,3,-1) # [10,9,8,7,6,5,4]`

Oft möchte man nicht nur auf die Elemente einer Liste, sondern auch auf deren Positionen zugreifen. Beispiel:
<code python>
numbers = [7,42,13,70,42,37,42]

for i in range(len(numbers)):
    if numbers[i] == 42:
        print(f"Found 42 at index {i}")
</code>

==== Aufgaben B ====

Löse alle Aufgaben mit for-Schleifen und verwende wenn immer sinnvoll die range-Funktion.

=== Aufgabe 1 ===

   1. Zähle auf $100$: Gib alle ganzen Zahlen von $1$ bis und mit $100$ aus.
   1. Zähle von $10$ in $5$er-Schritten auf $100$, also $10,15,20,25,\ldots,95,100$.
   1. Zähle von $99$ in $3$er-Schritten bis auf $0 herunter.

=== Aufgabe 2 ===

Noten:
`grades = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]`

   1. Gib die Positionen aller Noten 6 aus.
   1. Berechne den Durchschnitt mit for.

=== Aufgabe 3 ===

   1. Berechne die Summe $1+2+3+\ldots+1000000$.
   1. Berechne die Summe aller gerader Zahlen bis und mit $1000000$, also $2+4+6+8+\ldots+1000000$

++++Lösungen|

   1. $500000500000$
   1. $250000500000$

++++
=== Aufgabe 4 ===

Wandle in möglichst kurze for-Schleife (max. 2 Zeilen) um. Der neue Code soll also den genau gleichen Output generieren wie der alte.
<code python>
i = 10
while i < 29:
    print(i)
    i = i + 3
</code>

=== Aufgabe 5 ===

**String umkehren**. Speichere einen String in einer Variablen ab, z.B. `text = "Hello, world!"`. Schreibe nun einen Code, der einen neuen String, z.B. `text_reversed` generiert, welcher den Text umgekehrt beinhaltet. Aus "Hello, world!" wird dann also "text = "Hello, world!" wird dann also "!dlrow ,olleH". Wie ist dein Name in umgekehrter Reihenfolge?

=== Aufgabe 6 ===

Bestimme die Anzahl Wörter im Gedicht "Der Erlkönig" von Goethe.

++++Gedicht|
<code>
poem = "WER REITET SO SPÄT DURCH NACHT UND WIND? ES IST DER VATER MIT SEINEM KIND; ER HAT DEN KNABEN WOHL IN DEM ARM, ER FASST IHN SICHER, ER HÄLT IHN WARM. MEIN SOHN, WAS BIRGST DU SO BANG DEIN GESICHT? SIEHST, VATER, DU DEN ERLKÖNIG NICHT? DEN ERLENKÖNIG MIT KRON UND SCHWEIF? MEIN SOHN, ES IST EIN NEBELSTREIF. DU LIEBES KIND, KOMM, GEH MIT MIR! GAR SCHÖNE SPIELE SPIEL ICH MIT DIR; MANCH BUNTE BLUMEN SIND AN DEM STRAND, MEINE MUTTER HAT MANCH GÜLDEN GEWAND. MEIN VATER, MEIN VATER, UND HÖREST DU NICHT, WAS ERLENKÖNIG MIR LEISE VERSPRICHT? SEI RUHIG, BLEIBE RUHIG, MEIN KIND; IN DÜRREN BLÄTTERN SÄUSELT DER WIND. WILLST, FEINER KNABE, DU MIT MIR GEHN? MEINE TÖCHTER SOLLEN DICH WARTEN SCHÖN; MEINE TÖCHTER FÜHREN DEN NÄCHTLICHEN REIHN UND WIEGEN UND TANZEN UND SINGEN DICH EIN. MEIN VATER, MEIN VATER, UND SIEHST DU NICHT DORT ERLKÖNIGS TÖCHTER AM DÜSTERN ORT? MEIN SOHN, MEIN SOHN, ICH SEH ES GENAU: ES SCHEINEN DIE ALTEN WEIDEN SO GRAU. ICH LIEBE DICH, MICH REIZT DEINE SCHÖNE GESTALT; UND BIST DU NICHT WILLIG, SO BRAUCH ICH GEWALT. MEIN VATER, MEIN VATER, JETZT FASST ER MICH AN! ERLKÖNIG HAT MIR EIN LEIDS GETAN! DEM VATER GRAUSETS; ER REITET GESCHWIND, ER HÄLT IN ARMEN DAS ÄCHZENDE KIND, ERREICHT DEN HOF MIT MÜHE UND NOT; IN SEINEN ARMEN DAS KIND WAR TOT."
</code>
++++

++++Tipps|
Zähle die Anzahl Leerschläge. Gehe dafür mit einer for-Schleife den Text durch.
++++

++++Antwort|
225
++++


=== Aufgabe 7 ===

Die Fakultät einer Zahl wird wie folgt berechnet:

   * $0! = 1$
   * $1! = 1$
   * $2! = 1 \cdot 2 = 2$
   * $3! = 1 \cdot 2 \cdot 3 = 6$
   * $4! = 1 \cdot 2 \cdot 3 \cdot 4 = 24$
   * $5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$
   * usw.

Schreibe einen Code, in dem die Benutzerin eine natürliche Zahl eingeben soll. Der Code berechnet dann die Fakultät dieser Zahl. Test deinen Code anhand der Beispiele oben.


=== Aufgabe 8 ===

Die bekannte **Fibonacci-Folge** ist $1,1,2,3,5,8,13,21,\ldots$. Findest du die Regel der Fibonacci-Folge selbst heraus? Versuche es für max. 2 min und lese nachher die Erklärung unten.

++++Erklärung Fibonacci-Folge|

Die ersten beiden Terme der Folge sind einfach gegeben: $1,1$. Jeder nachfolgende Term ist gegeben durch die *Summe der beiden vorherigen Terme*.

   * Nach $1,1$ kommt also $2$: $1,1,2$
   * $1,1,2$: das nächste Element ist also $1+2=3$
   * $1,1,2,3$: das nächste Element ist also $2+3=5$
   * $1,1,2,3,5$: das nächste Element ist also $3+5=8$
   * usw.

++++

Erstelle nun die Liste `fibonacci = [1,1]`. Füge dieser Liste nun in einer for-Schleife die nächsten $18$ Elemente der Fibonacci-Folge hinzu.


==== Lösungen B ====

++++Lösungen B|

Aufgabe 1
<code python>
for i in range(1,101):
    print(i)

for i in range(10,101,5):
    print(i)

for i in range(99,-1,-3):
    print(i)
</code>

Aufgabe 2
<code python>
grades = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]

summe = 0

for i in range(len(grades)):
    if grades[i] == 6:
        print("Note 6 trouvée à l'indice", i)
    summe += grades[i]

average = summe / len(grades)
print("La moyenne est de", average)
</code>

Aufgabe 3
<code python>
summe = 0

for i in range(1, 1000000 + 1):
    summe = summe + i

print(summe)
</code>

Aufgabe 4
<code python>
for i in range(10,29,3):
    print(i)
</code>

Aufgabe 5
<code python>

# Lösung 1 (mit range)
text = "Hello, world!"
text_reversed = ""

for i in range(len(text)-1,-1,-1):
    text_reversed = text_reversed + text[i]
    
print(text_reversed)

# Lösung 2 (ohne range)
text_reversed = ""

for char in text:
    text_reversed = char + text_reversed
    
print(text_reversed)
</code>

Aufgabe 6
<code python>

# Lösung 1 (mit range)
word_count = 1
for i in range(len(poem)):
    if poem[i] == " ":
        word_count = word_count + 1
print(word_count)

# Lösung 2 (ohne range)
word_count = 1
for char in poem:
    if char == " ":
        word_count = word_count + 1
print(word_count)
</code>

Aufgabe 7
<code python>
n = input()

fac = 1
for i in range(1,n+1):
    fac = fac * i
    
print(fac)
</code>

Aufgabe 8
<code python>
fibonacci = [1,1]

for i in range(18):
    fibonacci.append(fibonacci[i]+fibonacci[i+1])

print(fibonacci)
</code>

++++

===== - Funktionen =====

==== - Einführung: Funktionen & Modern Art ====

++++Lernziele|

**Lernziele:**

   * Wissen, was ein Funktionen sind und warum diese nützlich sind.
   * Funktionen definieren ohne Input und ohne/mit Rückgabewert.
   * Den Rückgabewert einer Funktion in der Konsole ausgeben.
   * Den Rückgabewert einer Funktion in einer Variablen speichern und mit diesem weiterarbeiten.
   * Mit random-Modul Zufallszahlen erzeugen können.

**Tipps zur Vorbereitung:**

   * Aufgaben im Stile der Aufgaben im Wiki lösen.
   * Lasse dir neue Aufgaben generieren von ChatGPT, Prompt z.B.: "Generiere mir einige Aufgaben, die ich mit for-Schleifen in Python lösen kann".

**Typische Aufgaben:**

   * Funktion schreiben, die Figur zeichnet mit gturtle.
   * Mathematische Funktion schreiben, die etwas berechnet und zurückgibt (z.B. Pythagoras).

++++

**Theorie & Aufträge in Slides:**

{{ :gf_informatik:gfif_funktionen_i.pdf |Slides Modern Art & Funktionen}}

++++Lösungen Auftrag II von Slides|

**A & B)**
<code python>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

turi.setPenColor("blue")
turi.setFillColor("red")
turi.setPenWidth(10)

def circle(x,y):
    turi.setPos(x,y)
    turi.startPath()
    turi.leftArc(30,360)
    turi.fillPath()

# CODE A
circle(-150,-50)
circle(-150,50)
circle(-50,-50)
circle(-50,50)
circle(50,-50)
circle(50,50)
circle(150,-50)
circle(150,50)

# CODE B
# Variante 1
for i in range(8):
    circle(i*100-300,-200)

# Variante 2
for x in range(-300,401,100):
    circle(x,-300)
</code>

**C)** (inkl. Input für Grösse des Kreises)
<code python>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

turi.setPenColor("blue")
turi.setFillColor("red")
turi.setPenWidth(10)

def circle(x,y,color,size):
    turi.setFillColor(color)
    turi.setPos(x,y)
    turi.startPath()
    turi.leftArc(size,360)
    turi.fillPath()

circle(-300,20,"green",50)
circle(100,20,"red",100)
circle(200,20,"pink",70)
</code>

++++

==== - Leitprogramm Funktionen ====

Arbeite dich selbständig durch dieses Leitprogramm. Zuerst kommt jeweils ein kurzer Theorieblock mit anschliessenden Aufgaben. Studiere die zugehörige Lösung, sobald du eine Aufgabe fertig gelöst hast.

=== Kapitel I: Basics ===

Eine Funktion erlaubt es einem, den gleichen Codeblock an verschiedenen Stellen im Code aufzurufen und auszuführen. Dadurch wird der Code kürzer und sauberer strukturiert.

In Python wird eine Funktion wie folgt programmiert:
<code python>
def name_der_funktion(<Input(s)>): # Argumente/Parameter sind optional
    # Codeblock
    # der Funktion
    return <Resultat> # ist optional
</code>

   * Das Schlüsselwort **def** leitet immer die Definition einer Funktion ein.
   * Darauf folgt der **Funktionsname**. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underlines _. Verwende immer *sinnvolle* Funktionsnamen!
   * Direkt anschliessend werden **runde Klammern** geschrieben. Diese enthalten die **Inputs / Parameter / Argumente**. Das sind Werte, die an die Funktion übergeben werden. Funktionen können auch ohne Parameter definiert werden, die Klammern sind dann halt einfach leer.
   * Nach einem **Doppelpunkt** ...
   * kommt der **Funktionskörper**, welcher den eigentlichen Code der Funktion beinhaltet. Dieser Code muss **eingerückt** sein. Dadurch weiss Python, welche Zeilen zur Funktion gehören und welche nicht mehr.
   * **Rückgabewert:** Eine Funktion kann (muss aber nicht) mit `return` etwas **zurückgeben**.

Nachdem du eine Funktion definiert hast, kannst du sie ganz einfach aufrufen. Dazu mehr in den Beispielen unten.

== Aufgabe ==

In Python gibt es viele *vorprogrammierte* Funktionen, die wir verwenden können, z.B. `len(["Pizza","Pasta"])` um die Anzahl Elemente einer Liste zu bestimmen:

   * `len` ist der **Name** der Funktion, steht für "length", also ein sinnvoller Name!
   * Die Liste `["Pizza","Pasta"]` ist der **Input**. In der Funktion drin wird diese Liste durchgegangen, um deren Anzahl Elemente zu ermitteln.
   * Der **Rückgabewert** ist die Anzahl Elemente in der Liste `["Pizza","Pasta"]`.

Du hast auch bereits die folgenden Funktionen kennengelernt. Notiere jeweils: Was sind die *Inputs*, was ist der *Rückgabewert* (falls es denn einen gibt).

   1. `print`
   1. `range`
   1. `forward` (für Turtles)


++++Lösung|

   1. `print`:
     1. Input: Das was in Konsole angezeigt werden soll.
     1. Rückgabewert: Keiner, die Funktion *macht* etwas (in Konsole schreiben), gibt aber nichts zurück. Deshalb macht z.B. `p = print("Hallo")` keinen Sinn.
   1. `range`:
     * Input: Zahlen, die Startwert, Endwert und Schrittweite angeben `range(3,13,2)`
     * Rückgabewert: Sequenz, für obige Inputs also `[3,5,7,9,11]`
   1. `forward`:
     1. Input: Zahl, Anzahl Pixel, die Turtle vorwärts laufen soll
     1. Rückgabewert: Keiner, die Funktion *macht* etwas (Turtle vorwärts laufen lassen), gibt aber nichts zurück. 

++++

**Hinweise zu den Codes**:

   1. Programmiere alle **Codes** mit dem **[[https://webtigerpython.ethz.ch|TigerPython-Editor]]** und speichere die Codes im OneNote ab.
   1. Verwende den **Debugger** in TigerPython. Mit diesem kannst du den Code **Schritt für Schritt** durchgehen. Das hilft dir, zu verstehen, was der Code genau macht.
      1. Debugger aktivieren: Drei Punkte oben rechts / Debugger
      1. Debugger verwenden: oranger Käfer / oranger Pfeil



=== Kapitel II: Funktion ohne Input und ohne Rückgabewert ===

Die einfachsten Funktionen sind solche *ohne Input* und *ohne Rückgabewert*. Solche Funktionen machen typischerweise einfach etwas wie in die Konsole zu schreiben. Stelle dir vor, du schreibst einen langen Code und brauchst ab und zu einen Motiavtions-Speech:
<code python>
def motivational_speech():
    print("Du kannst das!")
    print("Du bist super!")
</code>

== Aufgabe ==

Der Code unten besteht aus vier kurzen Codeblöcken.

   1. Kopiere den Code unten in den Editor.
   1. Füge dem Code am Anfang die Funktion `motivational_speech()` von oben an.
   1. Rufe nun nach jedem der vier Codeblöcke die Funktion auf.
   1. Gehe den Code mit dem Debugger durch. 

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

x = 5
if x > 10:
    print("A")
else:
    print("B")

k = 3
while k > 0:
    print(k)
    k = k - 1

foods = ["Pizza","Pasta"]
foods.append("Risotto")
</code>

++++Lösung|

<code python>
def motivational_speech():
    print("Du kannst das!")
    print("Du bist super!")

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

motivational_speech()

x = 5
if x > 10:
    print("A")
else:
    print("B")
    
motivational_speech()

k = 3
while k > 0:
    print(k)
    k = k - 1

motivational_speech()

foods = ["Pizza","Pasta"]
foods.append("Risotto")

motivational_speech()
</code>

++++

=== Kapitel III: Funktion mit Input und ohne Rückgabewert ===

Oft soll es aber eine gewisse Variation geben, wenn der Code ausgeführt wird.

== Aufgabe ==

Der folgende Code zeichnet vier rote Kreise mit blauem Rand in einem Quadrat angeordnet:
<code python>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

turi.setPenColor("blue")
turi.setFillColor("red")
turi.setPenWidth(10)

def circle(x,y):
    turi.setPos(x,y)
    turi.startPath()
    turi.leftArc(30,360)
    turi.fillPath()

circle(-50,-50)
circle(-50,50)
circle(50,-50)
circle(50,50)
</code>

   1. Kopiere den Code von oben in den Editor, lasse aber die letzten vier Zeilen Code (also die Funktionsaufrufe) weg.
   1. Füge dem Code direkt unter der Definition des Kreises eine Funktion `quadrat(x,y)` hinzu, welche die Turtle an die Koordinaten $(x,y)$ stellt und von dort aus ein Quadrat mit Seitenlänge $60$ zeichnet.
   1. Rufe nun die beiden Funktionen so auf, dass die folgende Figur reproduziert wird. 

{{:gf_informatik:modern_art_squares_circles.png?200|}}

++++Lösung|

<code python>
from gturtle import *
 
turi = Turtle()
turi.hideTurtle()
 
turi.setPenColor("blue")
turi.setFillColor("red")
turi.setPenWidth(10)
 
def circle(x,y):
    turi.setPos(x,y)
    turi.startPath()
    turi.leftArc(30,360)
    turi.fillPath()

def square(x,y):
    turi.setPos(x,y)
    turi.startPath()
    for i in range(4):
        turi.forward(60)
        turi.left(90)
    turi.fillPath()

square(-100,100-30)
circle(0,100)
square(100,100-30)

circle(-100,0)
square(0,-30)
circle(100,0)

square(-100,-100-30)
circle(0,-100)
square(100,-100-30)
</code>
Optimalerweise würde man hier zwei Variablen verwenden: Eine für die Grösse der Figuren und eine um sie richtig zu Positionieren. Falls du das gemacht hast: super!

++++

== Zusatzaufgabe ==

Reproduziere die folgende Funktion. Verwende zwei verschachtelte Schleifen für die Funktionsaufrufe:

++++Figur anzeigen|
{{:gf_informatik:modern_art_squares_circles_big.png?500|}}
++++

++++Lösungen|

<code python>
from gturtle import *

n = 11 # nr of rows and columns
l = 100 # size of forms

x0 = -l*n/2 # x coord of first form
y0 = -l*n/2

turi = Turtle()
turi.hideTurtle()
 
turi.setPenColor("blue")
turi.setFillColor("red")
turi.setPenWidth(10)
 
def circle(x,y):
    turi.setPos(x,y)
    turi.startPath()
    turi.leftArc(l*0.3,360)
    turi.fillPath()
 
def square(x,y):
    turi.setPos(x,y)
    turi.startPath()
    for i in range(4):
        turi.forward(l*0.6)
        turi.left(90)
    turi.fillPath()

for i in range(n):
    for k in range(n):
        if (i + k) % 2 == 0:
            square(x0+i*l,y0+k*l)
        else:
            circle(x0+i*l,y0+k*l+l*0.3)
</code>
++++
=== Kapitel IV: Funktion mit Rückgabewert ===

Die wohl am meisten verwendeten Funktionen benötigen Inputs und geben einen Rückgabewert zurück. Dies ist typischerweise der Fall für mathematische Funktionen, welche einem etwas ausrechnen sollen.

Möchte man zum Beispiel viele Zahlen quadrieren, kann man sich eine passende Funktion definieren und diese aufrufen:

<code python>
def square(x):
    return x * x

result = square(5)
print(result)

print(square(42))
</code>

== Aufgabe ==

   1. Kopiere den Code oben mit der `square`-Funktion in den Editor und gehe diesen mit dem Debugger Schritt für Schritt durch. Stelle sicher, dass du jeden Schritt genau verstehst.
   1. Verwende nun diese Funktion zusammen mit einer for-Schleife, um alle Quadratzahlen von $1$ bis und mit $20^2 = 400$ auszugeben.

++++Lösung|

<code python>
def square(x):
    return x * x

for i in range(1,21):
    print(square(i))
</code>

++++

== Aufgabe ==

Kopiere den folgenden Code in den Editor und vervollständige die Funktion. Verwende die vordefinierte Funktion `sqrt()` um die Quadratwurzel zu berechnen.
<code python>
def pythagoras(a,b):
    return # HIER DEIN CODE
    
print(pythagoras(3,4)) # Resultat muss 5 sein
</code>

++++Lösung|

<code python>
def pythagoras(a,b):
    return sqrt(a*a + b*b)

print(pythagoras(3,4)) # Resultat muss 5 sein
</code>

Kann auch Rechnung in eigener Zeile ausführen:
<code python>
def pythagoras(a,b):
    c = sqrt(a*a + b*b)
    return c

print(pythagoras(3,4)) # Resultat muss 5 sein
</code>

++++

== Aufgabe ==

   1. Definiere eine Funktion `umfang_kreis()`, der man den Radius eines Kreises übergeben soll. Die Funktion berechnet dann den Umfang des Kreises und gibt diesen zurück.
   1. Berechne mithilfe deiner Funktion den Umkreis der Kreise mit Radius:
     1. $r = 1$
     1. $r = 5$
     1. $r = 13$

++++Lösung|

<code python>
def umfang_kreis(r):
    return 2*3.14159*r

print(umfang_kreis(1))
print(umfang_kreis(5))
print(umfang_kreis(13))
</code>

++++

=== Kapitel V: Modern Art ===

Mache nun moderne Kunst!

   1. Verwende die bereits existierenden Funktionen `circle()` und `quadrat()`.
   1. Definiere neue Funktionen, z.B. `triangle()`.
   1. Füge den Funktionen weitere Inputs hinzu, mit denen man die Grösse und Farbe anpassen kann.
   1. Füge Zufallselemente ein: Platziere Figuren mit Zufallsgrössen und Zufallsfarben an Zufallspositionen. Verwende dazu das random-Modul:<WRAP>
<code python>
import random # in aller erster Zeile des Codes
# Achtung, es heisst randINT und nicht randIT !!!
r = random.randint(10,200) # generiert Zufallszahl im Bereich 10 bis 200$
</code></WRAP>

++++Lösung Modern Art mit Quadraten und Dreiecken|

<code python>
from gturtle import *
import random

turi = Turtle()
turi.hideTurtle()

colors = ['red','blue','green','yellow','purple','black']
#           0      1      2        3       4       5

def dreieck(x,y):
    r_width = random.randint(3,7)
    turi.setPenWidth(r_width)
    
    r_pen_col = random.randint(0,len(colors)-1)
    turi.setPenColor(colors[r_pen_col])
    
    r_fill_col = random.randint(0,len(colors)-1)
    turi.setFillColor(colors[r_fill_col])
    
    r_side = random.randint(40,150)
    
    turi.setPos(x,y)
    turi.startPath()
    for i in range(3):
        turi.forward(r_side)
        turi.left(120)
    
    turi.fillPath()


def quadrat(x,y):
    r_width = random.randint(10,30)
    turi.setPenWidth(r_width)
    
    r_pen_col = random.randint(0,len(colors)-1)
    turi.setPenColor(colors[r_pen_col])
    
    r_fill_col = random.randint(0,len(colors)-1)
    turi.setFillColor(colors[r_fill_col])
    
    r_side = random.randint(20,150)
    
    turi.setPos(x,y)
    turi.startPath()
    for i in range(4):
        turi.forward(r_side)
        turi.left(90)
    
    turi.fillPath()

r_anz_figs = random.randint(30,40)

for i in range(r_anz_figs):
    x_rand = random.randint(-300,300)
    y_rand = random.randint(-200,200)

    r_figur = random.randint(0,1)
    if r_figur == 0:
        quadrat(x_rand,y_rand)
    else:
        dreieck(x_rand,y_rand)
</code>

++++

==== - Aufgaben (Funktionen) ====

=== Aufgabe Würfelvolumen ===

Definiere eine Funktion mit einem Argument `volume_cube(x)`, die das Volumen eines Würfels mit Seitenlänge $x$ (in cm) berechnet und zurückgibt (also NICHT printed). Speichere das Resultat in einer Variablen und gib es dann aus.

Welches Volumen hat ein Würfel mit Seitenlänge 13 cm?

++++Lösung|

<code python>
def volume_cube(x):
    return x**3

vol = volume_cube(13)
print(vol)
</code>

++++

=== Aufgabe Kugelvolumen ===

Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
Definiere eine Funktion `volume_sphere(...)`, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi ($\pi$) kannst du mit `math.pi` aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (`import math`).

++++Lösung|

<code python>
import math

def volume_sphere(r):
    return 4 * math.pi / 3 * r**3

vol = volume_sphere(5)
print(vol)
</code>

++++

=== Aufgabe Notenberechnung ===

Schreibe eine Funktion `grade(points)`, die dir die Note (grade) für eine gegebene Punktzahl berechnet und zurückgibt. Lege die Punktzahl, die für die Note $6$ notwendig ist in einer Konstanten (wie Variable, aber alles Grossbuchstaben) fest. Die Formel geht wie folgt:
$$\text{Note} = \frac{5 \cdot \text{(erreichte Punkte)}}{\text{Punktzahl für Note 6}} + 1$$

Beachte:
   * Um die Noten schön zu runden, kannst du die //vordefinierte Funktion// `round` verwenden: `round(3.14159,2)` rundet dir die Zahl $3.14159$ auf zwei Nachkommastellen, man erhält also $3.14$.
   * Erreicht man mehr Punkte als notwendig für Note 6, soll man trotzdem die Note 6 erhalten.

++++Lösung|

<code python>
POINTS_FOR_SIX = 22

def grade(points):
    g = round(5 * points / POINTS_FOR_SIX + 1,2)
    if g > 6:
        return 6
    return g # kann auch vorher noch else: schreiben, macht keinen Unterschied

print(grade(0))
print(grade(20))
print(grade(22))
print(grade(24))
</code>

++++


=== Aufgabe Liste mit Vielfachen ===

Schreibe eine Funktion `liste_vielfache(vv,anzahl)`, welche zwei Zahlen als Inputs verlangt. Es soll eine Liste mit der Anzahl `anz` der Vielfachen der Zahl `vv` erstellt werden und zurückgegeben (nicht geprintet!) werden. Zum Beispiel soll `liste_vielfache(3,5)` die Liste `[3,6,9,12,15]` zurückgeben.

++++Lösung|

<code python>
def liste_vielfache(vv,anzahl):
    li = [] # Wichtig, dass in und NICHT ausserhalb der Funktion definiert wird. Warum?
    for i in range(1,anzahl+1):
        li.append(i*vv)
    return li
    
print(liste_vielfache(3,5))
</code>

++++

=== Aufgabe Fakutltät ===

Die **Fakultät** ist eine Funktion, welche jeder ganzen natürlichen Zahl das Produkt aller natürlichen Zahlen (ohne Null) kleiner und gleich dieser Zahl zuordnet. Sie wird mit einem Ausrufezeichen geschrieben. Als Beispiel: $5!=1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 =120$.

Schreibe eine Funktion `factorial(...)`, welcher als Argument eine ganze Zahl übergeben wird und welche dir dann die Fakultät dieser Zahl zurückgibt.

**Optionale Challenge für absolute Freaks**: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der *Rekursion* (Selbst-Aufruf) entdeckt!

++++Lösung|

<code python>
def factorial(n):
    p = 1
    for i in range(1,n+1):
        p = p * i
    return p

print(factorial(0))
print(factorial(1))
print(factorial(2))
print(factorial(3))
print(factorial(4))
print(factorial(5))
</code>

++++

=== Aufgabe Mitternachtsformel (Zusatzaufgabe) ===

Eine quadratische Funktion kann immer in die Form $$ax^2 + bx + c = 0$$ gebracht werden. Die Lösung ist gegeben durch die sogenannte **Mitternachtsformel**:
$$x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}$$

Schreibe eine Funktion `mitternachtsformel(...)`, die die drei Werte für $a,b,c$ entgegennimmt und die Lösung(en) zurück gibt. Beachte, dass es drei Fälle gibt:
   * keine Lösung: gib `None` zurück, dies ist der Fall, wenn der Term in der Wurzel negativ ist
   * eine Lösung, dies ist der Fall, wenn der Term in der Wurzel genau 0 ist
   * zwei Lösungen: gib Liste mit den beiden Werten zurück

Tipp: Verwende die Diskriminante, um den richtigen Fall zu ermitteln.

Kontrolle: Die quadratische Gleichung ...

   * $3 x^2 - 6 x - 5 = 0$ hat die zwei Lösungen: $-0.632993$ und $2.63299$
   * $x^2 - 4 x + 4 = 0$ hat eine Lösung: $2$
   * $x^2 + 2 x + 7 = 0$ hat keine Lösung


++++Lösung|

<code python>
def mitternachtsformel(a,b,c):
    d = b**2 - 4*a*c
    if d < 0:
        return []
    elif d == 0:
        return [-b/(2*a)]
    else:
        return [(-b-sqrt(d))/(2*a),(-b+sqrt(d))/(2*a)]
    
print(mitternachtsformel(3,-6,-5))
print(mitternachtsformel(1,-4,4))
print(mitternachtsformel(1,2,7))

</code>

++++