11. Aktionen mit while-Schleifen wiederholen

Programme müssen oft Aktionen mehrfach wiederholen. Sie haben bereits gesehen, wie man mit if-Anweisungen in Kapitel 8 Entscheidungen trifft, aber was ist, wenn Sie eine Aktion wiederholt ausführen müssen, bis eine bestimmte Bedingung erfüllt ist? Hier kommen Schleifen(loop) ins Spiel.

Python stellt zwei Haupttypen von Schleifen(loop) bereit: while-Schleifen und for-Schleifen. In diesem Kapitel konzentrieren wir uns auf while-Schleifen, die einen Codeblock so lange wiederholen, wie eine Bedingung wahr bleibt. Die for-Schleife, die besser zum Iterieren über Sequenzen geeignet ist, wird in Kapitel 12 behandelt.

Das Verständnis von while-Schleifen ist grundlegend, um Programme zu schreiben, die Daten wiederholt verarbeiten, Benutzereingaben validieren, Spielschleifen implementieren und viele andere Programmier-Szenarien aus der Praxis bewältigen können.

11.1) Die Struktur einer while-Schleife

Eine while-Schleife(while loop) führt einen Codeblock wiederholt aus, solange eine angegebene Bedingung zu True ausgewertet wird. Sobald die Bedingung False wird, stoppt die Schleife, und das Programm fährt mit dem Code nach der Schleife fort.

Grundlegende while-Schleifen-Syntax

Die Struktur einer while-Schleife sieht so aus:

while condition:
    # Codeblock, der wiederholt werden soll
    # Dieser Code läuft, solange condition True ist

Die condition ist ein beliebiger Ausdruck, der zu einem booleschen Wert ausgewertet wird (oder als truthy oder falsy interpretiert werden kann, wie wir in Kapitel 7 gelernt haben). Der eingerückte Codeblock unter der while-Anweisung wird Schleifenrumpf(loop body) genannt, und er wird wiederholt ausgeführt, solange die Bedingung True bleibt.

Schauen wir uns ein einfaches Beispiel an:

# Zählen von 1 bis 5
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count = count + 1  # count erhöhen
print("Loop finished!")

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Loop finished!

So funktioniert das Schritt für Schritt:

1. Wir initialisieren count mit 1
2. Die Bedingung count <= 5 wird geprüft. Da 1 <= 5 True ist, wird der Schleifenrumpf(loop body) ausgeführt
3. Innerhalb der Schleife geben wir den aktuellen Zählerstand aus und erhöhen ihn dann um 1
4. Nachdem der Schleifenrumpf(loop body) abgeschlossen ist, kehrt Python zur while-Anweisung zurück und prüft die Bedingung erneut
5. Dieser Prozess wiederholt sich, bis count zu 6 wird. Dann ist 6 <= 5 False, und die Schleife endet
6. Das Programm fährt mit dem Code nach der Schleife fort

Die entscheidende Erkenntnis ist, dass die Bedingung vor jeder Iteration (jeder Wiederholung des Schleifenrumpfs(loop body)) geprüft wird. Wenn die Bedingung anfänglich False ist, wird der Schleifenrumpf(loop body) überhaupt nie ausgeführt:

count = 10
while count <= 5:
    print("This will never print")
print("Loop skipped entirely")

Output:

Loop skipped entirely

Da 10 <= 5 von Anfang an False ist, wird der Schleifenrumpf(loop body) nie ausgeführt.

Die Bedeutung der Änderung der Schleifenvariable

Damit eine while-Schleife irgendwann stoppt, muss etwas innerhalb der Schleife die Bedingung von True zu False ändern. Das bedeutet typischerweise, dass die Variable(n) verändert werden, die in der Bedingung verwendet werden. Wenn Sie das vergessen, erzeugen Sie eine Endlosschleife(infinite loop) (die wir im nächsten Abschnitt im Detail besprechen).

Hier ist ein Beispiel, das zeigt, warum das Aktualisieren der Schleifenvariable wichtig ist:

# Berechnen der Summe der Zahlen von 1 bis 10
total = 0
number = 1
 
while number <= 10:
    total = total + number  # Aktuelle Zahl zu total addieren
    number = number + 1     # Zur nächsten Zahl wechseln
 
