Programmieren Teil 3 – Listen (mit der while-Schleife)

• Dieses Seite ist die Fortsetzung von Programmieren Teil 2 – Rechnen, Strings und While-Schleife.
• Weiter zu Programmieren Teil 4 – Funktionen (Unterprogramme).

Lernziele:

Du kennst bereits Variablen und kannst diese verwenden. In einer Variable kannst du einen Wert – eine Zahl oder einen Text – speichern:

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.

Warum nutzen wir Variablen?

count = 10             # Variable definieren
while count > 0:       # Variable abfragen
    print(count)       # Variable ausgeben
    count = count - 1  # Variable verändern
print("null!")

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)

from gturtle import *
donatello = Turtle()
 
donatello.rightArc(100, 220)
donatello.leftArc(100, 220)
donatello.rightArc(100, 220)
donatello.leftArc(100, 220)

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:

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

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

Beachte, dass das erste Element den Index 0 hat!

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

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']

Einer Liste kann man Elemente hinzufügen und entfernen

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

Die Länge einer Liste bestimmt man wie folgt:

len(alphabet) # Anzahl Elemente in Liste

Oft möchte man alle Elemente einer Liste durchgehen und etwas mit ihnen machen, z.B. sie ausgeben:

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

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.

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: IndexError: list index out of range. Mit der Funktion len() kannst du solche Fehler vermeiden:

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

In der Bedingung i < len(alphabet) ermitteln wir mit len(alphabet) die Länge der Liste. Für obige Liste alphabet mit fünf Elementen gibt len(alphabet) den Wert 5 zurück.

Kopiere folgende Liste in deinen Code und gib ein beliebiges Element aus der Liste aus (mit print).

planeten = ["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]

Betrachte folgende Liste: Ein Element ist falsch. Dein Code soll Folgendes tun:

1. Die falsche Liste ausgeben,
2. das betreffende Element korrigieren und
3. die korrigierte Liste ausgeben.

planeten = ["Merkur", "Venus", "Erde", "Snickers", "Jupiter", "Saturn", "Uranus", "Neptun"]

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.

Erstelle eine Liste mit den sieben längsten Flüssen in der Schweiz (siehe hier: sortiere erst nach Länge, lasse die Varianten mit „ob“ weg).

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

Erweitere dein Programm, sodass mit dem Flussnamen auch der Rang ausgegeben wird, also so:

1. Rhein
2. Aare
3. Reuss
...

Tipp: Erstelle einen f-String

Kopiere folgende Liste in deinen Code. Schreibe ein Programm, das jedes zweite Element der Liste ausgibt.

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']

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.

colors = ["red", "orange", "yellow", "green", "blue", "purple"]

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

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

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:

numbers = []

import random
zahl1 = random.randint(1, 9)
print(zahl1)

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

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:

Dein Programm, geht die Liste durch und ersetzt alle Vielfachen von 7 durch den Text „Bösi“. Am Ende wird die Liste ausgegeben.

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

Dein Programm erstellt eine zweite Liste mit allen „bösen“ Zahlen und gibt diese zusätzlich zur abgeänderten Liste aus. Zum Beispiel so:

[75, 65, 24, 'Bösi', 60, 65, 30, 69, 12, 43, 'Bösi', 8]
[63, 77]

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 …

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

[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]

Mittelwert = 51.75
Mittelwert = 15.2
Mittelwert = 9.4

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:

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.

durcheinander = ["Linse", "lnse", "Linse", "lünse", "Lnise", "Linse", "insel", "lönse", "lNSe", "LiNsi", "Linse", "lYnse", "Liins", "Linis", "Linse", "Linse", "lisne", "Linse", "Lynsu", "Line", "Linse"]

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

1. 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.
2. 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.

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

Schreibe ein Programm, das wie folgt funktinoiert:

1. Die Benutzer:in kann eine beliebige Zahl zwischen 1 und 50 eingeben.
2. 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:
   1. Sorry, die Zahl … ist in der Liste nicht vorhanden.
   2. Treffer! Die Zahl … ist in der Liste vorhanden!

numbers = [39, 40, 32, 21, 32, 27, 14, 45, 28, 20, 15, 7]

In untenstehender Liste sind einige Elemente mehrfach aufgeführt: Die Liste enthält sogenannte Duplikate.

bands = ["The Beatles", "The Kinks", "Blur", "Led Zeppelin", "Radiohead", "Blur", "The Cure", "Gorillaz", "The Kinks", "Rage Against The Machine", "R.E.M", "The Cure"]

Dein Programm soll die Liste korrigieren, sodass sie keine Duplikate mehr enthält. Am Ende gibt dein Programm Folgendes aus:

1. die korrigierte Liste
2. eine Meldung, die sagt, wie viele Duplikate entfernt wurden.

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:

noten = ["do", "re", "mi", "fa", "so", "la", "ti"]

Ziel:

['ti', 'la', 'so', 'fa', 'mi', 're', 'do']

1. Dein Programm soll zuerst eine Liste von 12 zufälligen Zahlen im Bereich zwischen 1 und 50 erstellen (wie in Aufgabe L9).
2. 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).

Schreibe ein Programm, das wie folgt funktioniert:

