while-Schleifen — laufen, solange eine Bedingung gilt

Das Problem, das wir lösen

Im letzten Kapitel haben wir gelernt, schlechte Eingaben abzufangen — wenn jemand twenty eintippt, kann das Programm sagen „das ist keine Zahl“.

Aber was macht es danach? Es hört auf. Die Person muss das ganze Programm noch einmal starten. Echte Software verhält sich nicht so — sie fragt noch einmal und fragt so lange weiter, bis sie eine gültige Antwort bekommt.

Dafür gibt es Schleifen: dieselbe Arbeit immer wieder zu erledigen, solange sie gebraucht wird. Heute lernst du while kennen, das läuft solange eine Bedingung wahr bleibt.

Außerdem wartet heute eine neue Erfahrung auf dich: ein Programm, das nicht aufhört, und Text, der durch das Terminal rast. Keine Angst — in diesem Kapitel lernst du, wie du es stoppst.

Am Ende dieses Kapitels kannst du

• Eine while-Schleife schreiben und sagen, wann sie aufhört
• Erkennen, warum Endlosschleifen entstehen, und eine mit Ctrl + C anhalten
• Eine Summe oder einen Zähler innerhalb einer Schleife aufbauen
• break und continue an den richtigen Stellen einsetzen
• So lange nachfragen, bis die Eingabe gültig ist

Voraussetzungen: Entscheidungen treffen — if, elif, else.

Die einfachste Schleife

count = 3

while count > 0:
    print(count)
    count = count - 1

print("Go")

3
2
1
Go

Der Aufbau sieht aus wie bei einem if — Bedingung, Doppelpunkt, eingerückter Block. Es gibt einen Unterschied, und der ist entscheidend: Ein if prüft die Bedingung einmal; ein while prüft sie jedes Mal neu, wenn der Block fertig ist.

Was das Programm oben getan hat:

1. count ist 3. Die Bedingung 3 > 0 ist wahr → der Block lief, hat 3 ausgegeben, und count wurde zu 2
2. Erneut prüfen: 2 > 0 ist wahr → 2 ausgegeben, count wurde zu 1
3. Erneut prüfen: 1 > 0 ist wahr → 1 ausgegeben, count wurde zu 0
4. Erneut prüfen: 0 > 0 ist falsch → die Schleife endet und das Programm geht weiter

Jede funktionierende while-Schleife hat drei Teile, und sie braucht alle drei:

• Ein Startwert — vor der Schleife (count = 3)
• Eine Bedingung — wann weitergemacht wird (count > 0)
• Eine Änderung — etwas im Inneren, das die Bedingung irgendwann falsch macht (count = count - 1)

Endlosschleifen

Es lohnt sich zu sehen, was passiert, wenn der dritte Teil fehlt:

count = 3

while count > 0:
    print(count)

Das gibt 3 für immer aus. count ändert sich nie, also wird count > 0 nie falsch.

So stoppst du sie: drücke Ctrl + C im Terminal. Sie hält sofort an und zeigt etwa Folgendes:

Traceback (most recent call last):
  File "D:\python-lab\lesson-10\loop.py", line 4, in <module>
    print(count)
KeyboardInterrupt

Die File-Zeile zeigt den vollständigen Pfad deiner Datei, und die Zeilennummer hängt davon ab, in welchem Moment du die Tasten drückst. KeyboardInterrupt bedeutet, dass du sie selbst gestoppt hast. Das ist kein Fehler in deinem Code, sondern deine Entscheidung.

Endlosschleifen gehören zum Lernen dazu. Auch erfahrene Entwickler schreiben sie noch immer. Du musst keine Angst haben: Wenn du Ctrl + C kennst, ist eine Endlosschleife nur noch ein kleines Ärgernis. Wenn du eine Schleife schreibst, frag dich einmal: „Wie wird diese Bedingung falsch?“ Wenn du das nicht beantworten kannst, hört die Schleife nicht auf.

