12. Iteration mit for-Schleifen und range()

In Kapitel 11 haben wir while-Schleifen (while loops) kennengelernt, die Aktionen so lange wiederholen, wie eine Bedingung wahr bleibt. Obwohl while-Schleifen leistungsfähig und flexibel sind, müssen wir bei ihnen Schleifenzähler manuell verwalten und Bedingungen aktualisieren. Python bietet eine weitere Art von Schleife—die for-Schleife (for loop)—die bei einer anderen, aber extrem häufigen Aufgabe glänzt: jedes Element in einer Datensammlung nacheinander zu verarbeiten.

Die for-Schleife ist eines der am häufigsten verwendeten Features von Python. Ob Sie Zeilen in einer Datei verarbeiten, Statistiken aus einer Zahlenfolge berechnen oder jedes Zeichen in einem String überprüfen—die for-Schleife bietet eine saubere, gut lesbare Möglichkeit, Sequenzen von Daten zu durchlaufen. In diesem Kapitel erkunden wir, wie for-Schleifen funktionieren, wie Sie Pythons range()-Funktion für Zähl-Operationen verwenden und wie Sie die Schleifenausführung mit break, continue und der weniger bekannten else-Klausel steuern.

12.1) Die for-Schleife und Iterationskonzepte

12.1.1) Was ist eine for-Schleife?

Eine for-Schleife (for loop) in Python wiederholt einen Codeblock genau einmal für jedes Element in einer Sequenz. Die Sequenz kann ein String sein, eine Liste (list) (die wir in Kapitel 14 im Detail kennenlernen) oder eine andere Sammlung von Elementen. Der zentrale Unterschied zu einer while-Schleife ist, dass eine for-Schleife die Iteration automatisch handhabt—Sie müssen keinen Zähler manuell aktualisieren oder eine Bedingung prüfen.

Hier ist die grundlegende Struktur einer for-Schleife:

for variable in sequence:
    # Codeblock, der für jedes Element ausgeführt wird
    # Die Variable enthält das aktuelle Element

Die for-Schleife funktioniert so:

1. Python nimmt das erste Element aus der Sequenz und weist es der Variable zu
2. Der Codeblock (unter der for-Anweisung eingerückt) wird ausgeführt
3. Python nimmt das nächste Element, weist es der Variable zu und führt den Block erneut aus
4. Das geht so weiter, bis alle Elemente in der Sequenz verarbeitet wurden

Sehen wir uns ein einfaches Beispiel mit einem String an:

# Jedes Zeichen in einem Namen ausgeben
name = "Alice"
for character in name:
    print(character)

Output:

A
l
i
c
e

In diesem Beispiel ist der String "Alice" die Sequenz. Die Schleife verarbeitet jedes Zeichen nacheinander. Während der ersten Iteration (iteration) enthält character 'A', während der zweiten Iteration enthält es 'l' und so weiter. Den Variablennamen character wählen wir selbst—wir hätten ihn auch letter, char oder sogar einfach c nennen können. Wählen Sie Namen, die den Zweck Ihres Codes klar machen.

Konventionen zur Benennung von Schleifenvariablen: Wenn Sie for-Schleifen schreiben, wählen Sie Variablennamen, die beschreiben, wofür jedes Element steht. Verwenden Sie aussagekräftige Namen wie character, student oder score, wenn der Wert wichtig ist, um Ihren Code zu verstehen. Verwenden Sie i für einfache numerische Zähler, wenn Sie nur Iterationen zählen. Verwenden Sie _ (Unterstrich), wenn Sie den Wert überhaupt nicht benötigen—das ist eine Python-Konvention und bedeutet „Dieser Wert ist mir egal“.

Hier ist ein praktisches Beispiel, das Vokale in einem Wort zählt:

# Vokale in einem Wort zählen
word = "Python"
vowel_count = 0
 
for letter in word:
    if letter in "aeiouAEIOU":
        vowel_count += 1
        print(f"Found vowel: {letter}")
 
print(f"Total vowels: {vowel_count}")

Output:

Found vowel: o
Total vowels: 1