1. Die Benutzer:in soll nacheinander drei Tipps (Zahlen zwischen 1 und 20) eingeben. Diese speicherst du in einer Liste namens tipps (mit drei Elementen).
2. Sobald alle drei Zahlen eingegeben sind, wird die Liste tipps ausgegeben.
3. Danach wird eine Liste namens zufallszahlen aus sechs zufälligen Zahlen im Bereich 1…20 erstellt uns ausgegeben.
4. Dann wird gezählt, wie viele der Tipps (in tipps) in der Liste zufallszahlen vorkommen.
5. 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!“

Dein Programm soll mit folgender Liste und mit einer while-Schleife einen Regenbogen wie im Bild unten zeichnen:

colors = ["red", "orange", "yellow", "green", "blue", "purple", "white"]

Tipp: Verwende die Funktoinen setFillColor, startPath und fillPath.

Schreibe ein Programm, dass mittels folgender zweidimensionalen Liste untenstehendes Bild malt. Verwende für die Punkte die Farben „red“ und „gainsboro“.

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]]

• Erstelle zusätzliche Bilder, hier kannst du bestehende laden, neue erstellen und jeweils die Binär-Codes dazu abrufen.
• Erstelle Animationen aus mehreren Bildern.

Mit der Turtle-Funktion playTone kannst du einen Ton von bestimmter Frequenz für eine bestimmte Dauer spielen ein Instrument wählen. Beispiel:

playTone(440, 300, instrument = "guitar")

Hier wird der Ton A4 (440 Hz) für 300 Millisekunden mit dem Klang einer Gitarre gespielt. Weitere Infos zur Funktion hier.

Mit Listen können wir Melodien erstellen: Wir können alle Töne in einer Melodie in einer Liste speichern.

# 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 
]

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 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()).

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:

Schreibe ein Programm, das die Melodie von Bruder Jakob korrekt spielt.

• Erstelle erst die Liste der Töne (ausgehnd von den Noten). 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.

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.

planeten = ["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]
print(planeten[1])

planeten = ["Merkur", "Venus", "Erde", "Snickers", "Jupiter", "Saturn", "Uranus", "Neptun"]
print(planeten)
planeten[3] = "Mars"
print(planeten)

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)

fluesse = ["Rhein", "Aare", "Rhone", "Reuss", "Limmat", "Saane", "Thur"]
i = 0
while i < len(fluesse):
    print(fluesse[i])
    i = i + 1

fluesse = ["Rhein", "Aare", "Rhone", "Reuss", "Limmat", "Saane", "Thur"]
i = 0
while i < len(fluesse):
    print(f"{i+1}. {fluesse[i]}")
    i = i + 1

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

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

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)

limit = input("Bis zu welcher Zahl?")
numbers = []
count = 1
while count <= limit:
    numbers.append(count)
    count = count + 1
print(numbers)

import random
numbers = []
count = 0
while count < 12:
    numbers.append(random.randint(1, 99))
    count = count + 1
print(numbers)

# 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)

# 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")

# 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!")

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)

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)

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

# 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)

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

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

noten = ["do", "re", "mi", "fa", "so", "la", "ti"]
noten_neu = []
 
i = len(noten)-1
while i >= 0:
    noten_neu.append(noten[i])
    i = i - 1
 
noten = noten_neu
print(noten)

import random
numbers = []
i = 0
while i < 12:
    numbers.append(random.randint(1,50))
    i = i + 1
print(numbers)
 
maxi = numbers[0]
i = 1
while i < 12:
    if numbers[i] > maxi:
        maxi = numbers[i]
    i = i + 1
print(maxi)

import random
tipps = [0,0,0]
tipps[0] = input("Erster Tipp (1...20):")
tipps[1] = input("Zweiter Tipp (1...20):")
tipps[2] = input("Dritter Tipp (1...20):")
print(tipps)
 
lose = []
i = 0
while i < 6:
    lose.append(random.randint(1,20))
    i = i + 1
print(lose)
 
i = 0
treffer = 0
while i < len(lose):
    if lose[i] in tipps:
        treffer = treffer + 1
    i = i + 1
 
if treffer > 2:
    print("JACKPOT JACKPOT JACKPOT!")
elif treffer > 1:
    print("2 Treffer, Du gewinnst eine Traumreise.")
elif treffer > 0:
    print("1 Treffer, Du gewinnst einen Kaugummi.")
else:
    print("Kein Treffer. Danke, Merci, Grazie.")

from gturtle import *
michelangelo = Turtle()
colors = ["red", "orange", "yellow", "green", "blue", "purple", "white"]
i = 0
 
radius = 100
 
while i < len(colors):
    michelangelo.setFillColor(colors[i])
    michelangelo.startPath()
    michelangelo.rightArc(radius, 180)
    michelangelo.right(90)
    michelangelo.forward(2*radius-10)
    michelangelo.right(90)
    michelangelo.fillPath()
    radius = radius - 10
    i = i + 1

from gturtle import * 
morla = Turtle()
 
morla.right(90)
morla.penUp()
#morla.hideTurtle()
 
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]]
 
row = 0
xpos = 0
ypos = 0
 
while row < 8:
    morla.setPos(xpos, ypos)
    column = 0
    while column < 8:
        if pixels[row][column]:
            morla.setPenColor("red")
        else:
            morla.setPenColor("gainsboro")
        morla.dot(20)
        morla.forward(30)
        column = column + 1
    ypos = ypos - 30
    row = row + 1

from gturtle import *
 
# 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 
]
 
dauer = 200
i = 0
 
while i < len(popcorn):
    if popcorn[i] == 0:
        delay(dauer)
    else:
        playTone(popcorn[i], dauer, instrument = "guitar")
    i = i + 1