print(f"The sum of numbers from 1 to 10 is: {total}")

Output:

The sum of numbers from 1 to 10 is: 55

In diesem Beispiel sammeln wir eine Summe an, während wir durch Zahlen fortschreiten. Sowohl total als auch number ändern sich mit jeder Iteration, aber es ist die Veränderung von number, die sicherstellt, dass die Schleife schließlich endet, wenn number zu 11 wird.

while-Schleifen mit Benutzereingaben

Eine praktische Verwendung von while-Schleifen ist das Verarbeiten von Benutzereingaben, bis eine bestimmte Bedingung erfüllt ist. Erstellen wir ein einfaches Zahlenratespiel:

# Einfaches Zahlenratespiel
secret_number = 7
guess = 0
 
while guess != secret_number:
    guess = int(input("Guess the number (1-10): "))
    
    if guess < secret_number:
        print("Too low! Try again.")
    elif guess > secret_number:
        print("Too high! Try again.")
    else:
        print("Correct! You guessed it!")

Diese Schleife fragt weiter nach Vermutungen, bis der Benutzer die richtige Zahl eingibt. Jede Iteration verarbeitet eine Vermutung und gibt Feedback. Die Schleife endet auf natürliche Weise, wenn guess gleich secret_number ist, wodurch die Bedingung guess != secret_number zu False wird.

while-Schleifen mit mehreren Bedingungen

Sie können boolesche Operatoren (and, or, not) verwenden, um komplexere Schleifenbedingungen zu erstellen, wie wir in Kapitel 9 gelernt haben:

# Eingabe verarbeiten, bis der Benutzer "quit" eingibt oder 5 Versuche erreicht
attempts = 0
user_input = ""
 
while user_input != "quit" and attempts < 5:
    user_input = input("Enter a command (or 'quit' to exit): ")
    attempts += 1
    
    if user_input == "quit":
        print("Goodbye!")
    else:
        print(f"You entered: {user_input}")
        print(f"Attempts remaining: {5 - attempts}")
 
if attempts >= 5 and user_input != "quit":
    print("Maximum attempts reached.")

Diese Schleife läuft weiter, solange beide Bedingungen wahr sind: Der Benutzer hat nicht "quit" eingegeben und er hat 5 Versuche nicht überschritten. Die Schleife endet, wenn eine der Bedingungen falsch wird.

Ausführung einer while-Schleife visualisieren

Hier ist ein Flussdiagramm, das zeigt, wie eine while-Schleife ausgeführt wird:

Die Schleife erzeugt einen Zyklus, in dem die Bedingung geprüft wird, der Rumpf ausgeführt wird, wenn die Bedingung wahr ist, Variablen aktualisiert werden und dann die Bedingung erneut geprüft wird. Dieser Zyklus läuft weiter, bis die Bedingung falsch wird.

11.2) Endlosschleifen und wie man sie vermeidet

Eine Endlosschleife(infinite loop) ist eine Schleife, die nie endet, weil ihre Bedingung nie False wird. Endlosschleifen gehören zu den häufigsten Fehlern, die Anfänger mit while-Schleifen machen, und sie können dazu führen, dass Ihr Programm unendlich lange hängt.

Was verursacht Endlosschleifen?

Die häufigste Ursache für Endlosschleifen ist, dass man vergisst, die Variable(n) zu verändern, die die Schleifenbedingung beeinflussen. Schauen wir uns ein problematisches Beispiel an:

# WARNUNG: Endlosschleife - nur zur Demonstration
# PROBLEM: count wird nie verändert
count = 1
while count <= 5:
    print(f"Count is: {count}")
    # Missing: count += 1

Wenn Sie diesen Code ausführen würden, würde er für immer "Count is: 1" ausgeben, weil count 1 bleibt und 1 <= 5 immer True ist. Die Bedingung ändert sich nie.

Woran Sie erkennen, dass es eine Endlosschleife ist: Schauen Sie sich die Schleifenbedingung (count <= 5) an und prüfen Sie dann, ob irgendetwas im Schleifenrumpf(loop body) count verändert. Wenn nicht, und die Bedingung startet als True, haben Sie eine Endlosschleife.

Hier ist die korrigierte Version:

# Korrekte Version mit sauberer Erhöhung
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Das stellt sicher, dass die Schleife schließlich endet

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5

Endlosschleifen mit Sicherheitslimits debuggen

Beim Entwickeln von Code mit Schleifen ist es hilfreich, ein Sicherheitslimit einzubauen, um versehentliche Endlosschleifen während des Testens zu verhindern:

# Sicherheitslimit während der Entwicklung
count = 1
iterations = 0
max_iterations = 100  # Sicherheitslimit
 
while count <= 5 and iterations < max_iterations:
    print(f"Count is: {count}")
    count += 1
    iterations += 1
 
if iterations >= max_iterations:
    print("WARNING: Maximum iterations reached. Check for infinite loop.")

Dieses Muster fügt einen Zähler hinzu, der verfolgt, wie oft die Schleife ausgeführt wurde. Wenn er das Sicherheitslimit erreicht, wissen Sie, dass etwas mit Ihrer Schleifenlogik nicht stimmt. Sobald Sie sicher sind, dass Ihre Schleife korrekt funktioniert, können Sie das Sicherheitslimit entfernen.

Endlosschleifen mit Benutzereingaben

Ein weiteres häufiges Szenario für Endlosschleifen betrifft die Validierung von Benutzereingaben:

# WARNUNG: Potenzielle Endlosschleife - nur zur Demonstration
# PROBLEM: Wenn der Benutzer nie gültige Eingaben macht, endet die Schleife nie
age = -1
while age < 0:
    age = int(input("Enter your age: "))
    # Wenn der Benutzer eine negative Zahl eingibt, läuft die Schleife weiter

Diese Schleife funktioniert korrekt, wenn der Benutzer schließlich eine nicht-negative Zahl eingibt, aber sie wird zu einer Endlosschleife, wenn der Benutzer weiterhin negative Werte eingibt. Auch wenn das für manche Programme akzeptabel sein kann (Sie möchten weiter fragen, bis eine gültige Eingabe vorliegt), ist es wichtig zu verstehen, dass das Ende der Schleife vollständig vom Verhalten des Benutzers abhängt.

Ein robusterer Ansatz könnte eine Möglichkeit zum Beenden enthalten:

# Besserer Ansatz mit Beenden-Option
age = -1
while age < 0:
    user_input = input("Enter your age (or 'quit' to exit): ")
    
    if user_input.lower() == 'quit':
        print("Exiting program.")
        age = 0  # Auf einen gültigen Wert setzen, um die Schleife zu beenden
    else:
        age = int(user_input)
        if age < 0:
            print("Age must be non-negative. Please try again.")
 
if age > 0:
    print(f"Your age is: {age}")

Endlosschleifen durch Logikfehler

Manchmal entstehen Endlosschleifen durch Logikfehler beim Aktualisieren von Variablen:

# WARNUNG: Endlosschleife - nur zur Demonstration
# PROBLEM: count wird verringert statt erhöht
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count -= 1  # FEHLER: Das macht count kleiner, nicht größer

Das erzeugt eine Endlosschleife, weil count bei 1 startet und zu 0, -1, -2 usw. wird. Da negative Zahlen immer kleiner oder gleich 5 sind, bleibt die Bedingung count <= 5 für immer True.

Die korrigierte Version:

count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Korrekt: erhöhen, um schließlich 5 zu überschreiten

Endlosschleifen debuggen

Wenn Sie beim Ausführen eines Python-Skripts versehentlich eine Endlosschleife erzeugen, können Sie sie beenden, indem Sie im Terminal Ctrl+C (oder Cmd+C auf dem Mac) drücken. Das sendet ein Keyboard-Interrupt-Signal an Python, wodurch das Programm stoppt.

So vermeiden Sie Endlosschleifen:

1. Stellen Sie immer sicher, dass die Schleifenbedingung False werden kann: Prüfen Sie, dass Variablen in der Bedingung innerhalb der Schleife verändert werden
2. Verwenden Sie den richtigen Vergleichsoperator: Stellen Sie sicher, dass <=, <, != usw. Ihrer Absicht entsprechen
3. Testen Sie zuerst mit kleinen Werten: Bevor Sie eine Schleife laufen lassen, die sehr oft ausgeführt werden könnte, testen Sie mit kleinen Limits
4. Fügen Sie Debug-Ausgaben hinzu: Geben Sie vorübergehend die Schleifenvariable aus, um zu sehen, wie sie sich verändert:
5. Verwenden Sie Sicherheitslimits während der Entwicklung: Wie zuvor gezeigt, fügen Sie beim Testen einen maximalen Iterationszähler hinzu