Die Schleife untersucht jeden Buchstaben in "Python". Wenn sie einen Vokal findet (mit dem in-Operator, den wir in Kapitel 7 gelernt haben), erhöht sie den Zähler und gibt eine Meldung aus. Dieses Muster—einen Zähler vor der Schleife zu initialisieren und ihn dann innerhalb zu aktualisieren—ist in der Programmierung extrem verbreitet.

Hier ist ein weiteres Beispiel, das Akkumulation zeigt, indem es ein Ergebnis aufbaut:

# Großbuchstaben in einem String zählen
text = "Python Programming"
uppercase_count = 0
 
for char in text:
    if char.isupper():
        uppercase_count += 1
 
print(f"Found {uppercase_count} uppercase letters in '{text}'")

Output:

Found 2 uppercase letters in 'Python Programming'

Dieses Beispiel zeigt das Akkumulationsmuster: Wir initialisieren vor der Schleife einen Zähler mit null, untersuchen dann jedes Zeichen und erhöhen den Zähler, wenn wir einen Großbuchstaben finden. Nachdem die Schleife abgeschlossen ist, verwenden wir das akkumulierte Ergebnis. Dieses Muster taucht ständig in der Programmierung auf—Elemente zählen, die bestimmte Kriterien erfüllen, Werte summieren oder Ergebnisse Schritt für Schritt aufbauen.

12.1.2) Iteration verstehen

Iteration (iteration) ist der Prozess, eine Aktion für jedes Element in einer Sammlung zu wiederholen. Wenn wir sagen, ein Objekt ist iterierbar (iterable), meinen wir, dass Python seine Elemente in einer for-Schleife nacheinander verarbeiten kann. Strings sind iterierbar—wir können über ihre Zeichen iterieren. Wie wir gleich sehen werden, sind viele andere Python-Typen ebenfalls iterierbar.

Die Variable in einer for-Schleife (wie character oder letter in unseren Beispielen) heißt Schleifenvariable (loop variable). Diese Variable wird automatisch von der for-Schleife erzeugt und existiert nur innerhalb des Gültigkeitsbereichs der Schleife. Bei jedem Durchlauf der Schleife weist Python der Variable das nächste Element aus der Sequenz zu.

Hier ist ein Beispiel, das zeigt, wie sich die Schleifenvariable ändert:

# Zeigen, wie sich die Schleifenvariable aktualisiert
colors = "RGB"  # Rot, Grün, Blau
for color_code in colors:
    print(f"Processing color code: {color_code}")
    print(f"  This is iteration for '{color_code}'")

Output:

Processing color code: R
  This is iteration for 'R'
Processing color code: G
  This is iteration for 'G'
Processing color code: B
  This is iteration for 'B'

Bei jedem Durchlauf enthält color_code ein anderes Zeichen aus dem String. Die Schleife geht automatisch zum nächsten Zeichen weiter—wir müssen keinen Code schreiben, um durch die Sequenz voranzuschreiten.

12.1.3) Die for-Schleife vs while-Schleife für Iteration

Wir könnten dieselbe Verarbeitung Zeichen für Zeichen auch mit einer while-Schleife erledigen, aber das erfordert mehr Code und manuelle Verwaltung:

# Mit while-Schleife über einen String iterieren (komplexer)
name = "Alice"
index = 0
while index < len(name):
    character = name[index]
    print(character)
    index += 1  # Den Index müssen Sie manuell aktualisieren

Das erzeugt dieselbe Ausgabe wie unser früheres for-Schleifen-Beispiel, aber beachten Sie, was wir dafür tun mussten:

• Eine Index-Variable erstellen und initialisieren
• Die Bedingung index < len(name) bei jeder Iteration prüfen
• Das Zeichen manuell mit name[index] extrahieren
• Daran denken, den Index zu erhöhen (wenn Sie das vergessen, entsteht eine Endlosschleife!)

Die for-Schleife erledigt all das automatisch:

# Mit for-Schleife über einen String iterieren (einfacher)
name = "Alice"
for character in name:
    print(character)

Das ist deutlich sauberer und weniger fehleranfällig. Die for-Schleife ist die natürliche Wahl, wenn Sie jedes Element in einer Sammlung verarbeiten möchten. Verwenden Sie eine while-Schleife, wenn Sie mehr Kontrolle über die Iterationslogik benötigen oder wenn Sie im Voraus nicht wissen, wie oft wiederholt werden soll.

12.2) range() für Zählschleifen verwenden

