for-loops (for-Schleifen)
Schleifen werden verwendet, wenn ein Programmteil mehrfach ausgeführt werden soll. In diesem Abschnitt lernst du for-Schleifen kennen. Später werden while-Schleifen erklärt.
Schleifen sind wichtige Kontrollstrukturen; der Fachbegriff in diesem Kontext lautet Iteration: Man führt etwas iterativ (= wiederholt) durch.
Schau dir das folgende Video zu for-loops an.
Wesentliche Inhalte des Videos
Ein einfaches Beispiel einer for-Schleife in Python:
for i in range(3, 15): print(i) print("Nun ist die Schleife beendet.")
Beachte:
- Die sogenannte Laufvariable
i
im obigen Beispiel nimmt nacheinander alle ganzzahligen Werte von 3 bis $14=15-1$ an; der Wert 15 wird nicht angenommen. - Statt
i
kann man einen beliebigen anderen Variablennamen verwenden, etwalaufvariable
. - Der Doppelpunkt
:
am Ende der Zeile mit demfor
darf nicht vergessen werden. - Der mehrfach auszuführende Code ist vier Zeichen eingerückt.
- Wenn man die erste Zeile als kompletten Satz lesen will:
- Auf Englisch: “For every
i
in the number range between 3 (included) and 15 (excluded) do the following:” - Auf Deutsch: “Für jedes Element
i
im Zahlenbereich zwischen 3 (einschliesslich) und 15 (ausgenommen) mache das Folgende:”
Der range
-Befehl benötigt standardmäßig zwei ganze Zahlen als Parameter, hat also die Form range(start, end)
. Er erzeugt eine (Art) Liste aller ganzen Zahlen, die bei start
startet und bei end - 1
endet. Im Video haben wir dies in der Python-Shell mit Befehlen wie list(range(3, 10))
getestet.
Der erste Parameter kann optional weggelassen werden und wird dann als 0
interpretiert: range(10)
hat dieselbe Bedeutung wie range(0, 10)
.
Aufgaben zu for-loops
Aufgabe 1: Zahlen und ihre Quadrate
Schreibe ein Programm, das für alle Zahlen zwischen $1$ und $20$ sowohl die Zahl als auch deren Quadrat ausgibt:
Das Quadrat von 1 ist 1. Das Quadrat von 2 ist 4. ... Das Quadrat von 20 ist 400.
Aufgabe 2: Summe der Quadratzahlen
Schreibe ein Python-Programm, das die Summe aller Quadrate der Zahlen von 1 bis n
ausgibt, wobei der Benutzer die Zahl n
eingibt.
Beispiel: Der Dialog mit dem Programm bei Eingabe 8 soll wie folgt aussehen:
Bis zu welcher Zahl soll ich die Quadrate aufsummieren? 8 Die Summe der Quadrate aller Zahlen von 1 bis 8 ist 204.
Bonus-Teil: Ändere dein Programm so, dass als Ausgabe eine Formel ausgegeben wird, etwa $1+2+3+4+5+6+7+8=204$ bei Eingabe 8. Bei dieser Eingabe soll der Dialog also wie folgt aussehen:
Bis zu welcher Zahl soll ich die Quadrate aufsummieren? 8 1+2+3+4+5+6+7+8=204
Aufgabe 3: Muster ausgeben
Schreibe ein Programm, das eine Zahl als Eingabe entgegennimmt (oder diese am Anfang des Programms in einer Variablen speichert) und dann ein Dreieck der folgenden Form produziert, hier im Fall der Eingabe 6:
* ** *** **** ***** ******
Aufgabe 4: Slalomtext
Schreibe ein Programm, das vom Benutzer einen kurzen Text erfragt und diesen dann 100 Mal wie unten illustriert in Slalom-Form ausgibt (maximale Einrückung im Beispiel unten sind 5 Leerschläge, etwas mehr ist aber auch erlaubt).
Damit es nicht zu leicht ist:
Du darfst nur eine for-Schleife verwenden.
Beliebig viele if-statements sind aber erlaubt!
Bemerkung: Wenn du die Ausgabe zeitlich verzögern willst, importiere am Anfang deines Programms mit import time
die dazu nötige Bibliothek und verwende im Programm den Befehl time.sleep(0.05)
für eine Pause von einer zwanzigstel Sekunde.
Gib einen kurzen Satz oder Text ein: Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! Schleifen sind cool! ...
Aufgabe 5: Ausbreitung von Corona
Schreibe ein Programm, das die Anzahl der Neuansteckungen mit Corona simuliert.
Am Anfang des Programms sollen aktuelle Anzahl und wöchentliche Zuwachsrate (in Prozent) und Simulationszeit (wie viele Wochen?) als Variablen definiert werden.
Hinweis: Um eine Kommazahl (alias float) zu einer ganzen Zahl (alias int) zu runden, verwende den Befeh round
. Zum Testen gib etwa round(3.49)
und round(3.5)
in der Python-Shell ein.
Die Ausgabe soll beispielsweise wie folgt aussehen:
Anzahl der Neuansteckungen heute: 300 Wöchentliche Zunahme: 17% Woche 0: 300 Woche 1: 351 Woche 2: 410 Woche 3: 480 Woche 4: 562 Woche 5: 657 Woche 6: 769 Woche 7: 900 Woche 8: 1053 Woche 9: 1232 Woche 10: 1442 Woche 11: 1687 Woche 12: 1974
Verschachtelte for-Schleifen
Innerhalb einer for-Schleife können weitere for-Schleifen stehen (und auch if-else statements etc). Lass das folgende Programm auf deinem Rechner laufen und verstehe es:
for i in range(3): print("Äussere Schleife beginnt, Laufvariable i = " + str(i) + ".") for j in range(3): print(" Innere Schleife beginnt, Laufvariable j = " + str(j) + ".") print(" (i,j) = (" + str(i) + ", " + str(j) + ")") print(" Innere Schleife abgearbeitet.") print("Äussere Schleife abgearbeitet.")
Manchmal ist es sinnvoll, einen Ausgabe-String schrittweise aufzubauen, wie im folgenden Python-Programm. Versuche, es zu verstehen.
Warum habe ich die “äussere” Laufvariable y
und nicht x
genannt?
for y in range(10): s = "" for x in range(10): s = s + "(" + str(x) + ", " + str(y) + "); " print(s)
Aufgabe: Kleines Einmaleins bzw. Multiplikationstabelle (mit unschön formatierter Ausgabe)
Schreibe ein Programm, das abhängig von einer Variablen n
eine Multiplikationstabelle der Zahlen von $1$ bis $n$ Zahlen ausgibt. Im Fall n == 10
soll die Ausgabe wie folgt aussehen (wir lernen in Bälde, wie man eine “tabellarisch schöne” Ausgabe erzeugt).
1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100
Bonus-Aufgabe: Liste von Primzahlen
Schreibe ein Programm, das eine Liste aller Primzahlen bis zu einer Zahl n
aus gibt.
f-strings (formatted strings = formatierte Zeichenketten) und end-Parameter beim print-Befehl
Schau dir das folgende Video an.
Aufgaben zu f-strings
Aufgabe 1: f-strings in der Python-Shell testen
Gehe in die Python-Shell und definiere Variablen s=“Hallo”
und x = 5
und b = 1/17
.
Wenn du nun etwa f“{s:15}”
eingibst, liefert Python als Ergebnis den String “Hallo”
linksbündig in einem Bereich von 15 Leerzeichen.
Was musst du eingeben, um als Ergebnis …
- den Wert von
s
rechtsbündig in einem Bereich von 15 Leerzeichen zu erhalten? - den Wert von
x
rechsbündig bzw. linksbündig in einem Bereich von 10 Leerzeichen zu erhalten? - den Wert von
b
rechsbündig bzw. linksbündig in einem Bereich von 25 Leerzeichen zu erhalten? - den Wert von
b
auf 7 Nachkommastellen genau rechsbündig bzw. linksbündig in einem Bereich von 25 Leerzeichen zu erhalten?
Bemerkung: Wenn du nicht mit Variablen arbeiten willst, kannst du statt f“{s:15}”
auch direkt f“{'Hallo':15}”
eingeben. Beachte dabei, dass hier der f-string mit doppelten Anführungszeichen notiert ist und der innere string 'Hallo'
mit einfachen Anführungszeichen. Nicht akzeptiert wird f“{“Hallo”:15}”
(da hier nicht klar ist, wo die Definition des f-strings endet).
Aufgabe 2: f-strings in for-Schleife
Zuvor hast du hoffentlich ein Programm geschrieben, das für alle Zahlen zwischen $1$ und $20$ sowohl die Zahl als auch deren Quadrat ausgibt. Ändere dieses Programm nun mit Verwendung von f-Strings so, dass jede Zahl rechtsbündig in einem Bereich von 3 Leerschlägen steht. Die Ausgabe soll also übersichtlicher als zuvor so aussehen:
Das Quadrat von 1 ist 1. Das Quadrat von 2 ist 4. ... Das Quadrat von 20 ist 400.
Aufgabe 3: Formatierte Multiplikationstabelle; verschachtelte for-Schleife und f-Strings
Vereinbarung: In den folgenden Tabellen hat jede Zahl einen “Platz von 5 Zeichen”.
(1) Ändere dein obiges Programm zur Multiplikationstabelle so, dass die Ausgabe im Fall n == 10
wie folgt aussieht:
1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100
(2) Bonus-Teil: Verbessere die Ausgabe weiter: Im Fall n==10
soll sie wie folgt aussehen:
* | 1 2 3 4 5 6 7 8 9 10 --------------------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 2 | 2 4 6 8 10 12 14 16 18 20 3 | 3 6 9 12 15 18 21 24 27 30 4 | 4 8 12 16 20 24 28 32 36 40 5 | 5 10 15 20 25 30 35 40 45 50 6 | 6 12 18 24 30 36 42 48 54 60 7 | 7 14 21 28 35 42 49 56 63 70 8 | 8 16 24 32 40 48 56 64 72 80 9 | 9 18 27 36 45 54 63 72 81 90 10 | 10 20 30 40 50 60 70 80 90 100
Bonusmaterial: range-Befehl mit Schrittweite und print-Befehl mit mehreren Argumenten und Zusatzparameter sep
range-Befehl mit Schrittweite
Teste in der Python-Shell die folgenden Befehle und versuche, das Ergebnis zu verstehen!
list(range(-5))
list(range(5, 5))
list(range(4, 5))
list(range(-5, 7))
list(range(4, 10, 2))
list(range(10, 4, 2))
list(range(10, 4, -1))
list(range(10, 4, -2))
list(range(10, 3, -2))
Stets kann man versuchen, sich im Internet schlau zu machen, wenn etwas unklar ist. Die Kunst ist hier, die richtigen (englischen) Suchbegriffe zu finden. Manchmal ist dies relativ verständlich:
Manchmal (aktuell vermutlich) eher nicht:
print mit mehreren Ausgabeargumenten und Parameter sep
Teste das folgende Python-Programm und finde heraus, was du dabei lernen sollst!
- print-mehrere-argumente-und-sep.py
print("Du bist", 999, "Jahre alt.") x = 3 y = 7 z = 13 print(x, y, z) print(x, y, z, sep = " | ") print("Du bist", 999, "Jahre alt.") print("Du bist", 999, "Jahre alt.", sep="") print("Du bist", 999, "Jahre alt.", sep="---") for i in range(1, 6): print(i, i*i, i*i*i, i*i*i*i, sep = " | ", end = " |\n") # ... wobei Letzteres (verschönert) einfacher mit einem einzigen f-string geht: for i in range(1, 6): print(f"{i:4} | {i * i:4} | {i * i * i:4} | {i * i * i * i:4} |")