Programmieren Teil 3 – Listen (mit der while-Schleife) [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 Teil 3 – Listen (mit der while-Schleife) ======

  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_ii_gra|]].
  * Weiter zu [[gf_informatik:programmieren_iv_gra|]].

++++Lernziele:|

   * Ich beherrsche die in Teil 1 und 2 gelernten Grundlagen in python (Turtlegraphics, Variablen, while-Schleife (inkl. while True und break), Verzweigungen, Vergleichsoperatoren, mathematische Operatoren, f-Strings, Funktionen ''print'' und ''input'', nie repeat verwenden, clever und kompakt programmieren).
   * Ich kann Listen korrekt erstellen – leer oder mit Zahlen oder mit Texten drin.
   * Ich kann mit einer while-Schleife alle Elemente einer Liste durchgehen, sie auslesen oder ausgeben oder
   * ...mit einer if-Verzweigung abfragen und ggf. verändern oder entfernen.
   * Ich kann die Listen-Funktionen ''pop'', ''append'' und ''insert'' richtig verwenden.
   * Ich kann Listen anaylsieren (z.B. Mittelwert oder Höchstwert ermitteln) oder verändern (z.B. Duplikate entfernen etc).
   * Ich kann das Modul ''random'' importieren und die Funktion ''randint'' verwenden.
   * Ich kann bestimmte Elemente in einer Liste suchen.
   * Ich kann bestimmte Elemente in einer Liste zählen. 

++++

==== Rückblick auf Variablen ====
Du kennst bereits Variablen und kannst diese verwenden. In einer Variable kannst du **einen Wert** – eine Zahl oder einen Text – **speichern**:

<code python>
my_text = "Hallo Welt" # in der Variable namens my_text wird der Wert "Hallo Welt" gespeichert.
my_number = 5          # in der Variable namens my_number wird der Wert 5 gespeichert.

print(my_number)       # der Wert in der Variable my_number wird ausgegeben.
print(my_text)         # der Wert in der Variable my_text wird ausgegeben.
</code>

++++ Warum nutzen wir Variablen?|
Wir verwenden Variablen vor allem aus folgenden Gründen:
  - Variablen können **zur Laufzeit** (während das Programm ausgeführt wird) **verändert** werden.
  - Variablen können **abgefragt** werden: Abhängig vom Wert einer Variable kann zum Beispiel eine Schleife verlassen oder ein bestimmter Zweig ausgeführt werden.
Damit werden Codes wie der folgende Count-Down möglich:
<code python>
count = 10             # Variable definieren
while count > 0:       # Variable abfragen
    print(count)       # Variable ausgeben
    count = count - 1  # Variable verändern
print("null!")
</code>

Ausserdem haben Variablen folgende **Vorteile** – vergleiche die beiden Codes unten mit und ohne Variablen:
  * Wiederholungen vermeiden: Einen wiederholt verwendeten Wert kannst du in einer Variable speichern. Wenn du sie später ändern möchtest, brauchst du nur //eine// Stelle zu ändern, nicht viele. 
  * Code lesbarer machen: Mit sinnvollen Namen für deine Variablen wird der Code lesbarer: Statt einer blossen Zahl sehen wir sofort, um welche Grösse es sich handelt.

<WRAP group>
<WRAP column half>
== Mit Variablen ==

<code python>
from gturtle import *
donatello = Turtle()

radius = 100
winkel = 220

donatello.rightArc(radius, winkel)
donatello.leftArc(radius, winkel)
donatello.rightArc(radius, winkel)
donatello.leftArc(radius, winkel)
</code>
</WRAP>

<WRAP column half>
== Ohne Variablen ==
<code python>
from gturtle import *
donatello = Turtle()

donatello.rightArc(100, 220)
donatello.leftArc(100, 220)
donatello.rightArc(100, 220)
donatello.leftArc(100, 220)
</code>
Der Code ist zwar etwas kürzer, aber weniger gut lesbar (wofür stehen die Zahlen?) und nicht so leicht anpassbar.