12.2.1) Die range()-Funktion vorstellen

Während for-Schleifen hervorragend darin sind, bestehende Sequenzen zu verarbeiten, müssen wir oft eine Aktion eine bestimmte Anzahl von Malen wiederholen—zum Beispiel eine Nachricht fünfmal ausgeben oder die ersten zehn Quadratzahlen berechnen. Pythons range()-Funktion erzeugt eine Zahlenfolge, über die wir mit einer for-Schleife iterieren können.

Die einfachste Form von range() nimmt ein Argument—die Anzahl der zu erzeugenden ganzen Zahlen, beginnend bei 0:

# Zahlen von 0 bis 4 ausgeben
for number in range(5):
    print(number)

Output:

0
1
2
3
4

⚠️ Häufiger Fehler: Anfänger erwarten oft, dass range(5) 1, 2, 3, 4, 5 erzeugt, aber tatsächlich erzeugt es 0, 1, 2, 3, 4. Merken Sie sich: range(n) startet bei 0 und endet vor n. Dieses „Ende vor“ Verhalten ist konsistent mit Pythons Slicing, das wir in Kapitel 5 kennengelernt haben. Der Bereich beginnt standardmäßig bei 0 und geht bis zum Stoppwert, aber ohne ihn einzuschließen.

Dieses Muster ist perfekt, um eine Aktion eine bestimmte Anzahl von Malen zu wiederholen:

# Eine Begrüßung fünfmal ausgeben
for i in range(5):
    print(f"Welcome! (iteration {i})")

Output:

Welcome! (iteration 0)
Welcome! (iteration 1)
Welcome! (iteration 2)
Welcome! (iteration 3)
Welcome! (iteration 4)

Die Variable i ist ein gebräuchlicher Name für einen Schleifenzähler (kurz für „index“ oder „iteration“), obwohl Sie jeden gültigen Variablennamen verwenden können. Wenn der Wert der Schleifenvariable für Ihre Logik keine Rolle spielt, ist i eine konventionelle Wahl.

12.2.2) Start- und Stoppwerte angeben

Sie können zwei Argumente an range() übergeben, um sowohl den Start als auch den Stopp festzulegen:

# Zahlen von 1 bis 5 ausgeben
for number in range(1, 6):
    print(number)

Output:

1
2
3
4
5

Hier startet range(1, 6) bei 1 und endet vor 6, wodurch wir die Zahlen 1 bis 5 erhalten. Das ist nützlich, wenn Sie ab einem anderen Wert als null zählen müssen.

Nutzen wir das, um eine einfache Multiplikationstabelle zu berechnen:

# Das 7er-Einmaleins von 1 bis 10 ausgeben
multiplier = 7
for number in range(1, 11):
    result = multiplier * number
    print(f"{multiplier} × {number} = {result}")

Output:

7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
7 × 4 = 28
7 × 5 = 35
7 × 6 = 42
7 × 7 = 49
7 × 8 = 56
7 × 9 = 63
7 × 10 = 70

Die Schleife läuft von 1 bis 10 und multipliziert jede Zahl mit 7. Das zeigt, wie range() es einfach macht, Berechnungen über eine bestimmte numerische Sequenz auszuführen.

12.2.3) Einen Schrittwert verwenden

Die range()-Funktion akzeptiert ein drittes optionales Argument: den Schrittwert (step), der festlegt, um wie viel zwischen den Zahlen erhöht (oder verringert) wird:

# Gerade Zahlen von 0 bis 10 ausgeben
for number in range(0, 11, 2):
    print(number)

Output:

0
2
4
6
8
10

Mit range(0, 11, 2) starten wir bei 0, stoppen vor 11 und erhöhen jedes Mal um 2. So erhalten wir alle geraden Zahlen von 0 bis 10.

Sie können auch einen negativen Schritt verwenden, um rückwärts zu zählen:

# Countdown von 10 bis 1
for number in range(10, 0, -1):
    print(number)
print("Liftoff!")

Output:

10
9
8
7
6
5
4
3
2
1
Liftoff!

Hier startet range(10, 0, -1) bei 10, stoppt vor 0 und verringert jedes Mal um 1. Der negative Schritt lässt den Bereich rückwärts zählen.