11.3) break und continue in while-Schleifen verwenden

Python stellt zwei spezielle Anweisungen bereit, die Ihnen mehr Kontrolle über die Ausführung von Schleifen geben: break und continue. Diese Anweisungen erlauben es Ihnen, den normalen Ablauf einer Schleife basierend auf Bedingungen zu verändern, die während der Ausführung auftreten.

11.3.1) Die break-Anweisung

Die break-Anweisung beendet die Schleife sofort, unabhängig von der Schleifenbedingung. Wenn Python auf break trifft, verlässt es die Schleife vollständig und fährt mit dem Code nach der Schleife fort.

Hier ist ein einfaches Beispiel:

# Schleife beenden, wenn ein bestimmter Wert erreicht ist
count = 1
while count <= 10:
    if count == 5:
        print("Reached 5, stopping loop")
        break
    print(f"Count: {count}")
    count += 1
 
print("Loop exited")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Reached 5, stopping loop
Loop exited

Beachten Sie, dass sobald count gleich 5 ist, die break-Anweisung ausgeführt wird und die Schleife sofort endet. Die Schleife erreicht nie count = 6, obwohl die Bedingung count <= 10 weiterhin True wäre.

Wie break den Schleifenfluss verändert

Zu verstehen, wie break die normale Schleifenausführung verändert, ist entscheidend. Hier ist ein Flussdiagramm, das den Unterschied zeigt:

Der Kernpunkt: break bietet einen sofortigen Ausstiegspfad aus der Schleife, wobei sowohl der verbleibende Code im Schleifenrumpf als auch die Bedingungsprüfung umgangen werden.

Praktische Verwendung von break: Eingabevalidierung

Eine der häufigsten Verwendungen von break ist, eine Schleife zu beenden, wenn eine gültige Eingabe empfangen wurde:

# So lange nach einer gültigen Eingabe fragen, bis sie vorliegt
while True:
    age_input = input("Enter your age (must be positive): ")
    
    # Versuchen, in eine Ganzzahl umzuwandeln
    try:
        age = int(age_input)
        
        # Prüfen, ob gültig
        if age > 0:
            print(f"Thank you! Your age is {age}")
            break  # Schleife bei gültiger Eingabe verlassen
        else:
            print("Age must be positive. Please try again.")
    except ValueError:
        print("That's not a valid number. Please try again.")
 
print("Input validation complete")

Dieses Muster verwendet while True:, um eine absichtliche Endlosschleife zu erzeugen, und nutzt dann break, um zu beenden, wenn eine gültige Eingabe empfangen wurde. Das ist sauberer, als zu versuchen, eine komplexe Schleifenbedingung zu verwalten. (Hinweis: Wir verwenden hier try und except, worüber wir in Teil VII im Detail lernen werden. Verstehen Sie fürs Erste einfach, dass es Fehler abfängt, wenn Eingaben in eine Ganzzahl umgewandelt werden.)

break mit mehreren Bedingungen

Sie können break mit komplexen Bedingungen verwenden, um eine Schleife zu beenden, wenn eines von mehreren Kriterien erfüllt ist:

# Nach einem bestimmten Element in der Benutzereingabe suchen
search_term = "python"
attempts = 0
max_attempts = 5
 
while attempts < max_attempts:
    user_input = input("Enter a word (or 'quit' to exit): ").lower()
    attempts += 1
    
    if user_input == 'quit':
        print("User requested exit")
        break
    
    if user_input == search_term:
        print(f"Found '{search_term}'!")
        break
    
    print(f"'{user_input}' is not '{search_term}'. Try again.")
    print(f"Attempts remaining: {max_attempts - attempts}")
 
if attempts >= max_attempts:
    print("Maximum attempts reached")

Diese Schleife kann auf drei Arten enden:

1. Der Benutzer gibt "quit" ein (erstes break)
2. Der Benutzer gibt den Suchbegriff ein (zweites break)
3. Maximale Versuche erreicht (Schleifenbedingung wird False)

