Schleifen¶
Allgemeiner Aufbau einer Schleife¶
Schleifen wiederholen einen Codeblock. Python besitzt dafür zwei zentrale Anweisungen:
whilewiederholt einen Block, solange eine Bedingung wahr ist.foriteriert über die Elemente eines Iterable, zum Beispiel über eine Liste, einen String, eine Datei oder einrange-Objekt.
Bei einer while-Schleife wird die Bedingung vor jedem Durchlauf geprüft. Solange ihr Wahrheitswert True ist, wird der Schleifenkörper ausgeführt. Danach springt die Programmausführung zur erneuten Prüfung der Bedingung zurück.
In anderen Programmiersprachen unterscheidet man häufig zwischen zähler-, bedingungs- und sammlungskontrollierten Schleifen. Python besitzt keine C-artige Syntax wie for (i=0; i <= n; i++). Zählerschleifen lassen sich aber sehr natürlich mit for und range() ausdrücken:
for i in range(0, n + 1):
print(i)
Die Python-for-Schleife ist grundsätzlich eine Iterationsschleife: Sie entnimmt nacheinander Werte aus einem Iterable. Dadurch eignet sie sich sowohl für Zählbereiche als auch für Listen und andere Datenstrukturen.
Einfache Beispiele von Schleifen¶
Das folgende Skript, das wir in der interaktiven Shell direkt eintippen können, gibt die Zahlen von 1 bis 10 aus:
i = 1
while i <= 10:
print(i)
i += 1
Mit dem nächsten kleinen Python-Skript berechnen wir die Summe der Zahlen von 1 bis 100. In ähnlicher Form würde man es auch in C, C++ oder Java machen. Allerdings geht es in Python deutlich einfacher, wie wir im folgenden Kapitel sehen werden.
n = 100
sum_of_numbers = 0
i = 1
while i <= n:
sum_of_numbers += i
i += 1
result = "Summe von 1 bis " + str(n) + ": " + str(sum_of_numbers)
print(result)
Standardeingabe lesen¶
Bevor wir mit der while-Schleife weitermachen, betrachten wir kurz die Standard-Datenströme. Ein Python-Prozess besitzt normalerweise:
sys.stdin– Standardeingabe,sys.stdout– Standardausgabe,sys.stderr– Standardfehlerausgabe.
Im Terminal ist stdin häufig mit der Tastatureingabe verbunden; stdout und stderr erscheinen normalerweise im Terminal. Die Streams können jedoch auch umgeleitet werden.
Das folgende Beispiel liest mit einer while-Schleife Zeichen für Zeichen aus sys.stdin, bis ein Zeilenumbruch erreicht wird:
import sys
text = ""
while True:
c = sys.stdin.read(1)
if c == "": # EOF
break
text += c
if c == "\n":
break
print(f"Eingabe: {text}")
Eleganter kann man eine beliebige Eingabezeile von der Standardeingabe natürlich mit der Funktion input(prompt) einlesen.
name = input("Wie heißen Sie?\n")
print(name)
Der else-Teil einer Schleife¶
Sowohl while- als auch for-Schleifen können in Python einen optionalen else-Zweig besitzen. Der Name ist zunächst ungewohnt: Der else-Block wird ausgeführt, wenn die Schleife ohne break endet. Bei while geschieht dies normalerweise, wenn die Schleifenbedingung falsch wird; bei for, wenn das Iterable vollständig durchlaufen wurde.
Wird die Schleife durch break verlassen, wird ihr else-Block übersprungen. Genau dadurch wird diese Konstruktion beispielsweise bei Suchschleifen nützlich.
while Bedingung:
Anweisungen
else:
# nur wenn kein break ausgeführt wurde
Anweisungen
Vorzeitiger Abbruch einer while-Schleife¶
Normalerweise wird eine while-Schleife nur beendet, wenn die Bedingung im Schleifenkopf nicht mehr erfüllt ist. Mit break kann man aber eine Schleife vorzeitig komplett verlassen. Mit 'continue' beendet man lediglich einen Durchlauf, d.h. man kehrt zum Schleifenkopf, also zur Überprüfung der Bedingung, zurück. Im folgenden Beispiel, einem einfachen Zahlenratespiel, kann man erkennen, dass in Kombination mit einem break der else-Zweig durchaus sinnvoll sein kann. Nur wenn die while-Schleife regulär beendet wird, d.h. der Spieler die Zahl erraten hat, gibt es einen Glückwunsch. Gibt der Spieler auf, d.h. break, dann wird der else-Zweig der while-Schleife nicht ausgeführt.
import random
n = 20
to_be_guessed = random.randint(1,n)
guess = 0
while guess != to_be_guessed:
guess = int(input("Neuer Versuch: "))
if guess > 0:
if guess > to_be_guessed:
print("Zu gross")
elif guess < to_be_guessed:
print("Zu klein")
else:
print("Schade, dass du aufgibst!")
break
else:
print("Gratuliere, das war's")
Das vorige Programm prüft nicht, ob die Zahl einen Sinn ergibt, d.h. ob die Zahl zwischen einer Untergrenze und einer Obergrenze liegt. Wir können unser Programm verbessern. Die Grenzen müssen entsprechend der Benutzereingabe angepasst werden:
import random
upper_bound = 20
lower_bound = 1
to_be_guessed = random.randint(lower_bound, upper_bound)
guess = 0
while guess != to_be_guessed:
guess = int(input("Dein Versuch: "))
if guess == 0: # Aufgegeben
print("Sorry that you're giving up!")
break # breche Schleife ab und gehe nicht zu "else"
if guess < lower_bound or guess > upper_bound:
print("Rateversuch außerhalb der Schranken!")
elif guess > to_be_guessed:
upper_bound = guess - 1
print("Zahl ist zu groß!")
elif guess < to_be_guessed:
lower_bound = guess + 1
print("Zahl ist zu klein!")
else:
print("Gratulation. Das war's!")
dog_age = int(input("Alter des Hundes: "))
print()
if dog_age <= 0:
human_age = -1
elif dog_age == 1:
human_age = 14
else:
# this means: dog_age >= 2:
human_age = 22 + (dog_age - 2) * 5
if human_age > 0:
print("Entspricht " + str(human_age) + " Menschenjahren!")
else:
print("Negative Werte oder Null ergeben keinen Sinn!")
Schreiben Sie eine Version mit einer while-Schleife, damit die Leute wiederholt Hundealter umwandeln können. 0 oder ein negativer Wert bedeutet, dass sie aufhören wollen.
Übung 2: Fakultäts-Rechner¶
Schreiben Sie ein Python-Programm, das die Fakultät einer vom Benutzer eingegebenen Zahl mit Hilfe einer while-Schleife errechnet. Die Fakultät einer nichtnegativen ganzen Zahl n, in der Mathematik als n! bezeichnet, ist das Produkt aller positiven ganzen Zahlen von 1 bis n. Zum Beispiel ist 5! (gelesen als "5 Fakultät") ist 5 * 4 * 3 * 2 * 1, was 120 entspricht.
Übung 3: Passwort-Prüfer¶
Schreiben Sie ein Python-Programm, das einen einfachen Passwort-Prüfer simuliert. Das Programm soll den Benutzer auffordern, ein Passwort einzugeben, und ihn so lange auffordern, bis er das richtige Passwort eingibt. Sobald das richtige Passwort eingegeben wurde, soll das Programm eine Erfolgsmeldung ausgeben.
Übung 4: Passwort-Prüfer – Fortsetzung¶
Erweitern wir das vorangegangene Beispiel für die Kennwortüberprüfung, indem wir eine maximale Anzahl von Versuchen hinzufügen. Wenn der Benutzer die maximale Anzahl an Versuchen überschreitet, soll das Programm ihn aussperren.
Übung 5: Primzahl-Prüfer¶
Schreiben Sie ein Python-Programm, das prüft, ob eine gegebene positive ganze Zahl eine Primzahl ist. Das Programm soll den Benutzer auffordern, eine Zahl einzugeben und dann in einer while-Schleife prüfen, ob die Zahl eine Primzahl ist.
Übung 6: Fibonacci-Folge¶
Schreiben Sie ein Python-Programm, das die Fibonacci-Folge bis zu einer bestimmten Anzahl von Termen erzeugt. Die Fibonacci-Folge ist eine Reihe von Zahlen, bei der jede Zahl die Summe der beiden vorhergehenden ist. Die ersten beiden Zahlen in der Folge sind normalerweise 0 und 1.
Übung 7: Collatz Sequenz¶
Bei dem Problem geht es um Zahlenfolgen, die nach einem einfachen Bildungsgesetz konstruiert werden:
- Beginne mit irgendeiner natürlichen Zahl n > 0.
- Ist n gerade, so nimm als nächstes n / 2.
- Ist n ungerade, so nimm als nächstes 3n + 1.
- Wiederhole die Vorgehensweise mit der erhaltenen Zahl.
Zum Beispiel ergibt sich mit der Startzahl n = 15 die Folge
46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1Die Folge tritt somit in einen Zyklus ein, in dem die Zahlen 4, 2, 1 ständig wiederholt werden.
Die Collatz-Vermutung lautet nun:
Die Zahlenfolge mündet immer in den Zyklus 4, 2, 1, egal, mit welcher positiven natürlichen Zahl nan beginnt.Diese Vermutung konnte man bislang weder beweisen noch widerlegen.
Mathematische Formulierung:
Die Collatz-Vermutung besagt, dass für eine beliebige positive ganze Zahl $n$ die Folge ${a_k}$ schließlich die Zahl $1$ für eine gewisse Anzahl $k$ erreicht, wenn $a_0$ auf $n$ gesetzt wird.}
$$a_{k+1} = \begin{cases} \frac{a_k}{2} & \text{if $a_k$ is even} \\ 3a_k + 1 & \text{if $a_k$ is odd} \end{cases}$$
- Schreibe ein Programm, das die Folge einer Zahl $n$ ausgibt.
- Wie lang ist die Folge für die Zahl 271114753?
- Schreibe ein Programm, das die Längen der Collatz-Folgen für die Zahlen von 1 bis 100 ausgibt.
dog_age = 1
while dog_age > 0:
dog_age = int(input("Alter des Hundes: (0 oder negative für Abbruch"))
print()
if dog_age <= 0:
human_age = -1
elif dog_age == 1:
human_age = 14
elif dog_age >= 2:
human_age = 22 + (dog_age - 2) * 5
print("Entspricht " + str(human_age) + " Menschenjahren!")
print("Programm ist zu Ende!")
Löung zu Übung 2¶
n = int(input("Ganze Zahl deren Fakultät berechnet werden soll: "))
factorial = 1
counter = 1
while counter <= n:
factorial *= counter
counter += 1
print(f"{n}! = {factorial}")
Löung zu Übung 3¶
correct_password = "password123"
user_input = input("Eingabe des Passwortes: ")
while user_input != correct_password:
print("Falsches Passwort. Probiere es nochmals.")
user_input = input("Eingabe des Passwortes: ")
print("Willkommen. Das war das korrekte Passwort!")
Alternativ können wir die Programmieraufgabe auch wie im Folgenden lösen. Dabei haben wir die Input-Zeile nur einmal. Deswegen müssen wir aber die Variable user_input vor der while-Schleife vorbesetzen und die input-Zeile muss als erstes im Schleifenkörper stehen:
correct_password = "password123"
user_input = " "
while user_input != correct_password:
user_input = input("Eingabe des Passwortes: ")
print("Falsches Passwort. Probiere es nochmals.")
print("Willkommen. Das war das korrekte Passwort!")
Löung zu Übung 4¶
correct_password = "password123"
max_attempts = 3
attempts = 0
while attempts < max_attempts:
user_input = input("Passwort eingeben: ")
if user_input == correct_password:
print("Willkommen. Das war das korrekte Passwort!")
break
else:
attempts += 1
remaining_attempts = max_attempts - attempts
if remaining_attempts > 0:
print(f"Falsches Passwort. Noch {remaining_attempts} Versuche übrig")
else:
print("Das war's maximale Eingebeversuche erreicht.")
Löung zu Übung 5¶
number = int(input("Positive ganze Zahl eingeben: "))
divisor = 1
is_prime = True
while divisor <= number // 2:
divisor += 1
if number % divisor == 0 and is_prime:
is_prime = False
break # Schleife wird verlassen, weil Divisor gefunden wurde
# Display the result
if is_prime:
print(number, "ist eine Primzahl.")
else:
print(number, "ist keine Primzahl.")
Löung zu Übung 6¶
n_terms = int(input("Anzahl der gewünschten Fibonacci-Folge-Glieder: "))
old, new = 0, 1
count = 0
while count < n_terms:
print(old, end=" ")
old, new = new, old + new
count += 1
print()
Löung zu Übung 7¶
Der Algorithmus für die Collatz-Sequenz funktioniert wie folgt:
- Man beginnt mit einer beliebigen positiven ganzen Zahl n.
- Wenn n gerade ist, teile es durch 2.
- Wenn n ungerade ist, multipliziere es mit 3 und addiere 1.
- Wiederhole den Vorgang mit dem berechneten Wert als neuem Wert von n und fahre fort, bis n 1 wird.
n = int(input("Enter a positive integer: "))
if n <= 0:
print("Please enter a positive integer.")
else:
print(f"Collatz sequence for {n}:")
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
print(n, end=', ')
n = int(input("Enter a positive integer: "))
length_of_sequence = 0
if n <= 0:
print("Please enter a positive integer.")
else:
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
length_of_sequence += 1
print(f"Length of sequence: {length_of_sequence}")
counter = 1
stop_value = 100
while counter <= stop_value:
#print(f"Collatz sequence for {counter}:")
n = counter
length_of_sequence = 0
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
#print(n, end=", ")
length_of_sequence += 1
print(f"{counter}: {length_of_sequence}", end=", ")
counter += 1
print()