Sehen wir uns ein praktisches Beispiel an, das die Summe aller ungeraden Zahlen von 1 bis 100 berechnet:

# Alle ungeraden Zahlen von 1 bis 100 summieren
total = 0
for number in range(1, 101, 2):  # Start bei 1, Schrittweite 2
    total += number
 
print(f"Sum of odd numbers from 1 to 100: {total}")

Output:

Sum of odd numbers from 1 to 100: 2500

Durch die Verwendung von range(1, 101, 2) erzeugen wir nur die ungeraden Zahlen (1, 3, 5, ..., 99) und vermeiden die Notwendigkeit, die Parität jeder Zahl innerhalb der Schleife zu prüfen. Das macht den Code effizienter und die Absicht klarer.

12.2.4) Was range() tatsächlich zurückgibt

Die range()-Funktion erstellt keine Liste von Zahlen im Speicher—sie erstellt ein range-Objekt (range object), das Zahlen bei Bedarf erzeugt. Das ist speichereffizient, insbesondere bei großen Bereichen:

# range() gibt ein range-Objekt zurück, keine Liste
numbers = range(1000000)
print(type(numbers))  # Output: <class 'range'>
print(numbers)        # Output: range(0, 1000000)

Output:

<class 'range'>
range(0, 1000000)

Obwohl dieser Bereich eine Million Zahlen repräsentiert, verwendet er sehr wenig Speicher, weil Python nicht tatsächlich alle eine Million Zahlen erzeugt, bis Sie darüber iterieren. Jede Zahl wird erst dann erzeugt, wenn sie von der Schleife benötigt wird.

Wenn Sie eine echte Liste von Zahlen benötigen, können Sie den Bereich konvertieren:

# range in eine Liste umwandeln
small_numbers = list(range(5))
print(small_numbers)  # Output: [0, 1, 2, 3, 4]

Output:

[0, 1, 2, 3, 4]

Wir werden in Kapitel 14 mehr über Listen und die list()-Funktion lernen. Für den Moment reicht es zu wissen, dass range() perfekt mit for-Schleifen funktioniert, ohne dass eine Konvertierung nötig ist.

12.3) Über Strings und andere Sequenzen iterieren

12.3.1) Über Strings Zeichen für Zeichen iterieren

Wir haben bereits mehrere Beispiele gesehen, wie man über Strings iteriert. Das ist eine der häufigsten Verwendungen von for-Schleifen, weil Strings Sequenzen von Zeichen sind und wir oft jedes Zeichen einzeln untersuchen oder verarbeiten müssen.

Hier ist ein Beispiel, das ein Passwort validiert, indem geprüft wird, dass es mindestens eine Ziffer enthält:

# Prüfen, ob ein Passwort mindestens eine Ziffer enthält
password = "secure123"
has_digit = False
 
for character in password:
    if character.isdigit():
        has_digit = True
        print(f"Found digit: {character}")
 
if has_digit:
    print("Password contains at least one digit ✓")
else:
    print("Password must contain at least one digit ✗")

Output:

Found digit: 1
Found digit: 2
Found digit: 3
Password contains at least one digit ✓

Die Schleife untersucht jedes Zeichen mit der String-Methode .isdigit() (die wir in Kapitel 5 gelernt haben). Wenn sie eine Ziffer findet, setzt sie has_digit auf True. Nachdem die Schleife abgeschlossen ist, prüfen wir das Flag, um festzustellen, ob Ziffern gefunden wurden.

Hier ist ein weiteres praktisches Beispiel, das verschiedene Zeichentypen zählt:

# Zeichentypen in einem String analysieren
text = "Hello, World! 123"
letters = 0
digits = 0
spaces = 0
other = 0
 
for char in text:
    if char.isalpha():
        letters += 1
    elif char.isdigit():
        digits += 1
    elif char.isspace():
        spaces += 1
    else:
        other += 1
 
print(f"Letters: {letters}")
print(f"Digits: {digits}")
print(f"Spaces: {spaces}")
print(f"Other: {other}")

Output:

Letters: 10
Digits: 3
Spaces: 2
Other: 2

Diese Schleife kategorisiert jedes Zeichen mit String-Methoden, die wir in Kapitel 5 gelernt haben. Die if-elif-else-Kette (aus Kapitel 8) stellt sicher, dass jedes Zeichen genau einer Kategorie zugeordnet wird.