11.3.2) Die continue-Anweisung

Die continue-Anweisung überspringt den Rest der aktuellen Iteration und springt zurück zur Prüfung der Schleifenbedingung. Anders als break, das die Schleife vollständig beendet, überspringt continue nur zur nächsten Iteration.

Hier ist ein grundlegendes Beispiel:

# Nur ungerade Zahlen von 1 bis 10 ausgeben
count = 0
while count < 10:
    count += 1
    
    if count % 2 == 0:  # Wenn gerade Zahl
        continue  # Den Rest überspringen und zur nächsten Iteration gehen
    
    print(f"Odd number: {count}")

Output:

Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9

So funktioniert das:

1. count wird zu Beginn jeder Iteration erhöht
2. Wenn count gerade ist (count % 2 == 0), wird continue ausgeführt
3. Die continue-Anweisung überspringt die print-Anweisung und springt zurück zur while-Bedingung
4. Wenn count ungerade ist, wird continue nicht ausgeführt, sodass die print-Anweisung läuft

Wie continue den Schleifenfluss verändert

Hier ist ein Flussdiagramm, das zeigt, wie continue die Schleifenausführung beeinflusst:

Der entscheidende Unterschied zwischen break und continue:

• break: Beendet die Schleife vollständig und springt zum Code nach der Schleife
• continue: Überspringt den verbleibenden Code in der aktuellen Iteration und springt zurück zur Bedingungsprüfung

Wichtiger Hinweis zur Platzierung von continue

Beachten Sie, dass count += 1 vor dem continue steht. Würden wir es danach platzieren, würden gerade Zahlen dazu führen, dass continue die Erhöhung überspringt, was eine Endlosschleife erzeugen würde:

# WARNUNG: Endlosschleife - nur zur Demonstration
# PROBLEM: continue überspringt die Erhöhung bei geraden Zahlen
count = 0
while count < 10:
    if count % 2 == 0:
        continue  # Überspringt alles darunter, einschließlich count += 1
    count += 1  # FEHLER: Das wird bei geraden Zahlen nie ausgeführt
    print(f"Odd number: {count}")

Wenn count 0 ist (gerade), wird continue ausgeführt und count += 1 übersprungen. Die Schleife prüft erneut 0 < 10, und der Zyklus wiederholt sich für immer.

Die Regel: Stellen Sie immer sicher, dass Schleifenvariablen, die die Bedingung beeinflussen, vor jeder continue-Anweisung aktualisiert werden, die den Rest des Schleifenrumpfs überspringen könnte.

Praktische Verwendung von continue: Daten filtern

Die continue-Anweisung ist nützlich, wenn Sie Daten verarbeiten und bestimmte Elemente überspringen möchten:

# Nur gültige Scores verarbeiten
score_count = 0
total_score = 0
attempts = 0
 
while attempts < 5:
    score_input = input(f"Enter score {attempts + 1} (or 'skip' to skip): ")
    attempts += 1
    
    if score_input.lower() == 'skip':
        print("Skipping this score")
        continue  # Zur nächsten Iteration springen
    
    try:
        score = int(score_input)
        
        if score < 0 or score > 100:
            print("Score must be between 0 and 100. Skipping.")
            continue  # Ungültige Scores überspringen
        
        # Gültiger Score - verarbeiten
        total_score += score
        score_count += 1
        print(f"Score recorded: {score}")
        
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
if score_count > 0:
    average = total_score / score_count
    print(f"\nAverage of {score_count} valid scores: {average:.1f}")
else:
    print("\nNo valid scores entered")

Dieses Beispiel zeigt mehrere Verwendungen von continue:

• Überspringen, wenn der Benutzer "skip" eingibt
• Überspringen, wenn der Score außerhalb des gültigen Bereichs liegt
• Überspringen, wenn die Eingabe keine gültige Zahl ist

Jedes continue verhindert, dass der Score zur Summe hinzugefügt wird, aber die Schleife läuft mit dem nächsten Versuch weiter.

break und continue kombinieren

Sie können sowohl break als auch continue in derselben Schleife verwenden, um eine anspruchsvolle Steuerung zu erreichen:

# Zahlen verarbeiten, bis die Summe 100 überschreitet; negative Zahlen überspringen
total = 0
count = 0
 
while True:
    number_input = input("Enter a number (or 'done' to finish): ")
    
    if number_input.lower() == 'done':
        print("User finished entering numbers")
        break  # Schleife verlassen
    
    try:
        number = int(number_input)
        
        if number < 0:
            print("Negative numbers not allowed. Skipping.")
            continue  # Zur nächsten Iteration springen
        
        total += number
        count += 1
        print(f"Added {number}. Current total: {total}")
        
        if total > 100:
            print("Total exceeded 100. Stopping.")
            break  # Schleife verlassen, wenn Limit erreicht
            
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
print(f"\nFinal total: {total} (from {count} numbers)")

Diese Schleife demonstriert:

• break, um zu beenden, wenn der Benutzer "done" tippt
• continue, um negative Zahlen zu überspringen
• continue, um ungültige Eingaben zu überspringen
• break, um zu beenden, wenn die Summe 100 überschreitet

11.4) else mit while-Schleifen verwenden

Python hat ein einzigartiges Feature, das viele andere Programmiersprachen nicht haben: Sie können an eine while-Schleife eine else-Klausel anhängen. Dieser else-Block wird nur dann ausgeführt, wenn die Schleife normal endet (das bedeutet: Die Schleifenbedingung wird False, ohne dass eine break-Anweisung ausgeführt wurde).

Grundlegende else-mit-while-Syntax

Die Syntax sieht so aus:

while condition:
    # Schleifenrumpf
else:
    # Das wird nur ausgeführt, wenn die Schleife normal endet
    # (nicht durch break unterbrochen)

Schauen wir uns ein einfaches Beispiel an:

# Von 1 bis 5 zählen mit else-Klausel
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1
else:
    print("Loop completed normally")
 
print("Program continues")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Loop completed normally
Program continues

Der else-Block wird ausgeführt, weil die Schleife lief, bis ihre Bedingung (count <= 5) False wurde. Die Schleife endete „normal“, ohne unterbrochen zu werden.

Wann else NICHT ausgeführt wird: Die break-Anweisung

Das Schlüsselverhalten der else-Klausel ist, dass sie nicht ausgeführt wird, wenn die Schleife durch eine break-Anweisung beendet wird:

# Nach einer Zahl suchen mit break
count = 1
target = 3
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Found 3!
Search complete

Beachten Sie, dass der else-Block ("Target not found in range") nicht ausgeführt wurde, weil die Schleife durch break beendet wurde. Das ist der entscheidende Unterschied: else läuft nur, wenn die Schleife normal endet (Bedingung wird False), nicht wenn sie über break endet.

Sehen wir uns nun an, was passiert, wenn das Ziel nicht gefunden wird:

# Nach einer Zahl suchen, die nicht existiert
count = 1
target = 7  # Nicht im Bereich 1-5
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Checking: 4
Checking: 5
Target not found in range
Search complete

Diesmal hat die Schleife alle Iterationen abgeschlossen, ohne das Ziel zu finden, sodass die Bedingung count <= 5 schließlich False wurde und der else-Block ausgeführt wurde.

Wie else bei Abschluss der Schleife funktioniert

Hier ist ein Flussdiagramm, das die Ausführungspfade mit der else-Klausel zeigt:

Der else-Block wird nur erreicht, wenn die Schleifenbedingung auf natürliche Weise False wird. Wenn break erreicht wird, springt der Ablauf direkt am else-Block vorbei zum Code nach der Schleife.

Praktische Verwendung: Suchoperationen

Die else-Klausel ist besonders nützlich für Suchoperationen, bei denen Sie wissen möchten, ob etwas gefunden wurde:

# Nach einem gültigen Passwort in einer Liste von Versuchen suchen
valid_password = "python123"
max_attempts = 3
attempts = 0
 
while attempts < max_attempts:
    password = input(f"Enter password (attempt {attempts + 1}/{max_attempts}): ")
    attempts += 1
    
    if password == valid_password:
        print("Access granted!")
        break
else:
    print("Access denied. Maximum attempts exceeded.")
    print("Account locked.")