Akkumulieren

Die häufigste Aufgabe einer Schleife ist, etwas aufzubauen — eine Summe, einen Zähler, den größten bisher gesehenen Wert:

total = 0
number = 1

while number <= 5:
    total = total + number
    number = number + 1

print("Sum of 1 to 5:", total)

Sum of 1 to 5: 15

total nennt man einen Akkumulator — den Behälter, in den du alles sammelst. Beachte, dass er vor der Schleife startet, bei 0. Würdest du ihn innerhalb starten, würde er bei jedem Durchlauf zurückgesetzt, und am Ende bliebe nur die letzte Zahl übrig.

break — sofort verlassen

break beendet die Schleife sofort, egal was die Bedingung sagt:

number = 1

while number <= 100:
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break
    number = number + 1

First multiple of 7: 7

Die Bedingung sagte, bis 100 zu laufen, aber die Arbeit war erledigt, sobald die 7 auftauchte — es hatte also keinen Sinn, noch 93 weitere Runden zu drehen.

break ermöglicht außerdem ein Muster, das sehr nützlich ist: True als Bedingung zu schreiben und an der richtigen Stelle im Inneren herauszuspringen:

while True:
    answer = input("Type 'quit' to exit: ").strip().lower()
    if answer == "quit":
        print("Goodbye")
        break
    print(f"You typed: {answer}")

Type 'quit' to exit: hello
You typed: hello
Type 'quit' to exit: QUIT
Goodbye

while True bedeutet „läuft für immer“, deshalb ist ein break im Inneren zwingend — sonst ist es eine Endlosschleife.

continue — diesen Durchlauf überspringen

continue beendet die Schleife nicht; es überspringt den Rest des Blocks und springt direkt zum nächsten Durchlauf:

number = 0

while number < 10:
    number = number + 1
    if number % 2 == 0:
        continue
    print(number)

1
3
5
7
9

Bei jeder geraden Zahl hat continue gegriffen, deshalb wurde das print übersprungen.

Beim Schreiben von continue gibt es eine Falle. Steht die Zeile, die die Bedingung weiterschaltet (number = number + 1), hinter dem continue, dann überspringt continue sie — und die Schleife bleibt dort für immer hängen. Deshalb steht die Erhöhung im Code oben zuerst. Achte bei jedem continue auf diese Reihenfolge.

Endlich: so lange nachfragen, bis die Eingabe gültig ist

Darauf haben wir seit zwei Kapiteln gewartet:

while True:
    raw = input("Your age: ").strip()
    if raw.isdigit():
        age = int(raw)
        break
    print("Please type a whole number, digits only.")

print(f"Thank you. Age recorded as {age}.")

Your age: twenty
Please type a whole number, digits only.
Your age: 22.5
Please type a whole number, digits only.
Your age: 22
Thank you. Age recorded as 22.

Das ist das Muster, das du dein ganzes Berufsleben lang verwenden wirst: endlos laufen, innen prüfen, mit break verlassen, wenn die Eingabe passt, und bei einer falschen Eingabe eine Meldung ausgeben und von vorn beginnen. Das Programm bricht bei falschen Eingaben nicht mehr ab, und die Person muss nicht noch einmal anfangen.

Ein vollständiges Beispiel

shopping.py:

# Keep taking item prices until the user is done, then summarise
total = 0.0
item_count = 0

print("Enter item prices. Type 'done' to finish.")

while True:
    entry = input("Price: ").strip().lower()

    if entry == "done":
        break

    if entry == "":
        print("  Nothing typed — try again.")
        continue

    # Accept only digits and at most one decimal point
    if entry.replace(".", "", 1).isdigit():
        price = float(entry)
        total = total + price
        item_count = item_count + 1
        print(f"  Added {price:.2f}. Running total {total:.2f}")
    else:
        print(f"  '{entry}' is not a price. Try again.")