12.3.2) Strings mit Indizes verarbeiten

Manchmal benötigen Sie sowohl das Zeichen als auch seine Position im String. Sie können range(len(string)) verwenden, um über die Indizes zu iterieren:

# Positionen eines bestimmten Zeichens finden
text = "Mississippi"
search_char = "s"
 
print(f"Looking for '{search_char}' in '{text}':")
for index in range(len(text)):
    if text[index] == search_char:
        print(f"  Found at index {index}")

Output:

Looking for 's' in 'Mississippi':
  Found at index 2
  Found at index 3
  Found at index 5
  Found at index 6

Die Schleife iteriert über Indizes von 0 bis len(text) - 1. Für jeden Index prüfen wir, ob das Zeichen an dieser Position unserem Suchzeichen entspricht. Dieser Ansatz ist nützlich, wenn Sie wissen müssen, wo etwas vorkommt, nicht nur, dass es vorkommt.

12.3.3) Über andere Sequenztypen iterieren

Die for-Schleife funktioniert mit jeder iterierbaren Sequenz in Python. Während wir uns in diesem Kapitel auf Strings konzentriert haben, lernen Sie in späteren Kapiteln weitere Sequenztypen kennen. Zum Beispiel wird Kapitel 14 Ihnen Listen beibringen, also geordnete Sammlungen, die mehrere Werte beliebiger Typen enthalten können. Die for-Schleifen-Syntax bleibt gleich, unabhängig davon, über welchen Sequenztyp Sie iterieren—die Schleife kümmert sich automatisch darum, jedes Element aus der Sequenz zu holen.

12.4) break und continue in for-Schleifen verwenden

12.4.1) Die break-Anweisung in for-Schleifen

Genau wie bei while-Schleifen (Kapitel 11) beendet die break-Anweisung eine for-Schleife sofort und überspringt alle verbleibenden Iterationen. Das ist nützlich, wenn Sie gefunden haben, wonach Sie suchen, und nicht weiter suchen müssen.

Hier ist ein Beispiel, das nach einem bestimmten Zeichen sucht:

# Den ersten Vokal in einem String suchen
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"First vowel found: {char}")
        found_vowel = True
        break  # Aufhören zu suchen, sobald wir den ersten Vokal finden
 
if not found_vowel:
    print("No vowels found")

Output:

First vowel found: o

Ohne break würde die Schleife alle verbleibenden Zeichen weiter untersuchen, selbst nachdem sie den ersten Vokal gefunden hat. Die break-Anweisung macht den Code effizienter, indem sie stoppt, sobald die Aufgabe abgeschlossen ist.

Hier ist ein praktisches Beispiel, das Benutzereingaben validiert, indem es auf ungültige Zeichen prüft:

# Prüfen, ob ein Benutzername nur erlaubte Zeichen enthält
username = "alice_123"
allowed = "abcdefghijklmnopqrstuvwxyz0123456789_"
is_valid = True
 
for char in username:
    if char.lower() not in allowed:
        print(f"Invalid character found: '{char}'")
        is_valid = False
        break  # Kein weiteres Prüfen nötig
 
if is_valid:
    print(f"Username '{username}' is valid ✓")
else:
    print(f"Username '{username}' is invalid ✗")

Output:

Username 'alice_123' is valid ✓

Die Schleife prüft jedes Zeichen gegen die erlaubte Menge. Wenn sie ein ungültiges Zeichen findet, meldet sie das Problem und bricht die Schleife sofort ab—es gibt keinen Sinn, den Rest des Benutzernamens zu prüfen, sobald klar ist, dass er ungültig ist.

12.4.2) Die continue-Anweisung in for-Schleifen

Die continue-Anweisung überspringt den Rest der aktuellen Iteration und geht zum nächsten Element in der Sequenz über. Das ist nützlich, wenn Sie bestimmte Elemente überspringen wollen, ohne die Schleife vollständig zu beenden.

Hier ist ein Beispiel, das nur bestimmte Zeichen verarbeitet:

# Nur Konsonanten aus einem String ausgeben
word = "Programming"
 
for letter in word:
    if letter.lower() in "aeiou":
        continue  # Vokale überspringen
    print(letter, end="")