Wenn der Benutzer das richtige Passwort eingibt, wird break ausgeführt und der else-Block übersprungen. Wenn alle Versuche ohne Erfolg aufgebraucht werden, endet die Schleife normal und der else-Block wird ausgeführt, was einen Fehlschlag anzeigt.

else mit continue

Die continue-Anweisung verhindert nicht, dass der else-Block ausgeführt wird. Nur break tut das:

# continue beeinflusst die else-Ausführung nicht
count = 0
while count < 5:
    count += 1
    if count == 3:
        print(f"Skipping {count}")
        continue  # Zur nächsten Iteration springen
    print(f"Processing {count}")
else:
    print("Loop completed normally (continue doesn't prevent this)")

Output:

Processing 1
Processing 2
Skipping 3
Processing 4
Processing 5
Loop completed normally (continue doesn't prevent this)

Der else-Block wird ausgeführt, weil die Schleife normal endete. Die continue-Anweisung beeinflusst nur einzelne Iterationen, nicht den gesamten Abschluss der Schleife.

else mit und ohne break vergleichen

Schauen wir uns einen Vergleich nebeneinander an:

# Beispiel 1: Erste Zahl finden, die durch 7 teilbar ist (mit break)
print("Finding first number divisible by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
        break
    number += 1
else:
    print("No number divisible by 7 found in range")
print()
 
# Beispiel 2: Alle Zahlen prüfen (ohne break)
print("Checking all numbers for divisibility by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
    number += 1
else:
    print("Finished checking all numbers")

Output:

Finding first number divisible by 7:
Found: 7
 
Checking all numbers for divisibility by 7:
Found: 7
Found: 14
Finished checking all numbers

Im ersten Beispiel stoppt break die Schleife, nachdem der erste Treffer gefunden wurde, daher wird else nicht ausgeführt. Im zweiten Beispiel prüft die Schleife alle Zahlen und endet normal, daher wird else ausgeführt.

Wann man else mit while-Schleifen verwenden sollte

Die else-Klausel ist am nützlichsten, wenn:

1. Suchoperationen: Sie möchten wissen, ob etwas gefunden wurde oder nicht
2. Validierung mit begrenzten Versuchen: Sie müssen den Fall behandeln, dass alle Versuche ausgeschöpft sind
3. Verarbeitung mit frühem Ausstieg: Sie möchten ein anderes Verhalten für „alles abgeschlossen“ vs. „früh gestoppt“

Allerdings kann else bei Schleifen für Programmierer, die aus anderen Sprachen kommen (wo es dieses Feature nicht gibt), verwirrend sein. Manchmal ist es klarer, eine Flag-Variable zu verwenden:

# else-Klausel verwenden
attempts = 0
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        break
else:
    print("Access denied")
 
# Entsprechendes Beispiel mit einer Flag-Variable (manchmal klarer)
attempts = 0
access_granted = False
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        access_granted = True
        break
 
if not access_granted:
    print("Access denied")

Beide Ansätze funktionieren. Wählen Sie den, der Ihren Code für Ihre konkrete Situation klarer macht.

Das Verständnis von else bei while-Schleifen gibt Ihnen ein weiteres Werkzeug, um klaren, ausdrucksstarken Code zu schreiben, insbesondere in Such- und Validierungsszenarien, in denen Sie zwischen „gefunden“ und „nicht gefunden“ oder „Erfolg“ und „Fehlschlag nach allen Versuchen“ unterscheiden müssen.

In diesem Kapitel haben wir while-Schleifen ausführlich untersucht und gelernt, wie man:

• Schleifen strukturiert, die Code basierend auf Bedingungen wiederholen
• Endlosschleifen vermeidet, indem man Schleifenvariablen korrekt aktualisiert
• break verwendet, um Schleifen bei Bedarf frühzeitig zu verlassen
• continue verwendet, um Iterationen basierend auf Bedingungen zu überspringen
• else verwendet, um Fälle zu behandeln, in denen Schleifen normal ohne break enden

Diese Werkzeuge geben Ihnen eine leistungsstarke Kontrolle über Wiederholungen in Ihren Programmen. Im nächsten Kapitel lernen wir for-Schleifen kennen, die eine bequemere Möglichkeit bieten, über Sequenzen wie Strings, Listen und Bereiche zu iterieren.