Was ist Iteration?

Ein Programm, das 10.000 Nutzern eine Erinnerungs-E-Mail schickt, enthält nicht 10.000 Kopien des Sendecodes. Es enthält den Code einmal, in einer Schleife, und die Schleife führt ihn einmal pro Nutzer aus. Jeder Durchlauf ist eine Iteration, und die Schleife als Ganzes ist die Art, wie das Programm über seine Nutzer iteriert.

Wie Iteration funktioniert, Schritt für Schritt

Jede Schleife folgt demselben Zyklus:

1. Prüfen. Teste die Bedingung der Schleife, einen Boolean: Gibt es noch ein Element, oder liegt der Zähler noch unter dem Limit?
2. Ausführen. Ist die Antwort wahr, führe den Schleifenrumpf einmal aus.
3. Aktualisieren. Geh zum nächsten Element oder ändere den Zähler.
4. Wiederholen. Zurück zu Schritt 1. Ergibt die Prüfung falsch, macht das Programm mit dem Code nach der Schleife weiter.

Hier läuft der Rumpf fünfmal, und jede Iteration addiert die nächste Zahl zu einer laufenden Summe:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

Die Variable total liegt außerhalb der Schleife, also behält sie ihren Wert von einer Iteration zur nächsten. Dieses Muster, eine Variable, die vor der Schleife gesetzt und in ihr aktualisiert wird, heißt Akkumulator, und es taucht in fast jeder Schleife auf, die etwas berechnet.

Zählschleifen und Bedingungsschleifen

Es gibt zwei Arten von Iteration. Bestimmte Iteration läuft eine bekannte Anzahl von Malen: einmal pro Element einer Liste oder einmal für jede Zahl von 1 bis 5. Pythons for-Schleife ist dafür gebaut, oft zusammen mit range().

Unbestimmte Iteration wiederholt sich, bis etwas eintritt, und die Anzahl der Durchläufe steht vorher nicht fest. Dafür passt eine while-Schleife:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Geld, das um 10 % pro Jahr wächst, braucht 8 Jahre, um sich zu verdoppeln. Das Programm hat das durch Iterieren herausgefunden, nicht durch das Lösen einer Gleichung. Die Anleitungen zu for-Schleifen und while-Schleifen behandeln beide in Python.

Über eine Sammlung iterieren

Die meisten Schleifen durchlaufen eine Sammlung: die Elemente eines Arrays, die Zeichen eines Strings, die Zeilen einer Datei. Pythons for-Schleife gibt dir jedes Element direkt, und enumerate() fügt seine Position hinzu:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Im Hintergrund holt sich for mit iter() einen Iterator von der Sammlung und ruft dann pro Iteration einmal next() darauf auf. Diese Aufrufe kannst du auch selbst machen:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Ohne den Standardwert löst das vierte next() eine StopIteration aus. Diese Exception ist das Signal, an dem eine for-Schleife erkennt, dass die Sammlung zu Ende ist.

Andere Sprachen schreiben dieselbe Idee anders. C zählt mit einem Index, während Java und JavaScript auch eine Schleife haben, die dir jedes Element direkt gibt:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iteration und Rekursion

Rekursion ist der andere Weg, Arbeit zu wiederholen: Eine Funktion ruft sich selbst mit einer kleineren Version des Problems auf, bis sie einen Fall erreicht, den sie direkt beantworten kann. Alles, was mit dem einen geschrieben ist, lässt sich mit dem anderen schreiben, aber sie verhalten sich unterschiedlich:

Die Speicherzeile zählt in der Praxis. Python erlaubt standardmäßig etwa 1.000 verschachtelte Aufrufe, also scheitert eine rekursive Summe über 5.000 Zahlen, wo eine Schleife kein Problem hat:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

Die Visualisierung der Rekursion zeigt Schritt für Schritt, wie der Stapel der Aufrufe wächst und schrumpft.

Typische Fehler

Die Endlosschleife. Eine while-Schleife, deren Bedingung nie falsch wird, läuft, bis du das Programm stoppst. Die übliche Ursache ist ein vergessener Aktualisierungsschritt, etwa ein fehlendes count = count - 1.

Um eins daneben (off by one). range(1, 5) liefert 1, 2, 3 und 4, nicht 5, weil der Endwert ausgeschlossen ist. Eine Schleife, die einmal zu oft oder zu selten läuft, läuft trotzdem ohne Fehlermeldung und liefert eine falsche Antwort, also einen Logikfehler.

Eine Liste ändern, während du sie durchläufst. Wenn du Elemente aus der Liste entfernst, über die du gerade iterierst, überspringt die Schleife Elemente:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Eine 2 hat überlebt, weil das Entfernen der ersten 2 die zweite an eine Position verschoben hat, an der die Schleife schon vorbei war. Bau stattdessen eine neue Liste: numbers = [n for n in numbers if n != 2].

Wie es weitergeht

Schleifen durchlaufen Sammlungen, also ist was ein Array ist die passende Begleitseite, und was ein Boolean ist erklärt die Wahr-oder-falsch-Prüfungen, die entscheiden, wann eine Schleife endet. Wenn eine Schleife ohne Fehlermeldung ein falsches Ergebnis liefert, lies, was ein Logikfehler ist. Um das Schreiben von Schleifen zu üben, starte den Python-Kurs oder probier die Beispiele oben im Python Playground aus.