print()  # Neue Zeile am Ende

Output:

Prgrmmng

Wenn die Schleife auf einen Vokal trifft, überspringt continue die print()-Anweisung und geht zum nächsten Zeichen. Nur Konsonanten erreichen die Ausgabe.

Hier ist ein praktischeres Beispiel, das Statistiken berechnet und dabei ungültige Daten überspringt. Beachten Sie, dass die .split()-Methode (aus Kapitel 6) eine Liste von Strings zurückgibt, die wir in Kapitel 14 kennenlernen. Für den Moment reicht es zu wissen, dass for-Schleifen über das Ergebnis iterieren können:

# Durchschnitt gültiger Testergebnisse (0-100) berechnen
# Die .split()-Methode gibt eine Liste von Strings zurück (Kapitel 14)
scores_input = "85 92 -5 78 105 90 88"
valid_scores = 0
total = 0
 
for score_str in scores_input.split():
    score = int(score_str)
    
    if score < 0 or score > 100:
        print(f"Skipping invalid score: {score}")
        continue  # Dieses Ergebnis überspringen
    
    valid_scores += 1
    total += score
 
if valid_scores > 0:
    average = total / valid_scores
    print(f"Average of {valid_scores} valid scores: {average:.1f}")
else:
    print("No valid scores to average")

Output:

Skipping invalid score: -5
Skipping invalid score: 105
Average of 5 valid scores: 86.6

Die Schleife verarbeitet jeden Score-String. Wenn sie auf einen ungültigen Score trifft (negativ oder über 100), gibt sie eine Warnung aus und verwendet continue, um das Hinzufügen dieses Scores zur Summe zu überspringen. So kann die Schleife alle gültigen Scores verarbeiten und ungültige ignorieren.

12.4.3) Wann man break und continue verwendet

Verwenden Sie break, wenn:

• Sie nach etwas suchen und stoppen möchten, sobald Sie es gefunden haben
• Sie auf eine Fehlersituation stoßen, die ein Weitermachen sinnlos macht
• Sie Ihre Aufgabe abgeschlossen haben und die verbleibenden Elemente nicht mehr verarbeiten müssen

Verwenden Sie continue, wenn:

• Sie bestimmte Elemente anhand einer Bedingung überspringen möchten
• Sie Daten filtern und nur Elemente verarbeiten möchten, die Kriterien erfüllen
• Sie tief verschachtelte if-Anweisungen vermeiden möchten, indem Sie Sonderfälle früh behandeln

Sowohl break als auch continue können Ihren Code klarer machen, weil sie explizit zeigen, wann und warum Sie den normalen Ablauf der Iteration ändern. Wenn Sie sie jedoch zu häufig verwenden, kann Code schwerer zu verfolgen sein—nutzen Sie sie, wenn sie die Klarheit wirklich verbessern.

12.5) else mit for-Schleifen verwenden

12.5.1) Das for-else-Muster

Pythons for-Schleifen unterstützen eine optionale else-Klausel, die ausgeführt wird, nachdem die Schleife normal abgeschlossen wurde—das heißt, wenn die Schleife alle Elemente durchlaufen hat, ohne auf eine break-Anweisung zu treffen. Das mag zunächst seltsam wirken (warum „else“, wenn es kein „if“ gibt?), aber es ist nützlich, um zwischen „gefunden, wonach ich gesucht habe“ und „alles durchsucht und nicht gefunden“ zu unterscheiden.

Hier ist die grundlegende Struktur:

for item in sequence:
    # Schleifenrumpf
    if some_condition:
        break
else:
    # Dies wird nur ausgeführt, wenn die Schleife ohne break abgeschlossen wurde
    print("Loop completed normally")

Der else-Block läuft dann, und nur dann, wenn die Schleife natürlich endet, indem die Sequenz vollständig abgearbeitet wird. Wenn eine break-Anweisung die Schleife vorzeitig beendet, wird der else-Block übersprungen.

Sehen wir uns ein praktisches Beispiel an, das nach einem bestimmten Wert sucht. Die .split()-Methode (aus Kapitel 6) gibt eine Liste von Strings zurück, die wir in Kapitel 14 kennenlernen:

# Nach einer Zielzahl suchen
numbers = "2 4 6 8 10"
target = 7
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