print()
if item_count == 0:
    print("No items were entered.")
else:
    average = total / item_count
    print(f"Items   : {item_count}")
    print(f"Total   : {total:.2f}")
    print(f"Average : {average:.2f}")

Enter item prices. Type 'done' to finish.
Price: 120
  Added 120.00. Running total 120.00
Price: abc
  'abc' is not a price. Try again.
Price: 85.5
  Added 85.50. Running total 205.50
Price: done

Items   : 2
Total   : 205.50
Average : 102.75

Drei Dinge greifen hier ineinander, und alle drei sind der heutige Stoff:

• break — die Schleife verlassen, wenn die Person done eintippt
• continue — den Rest überspringen und bei einer leeren Zeile erneut fragen
• Akkumulatoren — total und item_count beginnen beide vor der Schleife und wachsen innerhalb

Denk darüber nach, warum das abschließende if item_count == 0 nötig ist. Wenn jemand sofort done eintippt, ohne etwas einzugeben, ist item_count gleich 0, und total / item_count würde das Programm mit einem ZeroDivisionError abbrechen. Bevor du etwas verwendest, das eine Schleife gesammelt hat, stell dir jedes Mal die Frage: „Wurde überhaupt etwas gesammelt?“

Wenn etwas schiefgeht

Das Programm hört nicht auf, Text rast vorbei Drücke Ctrl + C. Prüfe dann, ob der Schleifenkörper die Zeile enthält, die die Bedingung weiterschaltet, und ob diese Zeile nicht hinter einem continue steht.

Die Schleife wurde gar nicht ausgeführt Die Bedingung war schon von Anfang an falsch. Vergleiche den Startwert mit der Bedingung — while count > 0 mit count = 0 betritt die Schleife nie.

Sie läuft einmal zu oft oder einmal zu selten < und <= wurden verwechselt. Mit n = 1 läuft while n < 5 viermal (mit n bei 1, 2, 3, 4), und while n <= 5 läuft fünfmal. Ändert man den Startwert, ändert sich auch die Anzahl — mit n = 0 läuft while n < 5 fünfmal. Prüfe deshalb immer Startwert und Bedingung zusammen.

IndentationError: expected an indented block after 'while' statement Die Zeile nach dem while ist nicht eingerückt.

NameError nach der Schleife — die Variable ist unbekannt Die Variable wurde nur innerhalb der Schleife erzeugt, und wenn die Schleife nie lief, wurde sie nie erzeugt. Gib jeder Variablen, die du nach der Schleife brauchst, vorher einen Startwert.

Die Summe stimmt am Ende der Schleife nicht Prüfe, ob der Akkumulator innerhalb der Schleife initialisiert wird. Die Zeile total = 0 muss außerhalb der Schleife stehen.

Jetzt bist du dran

Schreibe ein Zahlenratespiel, guess.py:

1. Lege im Code eine geheime Zahl zwischen 1 und 100 fest
2. Frag die Person nach ihrem Tipp und sag bei jedem Versuch, ob die Zahl „höher“ oder „niedriger“ ist
3. Bei einem richtigen Tipp gratulierst du und verlässt die Schleife
4. Gib aus, wie viele Versuche es gebraucht hat
5. Wenn die Person etwas eintippt, das keine Zahl ist, darf das Programm nicht abbrechen — gib eine Meldung aus und frag erneut
6. Nach sieben Versuchen endet das Spiel und verrät die geheime Zahl

Punkt 6 ist der, bei dem du nachdenken musst: Deine Schleife kann jetzt aus zwei verschiedenen Gründen enden — durch einen richtigen Tipp oder weil die Versuche aufgebraucht sind. Wie du die beiden Ausgänge anordnest, ist die eigentliche Frage dieser Übung. Und wenn es funktioniert, lies deinen Code noch einmal und frag dich: Gibt es einen Zustand, den diese Schleife erreichen könnte, in dem sie für immer läuft?