</WRAP>
</WRAP>
++++
===== Listen – Mehrere Werte an einem Ort =====
Wenn du **mehrere Werte** – mehrere Zahlen oder mehrere Texte – **speichern** willst, brauchst du eine **Liste**.

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!

==== Elemente in einer Liste auswählen (Selektion) und verändern (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>
alphabet = ['a','b','c','d','e']
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>

==== Eine Liste durchgehen (Iteration) ====

Oft möchte man alle Elemente einer Liste **durchgehen** und etwas mit ihnen machen, z.B. sie ausgeben:
<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 < 5:              # Bedingung while-Schleife
    print(alphabet[i])    # lese Element aus Liste aus, alphabet[i], und printe dieses
    i = i + 1             # erhöhe Index
</code>

Wie gross wird ''i'' in dieser Schleife? Solange ''i'' kleiner als 5 ist, wird der Code in der Schleife ausgeführt. Sobald diese Bedingung nicht mehr erfüllt ist, wird die Schleife verlassen. Also wird ''i'' nicht grösser als 4. Es werden also alle fünf Elemente der Liste ausgegeben.

== Länge einer Liste ermitteln mit der Funktion len() ==
In obigem Code musst du die Bedingung der while-Schleife anpassen, wenn sich die Länge der Liste ändert. Für die Liste ''alphabet = ['a','b','c']'' müsstest du die Zahl 5 auf 2 anpassen, weil es in dieser Liste nur die Positionen 0, 1 und 2 gibt. Vergisst du das, so wird ''i'' höher als 2 und der Computer versucht, auf ein Element zuzugreifen, das nicht existiert. Dann erscheint die Fehlermeldung: <color #ed1c24>IndexError: list index out of range.</color> Mit der Funktion ''len()'' kannst du solche Fehler vermeiden:
<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. Für obige Liste ''alphabet'' mit fünf Elementen gibt ''len(alphabet)'' den Wert 5 zurück.
==== Aufgaben L ====

=== Aufgabe L1 – Element auswählen ===
Kopiere folgende Liste in deinen Code und gib ein beliebiges Element aus der Liste aus (mit ''print'').
<code python>
planeten = ["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]
</code>

=== Aufgabe L2 – Element verändern  ===
Betrachte folgende Liste: Ein Element ist falsch. Dein Code soll Folgendes tun:
  - Die falsche Liste ausgeben,
  - das betreffende Element korrigieren und
  - die korrigierte Liste ausgeben.
<code python>
planeten = ["Merkur", "Venus", "Erde", "Snickers", "Jupiter", "Saturn", "Uranus", "Neptun"]
</code>



=== Aufgabe L3 – Elemente entfernen und hizufügen ===
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

Zuletzt gibst du die korrigierte Liste aus.

=== Aufgabe L4 – Liste längster Flüsse ===
Erstelle eine Liste mit den sieben längsten Flüssen in der Schweiz (siehe [[https://de.wikipedia.org/wiki/Liste_der_Flüsse_in_der_Schweiz|hier]]: sortiere erst nach Länge, lasse die Varianten mit "ob" weg). 

== Version 1 ==
Schreibe ein Programm mit einer while-Schleife, das jedes Element der Liste ausgibt.

== Version 2 == 
Erweitere dein Programm, sodass mit dem Flussnamen auch der Rang ausgegeben wird, also so:
<code>
1. Rhein
2. Aare
3. Reuss
...
</code>
Tipp: Erstelle einen [[gf_informatik:programmieren_ii_gra#strings|f-String]]
=== Aufgabe L5 – Jedes zweite Element ausgeben ===
Kopiere folgende Liste in deinen Code. Schreibe ein Programm, das jedes zweite Element der Liste ausgibt.
<code python>
buchstaben = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
</code>

=== Aufgabe L6 – Farbige Punkte ===
Kopiere folgende Liste in deinen Code. Schreibe ein Programm (mit TurtleGraphics), das gemäss der Liste farbige 20px-Punkte von links nach rechts zeichnet – so wie im Bild. Natürlich mit while-Schleife.

<code python>
colors = ["red", "orange", "yellow", "green", "blue", "purple"]
</code>

{{:gf_informatik:programmieren_iii_gra:pasted:20250305-061713.png?250}}

=== Aufgabe L7 – Summe ===
Kopiere folgende Liste in deinen Code. Schreibe ein Programm, das die Summe aller Zahlen der Liste berechnet und ausgibt. Das Programm soll mit jeder beliebigen Zahlenliste funktionieren. (Es ist nicht erlaubt, die bestehende sum-Funktion o. ä. zu verwenden).

<code python>
numbers = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]
</code> 

=== Aufgabe L8 – Zahlenliste generieren ===
Erstelle ein Programm, bei dem die Benutzer:in eine obere Grenze eingeben kann (mit ''input''). Dein Programm erstellt dann eine Liste aller Ganzzahlen von 1 bis und mit zu dieser Grenze und gibt die Liste aus.

Beispiel: Für die Eingabe 7 soll die Liste [1, 2, 3, 4, 5, 6, 7] ausgegeben werden. Benutze die Funktion ''append''. 

Eine leere Liste erstellst du so:
<code python>
numbers = []
</code>

=== Aufgabe L9 – Liste zufälliger Zahlen generieren ===
<box 100% round green|**Random**>

Mit dem Modul ''random'' kannst du zufällige Zahlen erzeugen. Hier ein Beispiel:

<code python>
import random
zahl1 = random.randint(1, 9)
print(zahl1)
</code>

- Die erste Zeile importiert das Modul random.
- In der zweiten Zeile wird //zahl1// auf eine zufällige Zahl zwischen 1 und 9 gesetzt. Bei der Funktion ''randint()'' gibst du in der Klammer den Bereich an, aus dem eine zufällige Zahl gewählt wird.
- Die dritte Zeile gibt die Zahl aus.

[[https://webtigerpython.ethz.ch/?code=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMNGbAewCcyACBqCYumAHQgC8oACwA2ARmYBeVu04xMbDhjIAKUQWYBOAJS9sDJcoEjROiM3PNeViGAC-AXSA|Probiere es aus – führe den Code mehrmals aus!]]

</box>


Schreibe ein Programm, das ein Liste mit 12 zufälligen Zahlen im Bereich 1...99 generiert und ausgibt (siehe Infos zum Modul random oben).

=== Aufgabe L10 – Bösi 7 is back ===

{{:gf_informatik:programmieren_iii_gra:pasted:20250310-161038.png?200}}

Gehe von Aufgabe L9 aus: Du hast eine Liste mit 12 zufälligen Zahlen im Bereich 1...99 generiert und ausgegeben. Erweitere dieses Programm nun wie folgt:

== Version 1 ==
Dein Programm, geht die Liste durch und ersetzt alle Vielfachen von 7 durch den Text "Bösi". Am Ende wird die Liste ausgegeben.

== Version 2 ==
Dein Programm zählt, wie viele "Bösi" in die Liste eingesetzt wurden und gibt am Ende (zusätzlich) eine Meldung in folgendem Format aus "Deine Liste enthält 2 Bösi".

== Version 3 == 
Dein Programm erstellt eine zweite Liste mit allen "bösen" Zahlen und gibt diese zusätzlich zur abgeänderten Liste aus. Zum Beispiel so:
<code>
[75, 65, 24, 'Bösi', 60, 65, 30, 69, 12, 43, 'Bösi', 8]
[63, 77]
</code>

== Version 4 ==
Dein Programm gibt abhängig von der **Anzahl "Bösi"** eine von vier Meldungen aus:
  * 0: "Keine Bösi in der Liste! Du Glückspilz!"
  * 1-3: "Ein paar Bösi in der Liste. Das kann passieren."
  * 4-5: "Sehr viele Bösi in der Liste – ich würde mir Sorgen machen!"
  * 6+: ...wähle selbst eine passende Nachricht ...

=== Aufgabe L11 – Mittelwert ===
Schreibe ein Programm, das von einer beliebigen Zahlenliste den Mittelwert (Durchschnitt) aller Zahlen in dieser Liste berechnet. Teste dein Programm mit folgenden Listen. (Verwende eine while-Schleife. Es ist nicht erlaubt, die bestehende sum-Funktion zu verwenden).

<WRAP group>
<WRAP column twothirds>
<code>
[8, 79, 86, 14, 92, 23, 38, 62, 71, 53, 2, 93]
[7, 23, 27, 1, 18]
[5, 7, 2, 20, 9, 9, 11, 15, 2, 6, 16, 17, 20, 14, 10, 4, 7, 7, 4, 3]
</code>
</WRAP>

<WRAP column third>
<code>
Mittelwert = 51.75
Mittelwert = 15.2
Mittelwert = 9.4
</code>
</WRAP>
</WRAP>

=== Aufgabe L12 – Aschenputtels Tauben ===
Aschenputtels böse Stiefmutter und Stiefschwestern warfen immer wieder mal eine Schale voller **Linsen** in die Asche, welche Aschenputtel dann herauslesen und sortieren musste. Aschenputtel hatte zum Glück ein gutes Verhältnis zu den Tauben in ihrer Umgebung:
<WRAP group>
<WRAP column third>
{{:gf_informatik:programmieren_iii_gra:pasted:20250312-152500.png?250| }}
</WRAP>

<WRAP column twothirds>
//„Ihr zahmen Täubchen, ihr Turteltäubchen, \\
all ihr Vöglein unter dem Himmel,\\
kommt und helft mir lesen,\\
die guten ins Töpfchen,\\
die schlechten ins Kröpfchen.“//
</WRAP>
</WRAP>

== Version 1 ==
Schreibe ein Programm, das wie die Tauben die guten von den schlechten Linsen in Windeseile trennt: 
  * Kopiere die Liste //durcheinander// in deinen Code und und erstelle zwei neue Listen namens //toepfchen// und //kroepfchen//. 
  * Dein Programm geht die Liste //durcheinander// durch, entfernt jedes Element aus dieser und fügt es einer der beiden andern Listen hinzu:
    * jede einwandreie "Linse" kommt in die Liste //toepfchen//,
    * alle anderen Texte kommt in die Liste //kroepfchen//.
  * Am Ende werden alle drei Listen ausgegeben. Die Liste //durcheinander// muss dann leer sein.
<code python>
durcheinander = ["Linse", "lnse", "Linse", "lünse", "Lnise", "Linse", "insel", "lönse", "lNSe", "LiNsi", "Linse", "lYnse", "Liins", "Linis", "Linse", "Linse", "lisne", "Linse", "Lynsu", "Line", "Linse"]
</code>
== Version 2 ==
Erweitere dein Programm um eine kleine Kontrolle: Am Ende soll dein ein Text in folgendem Format ausgegeben werden: 

"Es wurden x Linsen sortiert: y gute und z schlechte."

=== Aufgabe L13 – Gerade ungerade ===
  - Dein Programm soll zuerst eine Liste von 15 zufälligen Zahlen im Bereich zwischen 1 und 20 erstellen (wie in Aufgabe L9). Diese Liste soll //even\_numbers// heissen. Aber die Liste enthält zurzeit nicht nur gerade, sondern auch ungerade Zahlen.
  - Im zweiten Schritt soll dein Programm die Liste //even\_numbers// durchgehen, jede ungerade Zahl aus dieser Liste löschen und sie einer anderen Liste //odd\_numbers// hinzufügen.

=== Aufgabe L14 – Da oder nicht da ===
<box 100% round green|**Prüfen, ob ein Element in einer Liste steht **>

Mit folgendem Code überprüfst du, 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>
</box>

Schreibe ein Programm, das wie folgt funktinoiert:
  - Die Benutzer:in kann eine beliebige Zahl zwischen 1 und 50 eingeben.
  - Dann prüft dein Programm, ob die eingegebene Zahl in der Liste ''numbers'' (von unten kopieren) drin ist und gibt eine von zwei Meldungen aus:
    - Sorry, die Zahl ... ist in der Liste nicht vorhanden.
    - Treffer! Die Zahl ... ist in der Liste vorhanden!

<code python>
numbers = [39, 40, 32, 21, 32, 27, 14, 45, 28, 20, 15, 7]
</code>

=== Aufgabe L15 – Duplikate ade ===
In untenstehender Liste sind einige Elemente mehrfach aufgeführt: Die Liste enthält sogenannte //Duplikate//.
<code python>
bands = ["The Beatles", "The Kinks", "Blur", "Led Zeppelin", "Radiohead", "Blur", "The Cure", "Gorillaz", "The Kinks", "Rage Against The Machine", "R.E.M", "The Cure"]
</code>
Dein Programm soll die Liste korrigieren, sodass sie keine Duplikate mehr enthält. Am Ende gibt dein Programm Folgendes aus: 
  - die korrigierte Liste
  - eine Meldung, die sagt, wie viele Duplikate entfernt wurden.

=== Aufgabe L16 – Reihenfolge drehen ===
Schreibe ein Programm, das eine Liste "umdreht", sodass das erste Element der Liste an die letzte Stelle kommt, das zweite an die zweitletzte usw. Teste mit folgender Liste:
<code python>
noten = ["do", "re", "mi", "fa", "so", "la", "ti"]
</code>
Ziel: 
<code>
['ti', 'la', 'so', 'fa', 'mi', 're', 'do']
</code>

=== Aufgabe L17 – Höchstwert ===
  - Dein Programm soll zuerst eine Liste von 12 zufälligen Zahlen im Bereich zwischen 1 und 50 erstellen (wie in Aufgabe L9).
  - Dann soll dein Programm den höchsten Wert in der Liste finden und ausgeben. (Es ist nicht erlaubt, die bestehende max-Funktion o. ä. zu verwenden).


=== Aufgabe L18 – Lotto ===
{{:gf_informatik:programmieren_iii_gra:pasted:20250317-210248.png?200|}}

Schreibe ein Programm, das wie folgt funktioniert: 
  - Die Benutzer:in soll nacheinander drei Tipps (Zahlen zwischen 1 und 20) eingeben. Diese speicherst du in einer Liste namens //tipps// (mit drei Elementen). 
  - Sobald alle drei Zahlen eingegeben sind, wird die Liste //tipps// ausgegeben. 
  - Danach wird eine Liste namens //zufallszahlen// aus sechs zufälligen Zahlen im Bereich 1...20 erstellt uns ausgegeben.
  - Dann wird gezählt, wie viele der Tipps (in //tipps//) in der Liste //zufallszahlen// vorkommen. 
  - Abhängig vom Resultat wird eine der folgenden Meldungen ausgegeben:
    * "Kein Treffer. Danke, Merci, Grazie."
    * "1 Treffer, Du gewinnst einen Kaugummi." 
    * "2 Treffer, Du gewinnst eine Traumreise." 
    * "JACKPOT JACKPOT JACKPOT!"


=== Aufgabe L19 – Regenbogen (optional) ===
Dein Programm soll mit folgender Liste und mit einer while-Schleife einen Regenbogen wie im Bild unten zeichnen:

<code python>
colors = ["red", "orange", "yellow", "green", "blue", "purple", "white"]
</code>

{{:gf_informatik:programmieren_iii_gra:pasted:20250316-134049.png?250|}}

Tipp: Verwende die Funktoinen ''setFillColor'', ''startPath'' und ''fillPath''.

=== Aufgabe L20 – Pixel-Matrix (optional) ===
Schreibe ein Programm, dass mittels folgender zweidimensionalen Liste untenstehendes Bild malt. Verwende für die Punkte die Farben "red" und "gainsboro".

<code python>
pixels = [[0, 0, 1, 1, 1, 1, 0, 0], 
          [0, 1, 0, 0, 0, 0, 1, 0], 
          [1, 0, 1, 0, 0, 1, 0, 1], 
          [1, 0, 0, 0, 0, 0, 0, 1], 
          [1, 0, 1, 0, 0, 1, 0, 1], 
          [1, 0, 0, 1, 1, 0, 0, 1], 
          [0, 1, 0, 0, 0, 0, 1, 0], 
          [0, 0, 1, 1, 1, 1, 0, 0]]
</code>

{{:gf_informatik:programmieren_iii_gra:pasted:20250318-110813.png?250|}}

== Zusatzaufgaben ==
  * Erstelle zusätzliche Bilder, [[https://xantorohara.github.io/led-matrix-editor/#|hier]] kannst du bestehende laden, neue erstellen und jeweils die Binär-Codes dazu abrufen. 
  * Erstelle Animationen aus mehreren Bildern.


=== Aufgabe L21 – Popcorn (optional) ===
{{:gf_informatik:programmieren_iii_gra:pasted:20250331-211019.png?300}}

Mit der Turtle-Funktion ''playTone'' kannst du einen Ton von bestimmter Frequenz für eine bestimmte Dauer spielen ein Instrument wählen. Beispiel:
<code python>
playTone(440, 300, instrument = "guitar")
</code>
Hier wird der Ton A4 (440 Hz) für 300 Millisekunden mit dem Klang einer Gitarre gespielt. Weitere Infos zur Funktion [[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/turtledoc.html#|hier]]. 

Mit Listen können wir Melodien erstellen: Wir können alle Töne in einer Melodie in einer Liste speichern. 
<code python>
# Frequenzen der Noten von A3 bis G5
A3  = 220
B3  = 247
C4  = 262
D4  = 294
E4  = 330
F4  = 349
G4  = 392
A4  = 440
B4  = 494
C5  = 523
D5  = 587
E5  = 659
F5  = 698
F5s = 740
G5  = 784
P = 0

popcorn = [
    A4, G4, A4, E4, C4, E4, A3, P,
    A4, G4, A4, E4, C4, E4, A3, P,
    A4, B4, C5, B4, C5, A4, B4, A4, B4, G4, A4, G4, A4, F4, A4, P, 
    A4, G4, A4, E4, C4, E4, A3, P,
    A4, G4, A4, E4, C4, E4, A3, P,
    A4, B4, C5, B4, C5, A4, B4, A4, B4, G4, A4, G4, A4, B4, C5, P,
    E5, D5, E5, C5, G4, C5, E4, P, 
    E5, D5, E5, C5, G4, C5, E4, P, 
    E5, F5s, G5, F5s, G5, E5, F5s, E5, F5s, D5, E5, D5, E5, C5, E5, P 
]
</code>
Obiger Code definiert erst die Frequenzen für die Töne A3 bis G5 (und P für Pause). Dann werden die Töne des Lieds [[https://youtu.be/Yx0KBLFG8qc?si=npQqnemJkc1lV2Fj|Pop Corn von Gershon Kingsley]] in einer Liste gespeichert. **Beachte:** P steht für Pause. Hier soll für die Dauer eines Tones kein Ton gespielt werden.

**Aufgabe:** Schreibe ein Programm, das die Liste durchgeht und Ton für Ton der Melodie spielt. Bei einem Pausenton soll für die Dauer eines Tons nichts gespielt, also gewartet werden (mit der Funktion ''delay()'').

== Zusatzaufgabe 1 – Bruder Jakob ==
Die Popcorn-Melodie ist einfach mit Blick auf die Rhythmus: Alle Töne sind gleich lang. Bei den meisten Liedern ist das nicht so. Zu m Beispiel das Lied //Bruder Jakob//:

{{:gf_informatik:programmieren_iii_gra:pasted:20250401-070509.png?400}}

Schreibe ein Programm, das die Melodie von Bruder Jakob korrekt spielt. 
  * Erstelle erst die Liste der Töne (ausgehnd von den Noten). [[https://mixbutton.com/music-tools/frequency-and-pitch/music-note-to-frequency-chart|Hier die Zuordnung zu den Frequenzen]]. 
  * Erstelle dann eine zweite Liste für die Tondauern: Für jeden Ton der ersten Liste speichert diese Liste die entsprechende Dauer (Viertelton, Halbton, ganzer Ton).
  * In der while-Schleife kannst du dann beide Listen gleichzeitig durchgehen. 
===== Lösungen =====

**Achtung:** Meist gibt es mehrere Lösungen. Nur weil deine Lösung anders ist als diejenige in den Musterlösungen unten, bedeutet dies nicht, dass deine nicht richtig/gut ist. Sende oder zeige im Zweifelsfall deine Lösung der Lehrperson.

<nodisp 1>

++++Lösungen L1-L5|

=== Aufgabe L1 ===
<code python>
planeten = ["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]
print(planeten[1])
</code>

=== Aufgabe L2 ===
<code python>
planeten = ["Merkur", "Venus", "Erde", "Snickers", "Jupiter", "Saturn", "Uranus", "Neptun"]
print(planeten)
planeten[3] = "Mars"
print(planeten)
</code>
=== Aufgabe L3 ===
<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>

=== Aufgabe L4 – Version 1 ===
<code python>
fluesse = ["Rhein", "Aare", "Rhone", "Reuss", "Limmat", "Saane", "Thur"]
i = 0
while i < len(fluesse):
    print(fluesse[i])
    i = i + 1
</code>

=== Aufgabe L4 – Version 2 ===
<code python>
fluesse = ["Rhein", "Aare", "Rhone", "Reuss", "Limmat", "Saane", "Thur"]
i = 0
while i < len(fluesse):
    print(f"{i+1}. {fluesse[i]}")
    i = i + 1
</code>

=== Aufgabe L5 ===
<code python>
buchstaben = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
i = 0
while i < len(buchstaben):
    print(buchstaben[i])
    i = i + 2
</code>
++++

++++Lösungen L6-L10|

=== Aufgabe L6 ===
<code python>
from gturtle import *
michelangelo = Turtle()
colors = ["red", "orange", "yellow", "green", "blue", "purple"]
i = 0
michelangelo.right(90)
while i < len(colors):
    michelangelo.setPenColor(colors[i])
    michelangelo.dot(20)
    michelangelo.forward(20)
    i = i + 1
</code>

=== Aufgabe L7 ===
<code python>
numbers = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]
i = 0
summe = 0
while i < len(numbers):
    summe = summe + numbers[i]
    i = i + 1
print(summe)
</code>

=== Aufgabe L8 ===
<code python>
limit = input("Bis zu welcher Zahl?")
numbers = []
count = 1
while count <= limit:
    numbers.append(count)
    count = count + 1
print(numbers)
</code>

=== Aufgabe L9 ===
<code python>
import random
numbers = []
count = 0
while count < 12:
    numbers.append(random.randint(1, 99))
    count = count + 1
print(numbers)
</code>

=== Aufgabe L10 – Version 1 ===
<code python>
# Liste mit zufälligen Zahlen generieren
import random
numbers = []
count = 0
while count < 12:
    numbers.append(random.randint(1, 99))
    count = count + 1
print(numbers)

# Liste auf "Bösi" prüfen (Version 1)
i = 0
while i < len(numbers):
    if numbers[i] % 7 == 0:
        numbers [i] = "Bösi"
    i = i + 1
print(numbers)
</code>

=== Aufgabe L10 – Version 2 ===
<code python>
# Liste mit zufälligen Zahlen generieren
import random
numbers = []
count = 0
while count < 12:
    numbers.append(random.randint(1, 99))
    count = count + 1
print(numbers)

# Liste auf "Bösi" prüfen und zählen (Version 2)
i = 0
count_evil = 0
while i < len(numbers):
    if numbers[i] % 7 == 0:
        numbers [i] = "Bösi"
        count_evil = count_evil + 1
    i = i + 1
print(numbers)
print(f"Deine Liste enthält {count_evil} Bösi")
</code>

=== Aufgabe L10 – Version 3 und 4 ===
<code python>
# Liste mit zufälligen Zahlen generieren
import random
numbers = []
count = 0
while count < 12:
    numbers.append(random.randint(1, 99))
    count = count + 1
print(numbers)
 
# Liste auf "Bösi" prüfen und Liste erstellen (Version 3)
i = 0
evil_numbers = []
while i < len(numbers):
    if numbers[i] % 7 == 0:
        evil_numbers.append(numbers[i])
        numbers [i] = "Bösi"
    i = i + 1
print(numbers)
print(evil_numbers)
 
# Anzahl "Bösi" auswerten (Version 4)
if len(evil_numbers) > 5:
    print("Ohjeminee – Du bist geliefert.")
elif len(evil_numbers) > 3:
    print("Sehr viele Bösi in der Liste… ich würde mir Sorgen machen!")
elif len(evil_numbers) > 0:
    print("Ein paar Bösi in der Liste. Das kann passieren.")
else:
    print("Keine Bösi in der Liste! Du Glückspilz!")
</code>
++++

++++Lösungen L11-L15|
=== Aufgabe L11 ===
<code python>
numbers = [8, 79, 86, 14, 92, 23, 38, 62, 71, 53, 2, 93]

i = 0
summe = 0
while i < len(numbers):
    summe = summe + numbers[i]
    i = i + 1
mittelwert = summe/len(numbers)
print(mittelwert)
</code>

=== Aufgabe L12 Version 1 ===
<code python>
durcheinander = ["Linse", "lnse", "Linse", "lünse", "Lnise", "Linse", "insel", "lönse", "lNSe", "LiNsi", "Linse", "lYnse", "Liins", "Linis", "Linse", "Linse", "lisne", "Linse", "Lynsu", "Line", "Linse"]
i = 0
toepfchen = []
kroepchen = []
while i < len(durcheinander):
    if durcheinander[i] == "Linse":
        toepfchen.append(durcheinander[i])
    else:
        kroepchen.append(durcheinander[i])
    durcheinander.pop(i)
print(durcheinander)
print(toepfchen)
print(kroepchen)
</code>

=== Aufgabe L12 Version 2 ===
<code python>
durcheinander = ["Linse", "lnse", "Linse", "lünse", "Lnise", "Linse", "insel", "lönse", "lNSe", "LiNsi", "Linse", "lYnse", "Liins", "Linis", "Linse", "Linse", "lisne", "Linse", "Lynsu", "Line", "Linse"]
anz_alle = len(durcheinander)
i = 0
toepfchen = []
kroepfchen = []
while i < len(durcheinander):
    if durcheinander[i] == "Linse":
        toepfchen.append(durcheinander[i])
    else:
        kroepfchen.append(durcheinander[i])
    durcheinander.pop(i)
print(durcheinander)
print(toepfchen)
print(kroepfchen)

print(f"Es wurden {anz_alle} Linsen sortiert: {len(toepfchen)} gute und {len(kroepfchen)} schlechte.")
</code>

=== Aufgabe L13 ===
<code python>
# Liste mit zufälligen Zahlen generieren
import random
even_numbers = []
count = 0
while count < 15:
    even_numbers.append(random.randint(1, 20))
    count = count + 1
print(even_numbers)

# Liste durchgehen, ungerade Zahlen entfernen und anderer Liste hinzufügen.
odd_numbers = []
i = 0
while i < len(even_numbers):
    if even_numbers[i] % 2 != 0:
        odd_numbers.append(even_numbers[i])
        even_numbers.pop(i)
    else:
        i = i + 1
print(even_numbers)
print(odd_numbers)
</code>


=== Aufgabe L14 ===
<code python>
numbers = [39, 40, 32, 21, 32, 27, 14, 45, 28, 20, 15, 7]
tipp = input("Zahl zwischen 1 und 50")

if tipp in numbers:
    print(f"Treffer! Die Zahl {tipp} ist in der Liste vorhanden!")
else:
    print(f"Sorry, die Zahl {tipp} ist in der Liste nicht vorhanden.")
</code>

=== Aufgabe L15 ===
<code python>
bands = ["The Beatles", "The Kinks", "Blur", "Led Zeppelin", "Radiohead", "Blur", "The Cure", "Gorillaz", "The Kinks", "Rage Against The Machine", "R.E.M", "The Cure"]

i = 0
count_dups = 0
bands_new = []
while i < len(bands):
    if bands[i] in bands_new:
        count_dups = count_dups + 1
    else:
        bands_new.append(bands[i])
    i = i + 1
    
bands = bands_new

print(bands)
print(f"Es wurden {count_dups} Duplikate entfernt.")
</code>

++++

</nodisp>