7 not found in the sequence

Die Schleife durchsucht alle Zahlen. Da sie die 7 nie findet, endet sie normal und der else-Block wird ausgeführt. Jetzt suchen wir nach einer Zahl, die vorhanden ist:

# Nach einer vorhandenen Zielzahl suchen
numbers = "2 4 6 8 10"
target = 6
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

Found 6!

Dieses Mal führt die Schleife, wenn sie die 6 findet, break aus, wodurch der else-Block vollständig übersprungen wird. Dieses Muster behandelt elegant sowohl den Fall „gefunden“ als auch „nicht gefunden“, ohne dass eine separate Flag-Variable nötig ist.

12.5.2) Praktische Verwendungen von for-else

Das for-else-Muster ist besonders nützlich für Suchoperationen. Hier ist ein Beispiel, das validiert, ob ein String nur Ziffern enthält:

# Prüfen, ob ein String eine gültige Ganzzahl ist
user_input = "12345"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

'12345' is a valid integer

Wenn die Eingabe ein Nicht-Ziffernzeichen enthält, bricht die Schleife ab und der else-Block wird nicht ausgeführt. Wenn alle Zeichen Ziffern sind, endet die Schleife normal und der else-Block bestätigt die Gültigkeit.

Testen wir mit ungültiger Eingabe:

# Prüfen, ob ein String eine gültige Ganzzahl ist (ungültiger Fall)
user_input = "123a5"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

Invalid: 'a' is not a digit

12.5.3) for-else mit Flag-Variablen vergleichen

Bevor Sie for-else kennenlernen, hätten Sie vielleicht eine Flag-Variable verwendet, um zu verfolgen, ob etwas gefunden wurde:

# Verwendung einer Flag-Variable (traditioneller Ansatz)
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        found_vowel = True
        break
 
if not found_vowel:
    print("No vowels found")

Output:

Found vowel: o

Das for-else-Muster macht die Flag-Variable überflüssig:

# Verwendung von for-else (Pythonischer)
text = "Python"
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        break
else:
    print("No vowels found")

Output:

Found vowel: o

Beide Ansätze funktionieren korrekt, aber die for-else-Version ist knapper und drückt die Absicht klar aus: „Suche nach etwas, und wenn du es nicht findest, tue dies.“ Die else-Klausel steht direkt für den „nicht gefunden“-Fall.

12.6) Zwischen for- und while-Schleifen wählen

12.6.1) Wann man eine for-Schleife verwendet

Verwenden Sie eine for-Schleife, wenn:

1. Sie jedes Element in einer Sammlung verarbeiten:

# Jedes Zeichen in einem String verarbeiten
message = "Hello"
for char in message:
    print(char.upper())

Output:

H
E
L
L
O

2. Sie eine Aktion eine bestimmte Anzahl von Malen wiederholen müssen:

# Eine Rahmenlinie ausgeben
for i in range(40):
    print("-", end="")
print()

Output:

----------------------------------------

3. Sie über einen numerischen Bereich iterieren:

# Fakultät von 5 berechnen
factorial = 1
for n in range(1, 6):
    factorial *= n
print(f"5! = {factorial}")

Output:

5! = 120

4. Sie im Voraus wissen, worüber Sie iterieren:

# Eine bekannte Folge von Werten verarbeiten
grades = "A B C D F"
for grade in grades.split():
    print(f"Grade: {grade}")

Output:

Grade: A
Grade: B
Grade: C
Grade: D
Grade: F

Das zentrale Merkmal von for-Schleifen ist, dass sie mit bestimmter Iteration (definite iteration) arbeiten—Sie wissen, über welche Sequenz Sie iterieren, auch wenn Sie im Voraus nicht wissen, wie viele Elemente sie enthält.

12.6.2) Wann man eine while-Schleife verwendet

Verwenden Sie eine while-Schleife, wenn:

1. Sie wiederholen, bis sich eine Bedingung ändert:

# So lange fragen, bis eine gültige Eingabe erfolgt
while True:
    age_input = input("Enter your age: ")
    if age_input.isdigit():
        age = int(age_input)
        if age > 0:
            print(f"Age recorded: {age}")
            break
    print("Please enter a valid positive number")

2. Sie nicht wissen, wie viele Iterationen Sie brauchen:

# Zählen, wie oft man eine Zahl verdoppeln kann, bevor sie 1000 überschreitet
number = 1
count = 0
while number <= 1000:
    number *= 2
    count += 1
print(f"Doubled {count} times to reach {number}")

Output:

Doubled 10 times to reach 1024

3. Die Iteration von komplexen Bedingungen abhängt:

# Ein einfaches Spiel simulieren, bei dem die Gesundheit des Spielers sinkt
health = 100
turn = 0
 
while health > 0 and turn < 10:
    damage = 15
    health -= damage
    turn += 1
    print(f"Turn {turn}: Health = {health}")
 
if health <= 0:
    print("Game over!")
else:
    print("Survived 10 turns!")

Output:

Turn 1: Health = 85
Turn 2: Health = 70
Turn 3: Health = 55
Turn 4: Health = 40
Turn 5: Health = 25
Turn 6: Health = 10
Turn 7: Health = -5
Game over!

4. Sie mehr Kontrolle über die Iterationslogik benötigen:

# Einen String verarbeiten, aber aufeinanderfolgende Duplikate überspringen
text = "bookkeeper"
index = 0
 
while index < len(text):
    char = text[index]
    print(char, end="")
    
    # Aufeinanderfolgende identische Zeichen überspringen
    while index < len(text) and text[index] == char:
        index += 1
 
print()

Output:

bokeper

Das zentrale Merkmal von while-Schleifen ist unbestimmte Iteration (indefinite iteration)—Sie machen weiter, bis eine Bedingung falsch wird, aber Sie wissen möglicherweise im Voraus nicht, wann das passieren wird.

12.6.3) Zwischen for und while umwandeln

Viele Probleme lassen sich mit beiden Schleifentypen lösen. Hier ist dieselbe Aufgabe auf beide Arten implementiert:

# Mit for-Schleife: Zahlen von 1 bis 10 summieren
total = 0
for number in range(1, 11):
    total += number
print(f"Sum (for loop): {total}")
 
# Mit while-Schleife: Zahlen von 1 bis 10 summieren
total = 0
number = 1
while number <= 10:
    total += number
    number += 1
print(f"Sum (while loop): {total}")

Output:

Sum (for loop): 55
Sum (while loop): 55

Beide liefern dasselbe Ergebnis, aber die for-Schleife ist knapper und weniger fehleranfällig—es besteht kein Risiko, zu vergessen, den Zähler zu erhöhen. Wenn Sie beides verwenden können, bevorzugen Sie die for-Schleife.

Allerdings lassen sich manche Probleme natürlicher mit while ausdrücken:

# Die erste Potenz von 2 finden, die größer als 1000 ist
power = 1
exponent = 0
 
while power <= 1000:
    exponent += 1
    power = 2 ** exponent
 
print(f"2^{exponent} = {power} (first power of 2 > 1000)")

Output:

2^10 = 1024 (first power of 2 > 1000)

Dieses Problem passt nicht natürlich in eine for-Schleife, weil wir im Voraus nicht wissen, wie viele Iterationen wir brauchen—wir suchen nach einem Wert, der eine Bedingung erfüllt.

In diesem Kapitel haben wir Pythons for-Schleife erforscht, die eine saubere und leistungsfähige Möglichkeit bietet, über Sequenzen zu iterieren. Wir haben gelernt, wie range() numerische Sequenzen für Zähloperationen erzeugt, wie man den Schleifenfluss mit break und continue steuert und wie das for-else-Muster Suchoperationen elegant handhabt. Außerdem haben wir untersucht, wann man for-Schleifen gegenüber while-Schleifen wählt—abhängig von der Art Ihrer Iterationsaufgabe.

Die for-Schleife ist eines der am häufigsten verwendeten Features von Python. Während Sie weiter Python lernen, werden Sie for-Schleifen ständig verwenden—Daten aus Dateien verarbeiten, mit Listen und Dictionaries arbeiten und Sammlungen von Informationen transformieren. Im nächsten Kapitel werden wir Pythons match-Anweisung betrachten, die eine weitere Möglichkeit bietet, Entscheidungen auf Basis von Werten zu treffen, und für bestimmte Problemtypen eine strukturiertere Alternative zu langen if-elif-Ketten darstellt.