Schleifen in Python

Eine Schleife wiederholt einen Codeblock. Jeder Durchlauf durch den Block ist ein Schleifendurchlauf. Eine while-Schleife prüft vor jedem Durchlauf eine Bedingung und führt ihren Körper aus, solange diese Bedingung wahr ist. Das passt zu einer Aufgabe wie „Addiere weiter, bis die Summe 100 erreicht“.

Starten, prüfen und aktualisieren

Eine Zählschleife braucht einen Startwert, eine Bedingung und eine Aktualisierung. Die Kopfzeile endet mit einem Doppelpunkt. Rücke den Körper um vier Leerzeichen ein:

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

Die Ausgabe lautet:

3
2
1
Liftoff!

Bei der ersten Prüfung ist n > 0 wahr, weil n gleich 3 ist. Python gibt 3 aus, subtrahiert 1 und kehrt zur Kopfzeile zurück. Das wiederholt sich mit 2 und dann mit 1. Durch die Aktualisierung wird n gleich 0, sodass die nächste Prüfung falsch ist. Python überspringt den Körper und führt das letzte print aus.

Die Einrückung bestimmt, was wiederholt wird. Beide eingerückten Zeilen gehören zum Körper. Die letzte Zeile steht auf Höhe von while, wird also einmal nach der Schleife ausgeführt. Ein if prüft seine Bedingung einmal; while kehrt nach jedem vollständig ausgeführten Körper zur erneuten Prüfung zurück.

Die Prüfung erfolgt am Anfang

Die Änderung einer Variablen unterbricht den Rest des aktuellen Körpers nicht:

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

Dies gibt Still in this pass und dann 0 in getrennten Zeilen aus. Die Aktualisierung macht die Bedingung falsch, aber Python prüft sie erst, wenn es zur Kopfzeile zurückkehrt. Ein Start mit n = 0 würde dagegen den gesamten Körper überspringen: Eine while-Schleife kann nullmal ausgeführt werden.

Kurze Aktualisierungen und veränderliche Werte

n -= 1 bedeutet n = n - 1. Entsprechend addiert count += 1 den Wert 1, balance *= 1.07 multipliziert mit 1,07 und n //= 10 ersetzt n durch den ganzzahligen Quotienten bei Division durch 10. Python hat keinen Inkrementoperator: count++ ist ein Syntaxfehler. ++count wendet das unäre Plus zweimal an und lässt die ganze Zahl unverändert.

Hier entfernt eine Schleife bei jedem Durchlauf eine Ziffer:

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

Der Rest n % 10 ist die letzte Ziffer. Zuerst wird 2 addiert und n wird zu 47. Danach wird 7 addiert und n wird zu 4. Schließlich wird 4 addiert und n wird zu 0. Die Ausgabe ist 13. Die Aktualisierung bereitet sowohl den nächsten Durchlauf vor als auch den Weg zum Ausgang.

Bei einer Schleife mit Zielwert muss die Anzahl der Durchläufe nicht im Voraus bekannt sein. Beginnend mit einem Guthaben von 1000 dauert es 11 Durchläufe, bis es durch Multiplikation mit 1,07 und Erhöhung eines Jahreszählers 2000 erreicht. Nach 10 Durchläufen beträgt das Guthaben etwa 1967,15; nach 11 etwa 2104,85.

Bedingungen können Vergleiche mit and, or und not verknüpfen. Auch die Wahrheitswertauswertung funktioniert: Bei einer ganzen Zahl wiederholt while n: die Schleife, solange n ungleich null ist. Verwende eine Bedingung, deren Bedeutung leicht nachzuvollziehen ist. Rücke einheitlich mit Leerzeichen ein; nicht zusammenpassende Ebenen können einen IndentationError und gemischte Tabulatoren und Leerzeichen einen TabError auslösen.

Eine Endlosschleife wiederholt sich, ohne einen Ausgang zu erreichen. Möglicherweise läuft dieselbe Ausgabe ständig weiter oder ein Programm scheint nichts zu tun. Um die Ursache zu finden, verfolge die Werte in der Bedingung und suche nach einem erreichbaren Ausgang.

Die Aktualisierung finden

Diese Schleife gibt immer wieder 3 aus:

n = 3
while n > 0:
    print(n)

Die Prüfung bleibt wahr, weil nichts den Wert von n ändert. Füge n -= 1 innerhalb des Körpers hinzu, damit die Werte 3, 2 und 1 ausgegeben werden, bevor die Schleife endet. Die Aktualisierung nach die Schleife zu setzen hilft nicht: Das Programm kann sie nicht erreichen, solange die Schleife noch läuft.

Auch die Richtung ist wichtig. Bei while n > 0: lässt eine Aktualisierung mit n += 1 einen positiven Wert wachsen. Ganze Zahlen in Python springen bei einem festen Maximum nicht über und bieten daher keinen zufälligen Ausgang. Benenne die erwartete Änderung, etwa „ein verbleibender Versuch weniger“, und prüfe, ob der Code diese Änderung auf jedem Weg durch den Körper ausführt.

Ein Zielwert kann verfehlt werden

Eine Aktualisierung kann den Wert bei jedem Durchlauf ändern und dennoch einen Zielwert, auf den mittels Gleichheit geprüft wird, nie erreichen:

n = 1
while n != 10:
    print(n)
    n += 2

Die Werte lauten 1, 3, 5, 7, 9, 11 und so weiter. Sie sind immer ungerade, sodass keiner gleich 10 ist. Verwende für die Aufgabe „Gib ungerade Werte unter 10 aus“ die Bedingung while n < 10:. Sobald n zu 11 wird, ist diese Bedingung falsch. Der gewählte Vergleich muss dazu passen, ob die Aufgabe bei einem Wert endet oder wenn eine Grenze überschritten wird.

Dezimalschritte und exakte Gleichheit

Viele Dezimalbrüche werden als Gleitkommazahlen näherungsweise gespeichert. Addiert man zehnmal 0.1 zu 0.0, ergibt sich 0.9999999999999999. Eine Schleife, die auf exakte Gleichheit mit 1.0 wartet, verfehlt daher ihren beabsichtigten Endpunkt.

Wenn die Aufgabe darin besteht, eine feste Folge von Zehnteln zu durchlaufen, zähle mit ganzen Zahlen und berechne jede Dezimalzahl:

for i in range(11):
    x = i / 10
    print(x)

Dies durchläuft 11 Werte von 0.0 bis 1.0. Der ganzzahlige Zähler steuert die Wiederholungen; die gespeicherte Dezimalzahl entscheidet nicht darüber, ob die Schleife endet.

Jeden Weg durch den Körper prüfen

Suche vor dem Ausführen einer while-Schleife ihre Startwerte, ihre Bedingung und jede Anweisung, die diese Werte ändert. Prüfe, ob die Änderung die Bedingung falsch machen kann. Überspringt ein if eine Aktualisierung, vollziehe auch diesen Weg nach. Eine vorübergehende Zeile wie print("n =", n) innerhalb des Körpers kann zeigen, dass ein Wert feststeckt oder sich von der Grenze entfernt.

Um ein laufendes Programm zu unterbrechen, drücke Strg+C in einem Terminal oder verwende die Schaltfläche zum Stoppen oder Unterbrechen im Editor. In einem Terminal meldet Python normalerweise KeyboardInterrupt mit einem Traceback.

Absichtliche Wiederholung

while True: hält seine Bedingung im Schleifenkopf absichtlich wahr. Der Körper verwendet break, um die Schleife bei einem Ereignis zu verlassen, etwa wenn der Benutzer „quit“ eingibt. Der Ausgang muss erreichbar sein. Eine Eingabeschleife kann weiter warten, weil der Benutzer das Beenden noch nicht angefordert hat; ein Programmfehler liegt vor, wenn die Logik der Schleife den beabsichtigten Ausgang unmöglich macht.

Eine Eingabeschleife kann eine unbekannte Datenmenge erfassen oder so lange erneut fragen, bis eine Antwort akzeptabel ist. In beiden Fällen muss die neue Eingabe die nächste Entscheidung über eine Wiederholung beeinflussen.

Bei einem Sentinelwert stoppen

Ein Sentinelwert ist eine besondere Eingabe, die „keine weiteren Daten“ bedeutet. Wähle einen Wert, der kein echtes Datenelement sein kann. Für positive Anzahlen kann 0 funktionieren; ist 0 ein gültiger Messwert, wähle ein anderes Stoppsignal.

Das vorbereitende Einlesen holt den ersten Wert, bevor die Bedingung geprüft wird:

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

Bei den Eingaben 4, 7 und 0 addiert der Körper zuerst 4 und dann 7. Das Einlesen von 0 macht die nächste Bedingung falsch. Das Programm gibt Total: 11 aus; es verarbeitet den Sentinelwert nicht. Ist die erste Eingabe 0, wird der Körper nullmal ausgeführt und die Summe bleibt 0.

Das letzte Einlesen innerhalb des Körpers ist wesentlich. Ohne dieses wird derselbe erste Wert endlos verarbeitet. Die Prüfung muss auch vor der Verarbeitung eines neu gelesenen Werts erfolgen: Andernfalls kann ein Sentinelwert als Datum gezählt werden.

Datentypen aufeinander abstimmen

input() gibt Text zurück. Die Zeichenkette "0" ist nicht gleich der ganzen Zahl 0. Wandle eine numerische Eingabe mit int() um, bevor du sie mit einem numerischen Sentinelwert vergleichst, oder behalte die Eingabe als Text und vergleiche sie mit einer Zeichenkette wie "done". Eine Umwandlung in eine Zahl erwartet eine gültige numerische Zeichenkette; eine Bereichsprüfung prüft die daraus entstehende Zahl.

Für ein arithmetisches Mittel führe neben der Summe einen Zähler. Beim Sentinelwert -1 und den Eingaben 8, 6, 10 und -1 ist die Summe 24 und die Anzahl 3. Dividiere nach der Schleife, um 8.0 zu erhalten. Ist die erste Eingabe -1, bleibt die Anzahl 0. Verwende daher vor der Division if count > 0:. So behandelst du einen leeren Datensatz ohne ZeroDivisionError.

Erneut fragen, solange eine Antwort ungültig ist

Eine Validierungsschleife beschreibt die nicht akzeptablen Antworten in ihrer Bedingung:

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

Bei 150, -2 und 34 erscheint die Warnung zweimal. Der Wert 34 macht beide Vergleiche falsch, sodass die Schleife endet. Auch die Randwerte 0 und 120 werden akzeptiert.

Das Wort or ist entscheidend: Ein Alter ist ungültig, wenn es unter dem Minimum oder über dem Maximum liegt. age < 0 and age > 120 würde nichts zurückweisen, weil eine Zahl nicht beides sein kann.

Für eine Ja-Nein-Antwort lautet die Prüfung auf Ungültigkeit answer != "y" and answer != "n". Eine Antwort muss sich von beiden akzeptierten Zeichenketten unterscheiden, um zurückgewiesen zu werden. Mit or würde selbst "y" zu einer Wiederholung führen, weil es sich von "n" unterscheidet. Vollziehe eine akzeptable und eine nicht akzeptable Antwort nach, um eine solche Bedingung zu prüfen.

Für dieselben Aufgaben lässt sich while True mit einem Einlesen im Körper verwenden, gefolgt von einer Abbruchprüfung und break. So steht die Entscheidung direkt nach der Eingabe und das Einlesen muss nicht zweimal geschrieben werden.

Eine for-Schleife durchläuft die Elemente einer Sequenz der Reihe nach. Bei jedem Durchlauf weist Python das nächste Element der Schleifenvariablen zu und führt den eingerückten Körper aus. Eine Schleife über eine Sequenz heißt oft Schleife mit bestimmter Anzahl von Durchläufen, weil die Elemente ihren Arbeitsumfang festlegen.

Ein Element nach dem anderen

Eine Zeichenkette ist eine Sequenz von Zeichen:

for ch in "cat":
    print(ch)

Dies gibt c, a und t in getrennten Zeilen aus. Auch Leerzeichen und Satzzeichen zählen als Zeichen. Die Zeichenkette "hi there" hat einschließlich ihres Leerzeichens acht Zeichen, sodass das Durchlaufen aller Zeichen acht Durchläufe benötigt.

Eine Liste enthält eine Sequenz von Werten. Ihre Literalform verwendet eckige Klammern und Kommas:

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

Die Ausgabe lautet 6, 82 und 24, jeweils in einer eigenen Zeile. score enthält jeweils eine Zahl, nicht die ganze Liste und nicht ihre Position. Um von 3 zu 41 und zu 12 zu gelangen, muss kein Zähler von Hand aktualisiert werden.

Verwende einen Namen, der ein einzelnes Element beschreibt: name in names oder score in scores. Benötigt der Körper den aktuellen Wert nie, ist _ ein üblicher Name für diese ungenutzte Schleifenvariable.

Eine Zuweisung ersetzt kein Element

Die Schleifenvariable ist eine gewöhnliche Variable. Wenn du ihr eine andere Zahl zuweist, ersetzt das nicht die Zahl in der Liste:

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

Der Körper gibt 10, 20 und 30 aus. Bei jedem neuen Durchlauf wird n das nächste Element aus der unveränderten Liste zugewiesen. Die letzte Ausgabezeile lautet [1, 2, 3]: Die Liste selbst hat sich nicht geändert. Nach der Schleife behält n den Wert 30, den letzten im Körper zugewiesenen Wert.

Eine leere Sequenz gibt dem Körper keine Arbeit. Bei for ch in "": gibt es null Durchläufe und die Schleife weist ch keinen Wert zu. Verlass dich nicht darauf, dass eine Schleife ihre Variable erstellt, wenn möglicherweise keine Elemente vorhanden sind.

Zugehörigkeit innerhalb einer Schleife

In einem for-Kopf leitet in die zu durchlaufende Sequenz ein. In einer Bedingung prüft es die Zugehörigkeit und ergibt True oder False. Beide Verwendungen können zusammenwirken:

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Jedes Zeichen wird durchlaufen, aber der Zähler ändert sich nur bei e, u, a, i und o. Die Ausgabe ist 5. Das if ist innerhalb der Schleife eingerückt und die Aktualisierung des Zählers innerhalb des if.

Diese Schleife zeigt auch, warum eine Schleifenvariable und ein Zähler verschiedene Aufgaben haben. ch enthält das aktuelle Zeichen; vowels hält fest, wie viele Zeichen die Bedingung bisher erfüllt haben. Der Zähler wird vor der Schleife initialisiert, damit er sein Ergebnis zwischen den Durchläufen behält.

Eine einzelne ganze Zahl kann keine Elemente liefern: for i in 5: löst TypeError aus. Um eine Aktion fünfmal zu wiederholen, schreibe for _ in range(5):. Der Zahlenbereich liefert die Schritte, auch wenn der Körper deren Werte nicht verwendet.

Ein Zahlenbereich (range) beschreibt ganze Zahlen mit gleichmäßigen Abständen. Er ist nützlich, um Arbeit eine festgelegte Anzahl von Malen zu wiederholen, vorwärts oder rückwärts zu zählen und regelmäßige Schritte auszuwählen. Seine Endgrenze ist immer ausgeschlossen.

Drei Formen

Bei einem Argument ist dieses die Endgrenze. Bei zwei Argumenten sind es Startwert und Endgrenze. Bei drei Argumenten ist das letzte die Schrittweite, die nach jedem Wert addiert wird. range(0, 10, 3) durchläuft 0, 3, 6 und 9; der nächste Schritt würde 12 erreichen, deshalb wird dieser Wert nicht geliefert.

Die Endgrenze bleibt auch dann ausgeschlossen, wenn ein Schritt genau auf ihr landen könnte. range(0, 10, 5) liefert nur 0 und 5. Bei der positiven Standardschrittweite 1 und einer Endgrenze über dem Startwert ist die Anzahl der gelieferten Werte gleich Endgrenze minus Startwert.

Mit negativer Schrittweite rückwärtszählen

range(5, 0, -1) liefert 5, 4, 3, 2 und 1. Um 0 einzuschließen, setze die Endgrenze darunter: range(5, -1, -1) liefert sechs Werte und endet bei 0.

Die Richtung muss zu den Grenzen passen. range(5, 0) ist leer, weil seine Standardschrittweite positiv ist. Auch range(1, 5, -1) ist leer, weil der Zahlenbereich unter der Endgrenze beginnt, aber abwärtsläuft. Leere Zahlenbereiche sind gültig und führen zu null Durchläufen; eine Schrittweite von null löst dagegen ValueError aus.

Den letzten benötigten Wert innerhalb der Grenze halten

Um die geraden ganzen Zahlen von 2 bis 20 zu addieren:

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

Die Endgrenze 21 ermöglicht, dass 20 durchlaufen wird. Die zehn Werte ergeben zusammen 110, sodass das Programm 110 ausgibt. Mit der Endgrenze 20 würde 20 ausgelassen und es ergäbe sich 90.

Lass für ein Einmaleins den Zahlenbereich die Faktoren liefern:

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

Die erste Ausgabezeile lautet 7 x 1 = 7 und die zehnte 7 x 10 = 70. Wenn die Zahl selbst nicht verwendet wird, kann for _ in range(3): eine Meldung dreimal wiederholen.

Einen Zahlenbereich untersuchen und seine Argumente prüfen

list(range(2, 6)) erzeugt [2, 3, 4, 5], was beim Prüfen der Grenzen hilfreich ist. len(range(0, 10, 3)) ist 4. Ein Zahlenbereich speichert seine definierenden Grenzen und seine Schrittweite, statt eine Liste mit jeder ganzen Zahl zu erstellen.

Die Argumente sind ganze Zahlen, darunter null und negative ganze Zahlen: range(-3, 3) durchläuft -3 bis 2. Eine Gleitkommazahl wie 3.0 wird mit TypeError zurückgewiesen, obwohl sie keinen Nachkommaanteil hat. Eine als Text eingegebene Anzahl kann zuerst mit n = int(input("How many? ")) umgewandelt und dann in range(n) verwendet werden.

Wähle eine Schleife, indem du fragst, was die Wiederholung steuert. Gibt es eine Sequenz von Elementen oder eine Anzahl von Wiederholungen, drückt for die Aufgabe meist direkt aus. Hängt die nächste Wiederholung von einer veränderlichen Bedingung oder einer zukünftigen Eingabe ab, setzt while diese Entscheidung in seinen Schleifenkopf.

Festgelegte Elemente oder eine veränderliche Bedingung

Eine Anzahl muss nicht als Literal im Programm stehen. Nachdem n eingelesen wurde, liefert range(n) weiterhin eine festgelegte Folge von Schritten. Eine Schleife mit unbestimmter Anzahl von Durchläufen wartet auf eine Bedingung, deren Endpunkt nicht als Anzahl von Wiederholungen festgelegt ist.

Eine große Anzahl von Wiederholungen zu schätzen, passt schlecht zu „bis zum Ende“. Eine Schleife über range(1000) kann ihre Versuche aufbrauchen, bevor der Benutzer fertig ist, und eine Version ohne Abbruchprüfung läuft nach Abschluss der Aufgabe weiter.

Eine Zählschleife umschreiben

Diese beiden Schleifen geben 1 bis 5 aus, jede Zahl in einer eigenen Zeile:

for i in range(1, 6):
    print(i)

i = 1
while i < 6:
    print(i)
    i += 1

In der while-Version wird der Startwert des Zahlenbereichs zur Initialisierung, die ausgeschlossene Endgrenze zum <-Vergleich und die Schrittweite zur Aktualisierung. Der Körper verwendet i vor dieser Aktualisierung. Würde die Aktualisierung vor print(i) verschoben, verschöben sich die ausgegebenen Werte.

Beim Rückwärtszählen ändern sich sowohl der Vergleich als auch die Aktualisierung:

i = 10
while i > 0:
    print(i)
    i -= 2

Dies gibt 10, 8, 6, 4 und 2 aus, genau wie for i in range(10, 0, -2):. Der absteigende Zahlenbereich schließt seine Endgrenze aus, daher lautet die entsprechende while-Bedingung i > 0.

Beide Formen erfüllen die Aufgabe, die Zahlen auszugeben; ihre Endwerte für die Schleifenvariable unterscheiden sich. Die while-Version führt vor dem Anhalten ihre letzte Aktualisierung auf 0 aus. Die for-Version endet, nachdem sie ihren letzten gelieferten Wert 2 zugewiesen hat.

Ein Zahlenbereich behält die angegebenen Grenzen

n = 3
for i in range(n):
    n = 10
    print(i)

Dies gibt weiterhin 0, 1 und 2 aus. Der Zahlenbereich wurde mit 3 erstellt; die Zuweisung von 10 an n erstellt ihn nicht neu. Ein break kann die Schleife vorzeitig beenden, aber eine Änderung dieser separaten Variablen ändert die vom Zahlenbereich gelieferten Zahlen nicht.

Ein while-Kopf wertet dagegen seinen Ausdruck bei jeder Rückkehr erneut aus. Verwendet dieser Ausdruck n, kann eine Änderung von n im Körper beeinflussen, wann die Schleife endet. Wenn beide Formen eine Zählaufgabe klar ausdrücken, übernimmt die for-Version das Weiterzählen ohne eine Aktualisierung von Hand, die man vergessen könnte.

break beendet sofort die innerste Schleife, die die Anweisung enthält. Python überspringt den Rest dieses Körpers und alle verbleibenden Durchläufe und fährt dann nach der Schleife fort. Eine Bedingung innerhalb des Körpers entscheidet, wann dieser vorzeitige Abbruch erfolgen soll.

Beim ersten gefundenen Ergebnis stoppen

Suche das erste Vielfache von 7 über 50:

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

Die Schleife prüft 51, 52, 53, 54, 55 und 56. Bei 56 ist der Rest null, sodass Python 56 ausgibt und die Schleife verlässt. Es sind sechs Durchläufe nötig, obwohl der Zahlenbereich 49 Zahlen liefern kann. Ohne break würde die Schleife auch spätere Vielfache von 7 ausgeben.

break ist innerhalb des if eingerückt und wird daher nur bei einem Treffer ausgeführt. Stünde es stattdessen auf Höhe von if, würde es unabhängig von der Prüfung bereits beim ersten Durchlauf ausgeführt. Ein break innerhalb eines if beendet die Schleife, die dieses if enthält; es beendet nicht nur den bedingten Block.

Einmal lesen und dann über die Verarbeitung entscheiden

Eine while True-Schleife platziert die Entscheidung über den Abbruch nach dem Einlesen:

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

Bei den Eingaben „hello“, „there“ und „done“ lauten die Antwortzeilen:

hello
there
Done!

Der Sentinelwert wird vor der Verarbeitungszeile geprüft. Wenn er erscheint, überspringt break die Anweisung print(line). Das letzte nicht eingerückte print wird weiterhin nach der Schleife ausgeführt. Es gibt nur eine input-Anweisung, weil jeder Durchlauf mit dem Einlesen einer neuen Zeile beginnt.

Eine numerische Summe verwendet dieselbe Reihenfolge: Initialisiere total = 0 vor der Schleife; lies eine Zahl und wandle sie um; brich ab, wenn sie 0 ist; addiere sie andernfalls. Für 4, 7 und 0 beträgt die Summe 11. Würde vor der Abbruchprüfung verarbeitet, gelangte der Sentinelwert in die Berechnung. Das ist relevant, wenn der Stoppwert eine Anzahl, ein Produkt oder ein arithmetisches Mittel verändern könnte.

Bei der Eingabe validieren

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

Der verkettete Vergleich akzeptiert ein Alter von 0 bis einschließlich 120. Er bedeutet 0 <= age and age <= 120. Eine akzeptierte Zahl führt vor der Warnung aus der Schleife; eine Zahl außerhalb dieses Bereichs führt zur Warnung und dann zu einer weiteren Eingabe. In dieser Form beschreibt das if eine gültige Antwort, während eine über den Schleifenkopf gesteuerte Validierungsschleife eine ungültige Antwort beschreibt.

Den Sprung wörtlich lesen

Eine Anweisung nach break im selben Block kann nicht ausgeführt werden. Setze eine Meldung oder ein gespeichertes Ergebnis vor das break, wenn sie zum Erfolgsfall gehören. Setze Code nach die Schleife, wenn er sowohl nach einem vorzeitigen Abbruch als auch nach regulärer Beendigung ausgeführt werden soll.

break muss innerhalb einer Schleife stehen; andernfalls löst Python SyntaxError aus. Mehrere getrennte Ausgänge können eine Schleife schwerer nachvollziehbar machen. Wenn eine einzige Bedingung die Abbruchregel der Aufgabe auf natürliche Weise beschreibt, kann sie im Schleifenkopf den Ablauf leichter nachvollziehbar machen.

continue überspringt den Rest des aktuellen Durchlaufs. Die Schleife bleibt aktiv: Eine for-Schleife nimmt ihr nächstes Element und eine while-Schleife kehrt zu ihrer Bedingung zurück. Das ist nützlich, wenn ein Element nicht von den Verarbeitungsschritten betroffen sein soll, die auf eine Prüfung folgen.

Ausgewählte Werte überspringen

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

Der Zahlenbereich liefert alle zehn ganzen Zahlen von 1 bis einschließlich 10. Bei 3, 6 und 9 überspringt continue die Addition. Die Summe aller zehn ist 55; lässt man diese drei Werte aus, entfallen 18, sodass das Programm 37 ausgibt.

Continue entfernt keinen Durchlauf aus dem Zahlenbereich. Der Körper beginnt weiterhin mit jedem Wert, auch mit den übersprungenen. Es ändert, welche späteren Zeilen in diesem Durchlauf ausgeführt werden.

Ein positiver Filter kann dieselbe Arbeit ausdrücken. In einer Schleife über [5, -2, 8, -7, 3] gibt if n < 0: continue gefolgt von print(n) die Werte 5, 8 und 3 aus. Setzt man die print-Anweisung in if n >= 0:, ergibt sich dieselbe Ausgabe. Continue ist oft hilfreich, wenn mehrere Verarbeitungszeilen folgen, weil zurückgewiesene Elemente diesen Teil des Körpers sofort verlassen können.

Eine while-Aktualisierung nicht überspringen

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Dies gibt 0 und 1 aus und bleibt dann bei 2 hängen. Bei 2 springt continue zur Bedingung, ohne die Aktualisierung zu erreichen. Die Bedingung bleibt wahr und derselbe Zweig wird erneut ausgeführt.

Um die Ausgabe von 2 zu überspringen und dennoch voranzukommen, aktualisiere auch in diesem Zweig:

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

Nun lautet die Ausgabe 0, 1, 3 und 4 in getrennten Zeilen. Der Weg mit dem Überspringen führt von 2 zu 3. Jeder Weg durch diesen Körper führt genau eine Aktualisierung aus.

Break, continue und pass

Angenommen, bei einer Schleife über [1, 2, 3, 4] enthält ein if n == 2: eine dieser Anweisungen und print(n) folgt auf das if. Break gibt nur 1 aus. Continue gibt 1, 3 und 4 aus. Pass gibt alle vier Werte aus, weil es die print-Anweisung nicht überspringt.

pass kann während der Codeentwicklung einen Körper füllen, in dem Python eine Anweisung verlangt. Es liefert weder eine Aktualisierung noch einen Ausgang: while True: pass läuft weiter. Break und continue müssen innerhalb einer Schleife stehen und wirken nur auf die innerste Schleife, die sie enthält.

Ein else-Block kann zu einer for- oder while-Schleife gehören. Er wird einmal ausgeführt, wenn die Schleife regulär endet: Eine for-Schleife hat ihre Elemente aufgebraucht oder eine while-Bedingung wird falsch. Endet diese Schleife durch break, wird der Block übersprungen. Lies ihn als den Fall ohne break.

Eine Suche ohne Treffer melden

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

Die Schleife erreicht 15, gibt First multiple of 5: 15 aus und wird abgebrochen. Das else wird übersprungen. Bei [4, 9, 22] durchläuft die Schleife jedes Element ohne Abbruch und gibt einmal No multiple of 5 aus.

Die Ausrichtung ist entscheidend. Das else steht auf Höhe von for und gehört deshalb zur Schleife. Ein else auf Höhe des inneren if würde für jedes nicht passende Element ausgeführt und einen Misserfolg melden, bevor die Suche beendet ist.

Auch eine leere Liste führt zum else der Schleife. Es gibt keine Elemente, daher wird der Körper nullmal ausgeführt und es erfolgt kein break. Ebenso führt eine while-Schleife, deren Bedingung bei der ersten Prüfung falsch ist, sofort ihr else aus.

Nach einem Teiler suchen

Eine Primzahl ist eine ganze Zahl von mindestens 2, deren einzige positive Teiler 1 und die Zahl selbst sind. Suche nach einem Teiler zwischen diesen beiden Werten:

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

Für 29 ist jeder Rest ungleich null und das else der Schleife gibt 29 is prime aus. Für 21 ist der erste Teiler 3 und der break überspringt das else der Schleife. Die äußere Prüfung behandelt Zahlen unter 2. Ohne sie würde ein leerer Zahlenbereich für 1 zum else führen und 1 fälschlich als Primzahl bezeichnen. Für 2 ist der Zahlenbereich ebenfalls leer, aber die Schlussfolgerung „Primzahl“ ist richtig.

Begrenzte Versuche mit while und else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

Eine richtige Eingabe führt zum break, auch beim dritten Versuch. Drei falsche Eingaben erhöhen den Zähler auf 3; die Bedingung wird falsch und das else gibt die Fehlermeldung aus. Eine gewöhnliche Anweisung nach der Schleife würde in beiden Fällen ausgeführt und könnte sie daher nicht unterscheiden.

Das Ergebnis mit einer Merkvariablen festhalten

Eine Merkvariable ist eine boolesche Variable, die festhält, ob etwas geschehen ist. Beginne mit found = False, ändere den Wert bei einem Treffer zu True und brich ab. Nach der Schleife behandelt if not found: den Misserfolg. Das liefert dasselbe Suchergebnis wie das else der Schleife und hält das Ereignis ausdrücklich fest. Wähle eine Form, deren Einrückung und Abbruchweg du klar erklären kannst.

Ein Akkumulator bewahrt ein Ergebnis zwischen den Durchläufen. Ein Zähler ist ein besonderer Akkumulator, der jedes Mal um 1 steigt, wenn ein Ereignis eintritt. Setze den Startwert vor der Schleife, aktualisiere ihn innerhalb der Schleife und verwende das fertige Ergebnis danach.

Ereignisse zählen oder Werte addieren

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

Die Prüfung ist für 15, 22 und 11 erfolgreich, sodass die Ausgabe 3 lautet. Die Aktualisierung addiert 1 für ein passendes Element; die Addition von n würde stattdessen die passenden Werte aufsummieren.

Um jedes Element zu summieren, initialisiere total = 0, entferne die if-Prüfung, füge total += n direkt im Körper hinzu und gib total danach aus. Die fünf Werte ergeben zusammen 60. Ihr arithmetisches Mittel ist 60 / 5, was 12.0 ergibt; die Division mit / gibt für diese ganzzahligen Operanden eine Gleitkommazahl zurück.

Für das arithmetische Mittel ausgewählter Werte aktualisiere Summe und Anzahl unter derselben Bedingung:

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Hier ist die Summe der ausgewählten Werte 48 und ihre Anzahl 3, sodass die Ausgabe 16.0 lautet. Eine Division durch die Länge der ganzen Liste würde die falsche Gruppe verwenden. Die Prüfung der Anzahl behandelt auch eine leere Liste oder eine Liste ohne Treffer.

Einen zur Operation passenden Startwert wählen

Ein Produkt der ganzen Zahlen von 1 bis 5 beginnt bei 1 und endet bei 120. Ein Start bei 0 würde jedes Produkt bei 0 halten.

Auch beim Aufbau von Text ist die Reihenfolge wichtig:

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Jedes neue Zeichen wird vor den gespeicherten Text gesetzt, sodass desserts entsteht. Ändert man die Aktualisierung zu rev = rev + ch, werden Zeichen am Ende angefügt und stressed entsteht erneut.

Das Ergebnis zwischen den Durchläufen bewahren

Wird total = 0 in eine Summenschleife verschoben, geht die bisherige Arbeit bei jedem Durchlauf verloren. Bei [4, 15, 22, 8, 11] bleibt nach dem Zurücksetzen vor jeder Addition am Ende nur 11 übrig. Initialisiere außerhalb der Schleife, damit die nächste Addition die vorherige Zwischensumme verwendet.

Eine print-Anweisung im Körper zeigt nach jeder Aktualisierung die laufende Summe: in diesem Beispiel 4, 19, 41, 49 und 60. Eine print-Anweisung nach der Schleife zeigt nur 60. Wähle die Position passend zur gewünschten Ausgabe.

Für eine einfache gespeicherte Liste liefert sum(values) ihre Summe und len(values) ihre Anzahl. Eine ausdrücklich geschriebene Schleife ermöglicht es, Werte zu filtern, mehrere Ergebnisse gemeinsam zu verfolgen oder Werte bei ihrer Eingabe zu verarbeiten.

Um ein Maximum zu finden, halte den bisher größten Wert fest. Vergleiche jedes neue Element mit diesem gespeicherten Wert und ersetze ihn nur, wenn das neue Element größer ist. Das Minimummuster funktioniert genauso mit umgekehrtem Vergleich.

Ohne erfundenen Datenwert beginnen

None ist Pythons Wert für „noch nichts“. Damit kann das erste Element auf klare Weise zum aktuell besten werden:

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

Die gespeicherten Werte nach jedem Element sind 12, 12, 25 und 25. Das Programm gibt 25 aus. Beim ersten Element ist largest is None wahr. Pythons or beendet die Auswertung dort und versucht daher nicht den ungültigen Vergleich einer Zahl mit None. Bei späteren Durchläufen ist der gespeicherte Wert eine Zahl und der zweite Vergleich wird verwendet.

Für ein Minimum beginne mit smallest = None und verwende smallest is None or n < smallest. Dieselbe Liste ergibt -3.

Beginnt die Suche nach einem Maximum bei 0, kann sie einen Wert melden, der nie vorkam. Für -5, -2 und -9 überschreitet kein Wert die 0, sodass diese Version fälschlich 0 behalten würde. Das Maximum ist -2. Beginnt die Suche nach einem Minimum bei 0, entsteht das entsprechende Problem, wenn jedes Element positiv ist.

Ist bekannt, dass die Daten ein Element enthalten, funktioniert auch der erste Wert als bisher bester Startwert. Eingebaute Funktionen decken einfache gespeicherte Listen ab: max([12, -3, 25, 7]) ergibt 25 und min([12, -3, 25, 7]) ergibt -3. Eine selbst geschriebene Schleife kann zugehörige Informationen festhalten, etwa wo der Wert vorkam.

Die Position speichern, wenn sich der beste Wert ändert

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

Der Tageszähler steigt bei jedem Element. Der beste Tag ändert sich nur, wenn ein neues Maximum erscheint. Die endgültige Ausgabe lautet 26 4, also eine Temperatur von 26 an Tag 4. Würde der Tag nach der Schleife gespeichert, wäre das lediglich der zuletzt geprüfte Tag.

Entscheiden, was bei Gleichstand geschehen soll

Für [5, 8, 8, 3] behält die Prüfung n > largest die erste 8 und ihre Position, beim Zählen ab 1 die Position 2. Ersetzt man > durch >=, wird auch bei einem gleichen Wert aktualisiert und die letzte 8 an Position 3 behalten. Die größte Zahl bleibt gleich; die gespeicherte Position unterscheidet sich.

Eine leere Liste lässt einen mit None initialisierten besten Wert unverändert. Prüfe diesen Zustand, bevor du eine Zahl meldest oder damit rechnest. Er bedeutet, dass kein Element einen besten Wert geliefert hat.

Der Vergleich kann eine Eigenschaft eines Elements verwenden. Um das längste Wort unter „pear“, „banana“ und „fig“ zu behalten, vergleiche len(word) mit der Länge des gespeicherten Wortes. „Banana“ hat sechs Zeichen und gewinnt daher. Speichere das Wort selbst, wenn es zum besten wird, damit das Ergebnis das Element und nicht nur seine Länge bezeichnet.

Eine lineare Suche prüft Elemente der Reihe nach, bis sie einen Treffer findet oder keine Elemente mehr übrig sind. Ein Treffer kann ein exakter Wert, das erste Element sein, das eine Bedingung erfüllt, oder ein Beleg für eine Frage nach mindestens einem oder nach allen Elementen.

Einen Erfolg festhalten

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

Die Merkvariable beginnt mit dem Wert falsch, weil noch nichts gefunden wurde. Die erste Prüfung, Ana, lässt sie unverändert. Die zweite Prüfung findet Ben, setzt die Merkvariable auf wahr und beendet die Suche. Die Ausgabe lautet Ben is on the list.

Die Merkvariable hält ein Ereignis über die ganze Suche hinweg fest. Setze sie nicht bei jeder Nichtübereinstimmung zurück. Wenn eine Schleife nach dem Finden von Ben weiterläuft und bei Chen found = False setzt, geht das erfolgreiche Ergebnis verloren. Ebenso gehört „nicht gefunden“ an die Stelle nach allen erfolglosen Prüfungen, nicht in ein else für jedes Element, das bereits für Ana einen Misserfolg meldet, bevor Ben geprüft wird.

Erster oder letzter Treffer

Für [7, 4, 9, 10] ist die erste gerade Zahl 4 und die letzte 10. Diese Schleife speichert die erste:

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

Die Ausgabe ist 4. Entferne den break und jeder neue Treffer überschreibt den vorherigen, sodass 10 bleibt. Passt nichts, bleibt der gespeicherte Wert None. Entscheide, ob die Aufgabe nach dem Vorhandensein, dem ersten Element, dem letzten Element oder einer Position fragt, bevor du festlegst, was gespeichert wird.

Um eine Position zu melden, führe einen Zähler, der bei jedem geprüften Element steigt, und speichere ihn bei einem Treffer. Gib an, wie die Positionen nummeriert werden: Beim Zählen ab 1 steht Chen in der Namensliste an Position 3; Pythons übliche Positionsnummerierung beginnt bei 0.

Für mindestens eins genügt ein Erfolg; für alle genügt ein Misserfolg

Eine Suche nach mindestens einem Treffer beginnt mit falsch und wird beim ersten Element, das die Prüfung besteht, wahr. Sie kann dort enden, weil ein Erfolg die Frage beantwortet.

Eine Prüfung aller Elemente beginnt mit wahr und wird beim ersten Misserfolg falsch:

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

Der dritte Wert, -1, widerlegt „Alle Werte sind positiv“, sodass die Ausgabe False lautet. Es ist nicht nötig, 5 zu prüfen. Auch null würde die Prüfung nicht bestehen, weil positiv größer als null bedeutet. Gibt es keine Elemente, bleibt die Merkvariable wahr: Es ist kein Gegenbeispiel aufgetreten.

Exakte Zugehörigkeit und eigene Bedingungen

Für Gleichheit allein liefert "Ben" in names direkt True oder False. Eine Schleife macht den sich ändernden Suchzustand sichtbar und erlaubt eine eigene Bedingung, etwa „das erste Wort mit mehr als fünf Zeichen“.

Zeichenkettenvergleiche sind exakt. "ben" unterscheidet sich von "Ben", und "Ben " enthält ein Leerzeichen am Ende. Eine Suche nach einer dieser Zeichenketten darf die anderen nicht als gleich behandeln.

Eine verschachtelte Schleife ist eine Schleife im Körper einer anderen Schleife. Bei jedem äußeren Durchlauf beginnt die innere Schleife und führt ihre Arbeit vollständig aus. Die äußere Variable bleibt gleich, während sich die innere Variable ändert.

Eine Zeile nach der anderen erstellen

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

Die Ausgabe hat diese drei Zeilen, jeweils mit einem Leerzeichen nach der letzten Zahl:

1 2 3 4 
2 4 6 8 
3 6 9 12 

Zuerst ist row gleich 1, während col die Werte 1 bis 4 annimmt. Dann wird row zu 2 und die innere Schleife beginnt erneut bei Spalte 1. Schließlich erhält Zeile 3 dieselben vier Spalten. Der innere Körper wird zwölfmal ausgeführt.

end=" " ersetzt den üblichen Zeilenumbruch von print durch ein Leerzeichen. Das leere print() beendet die Zeile. Es steht innerhalb des äußeren, aber außerhalb des inneren Körpers und wird daher dreimal ausgeführt. Eine Einrückung um eine weitere Ebene würde jede Zahl in eine eigene Zeile setzen. Ohne Einrückung würde es erst nach beiden Schleifen einmal eine Zeile beenden.

Gib den Schleifenvariablen unterschiedliche Namen, etwa row und col. Wird der äußere Name in der inneren Schleife erneut verwendet, überschreibt das den Wert, der zur Bestimmung der aktuellen Zeile benötigt wird.

Die Arbeit zählen

Hat jeder äußere Durchlauf dieselbe Anzahl innerer Durchläufe, multipliziere die Anzahlen. Drei Zeilen und vier Spalten ergeben zwölf Ausführungen des inneren Körpers. Zwei Schleifen mit je 100 Durchläufen ergeben 10.000 innere Ausführungen; drei Ebenen ergeben 1.000.000. Eine kleine Erhöhung jeder Grenze kann daher zu deutlich mehr wiederholter Arbeit führen.

Ändert sich die innere Grenze mit der äußeren Variablen, addiere die einzelnen Anzahlen:

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

Dies gibt aus:

*
**
***
****

Die Zeilenlängen sind 1, 2, 3 und 4, also insgesamt zehn Sterne. Für ein Muster mit n solchen Zeilen ist die Gesamtzahl $n(n+1)\mathrm{/}2$. Eine Multiplikation von vier mit vier würde fälschlich voraussetzen, dass jede Zeile vier Sterne hat.

Ein Ergebnis für jede Gruppe zurücksetzen

Um jede Zeile des Einmaleinsrasters zu summieren, setze row_total = 0 innerhalb der äußeren Schleife direkt vor der inneren Schleife. Addiere row * col im inneren Körper und gib row_total nach der inneren Schleife aus. Die Ausgaben sind 10, 20 und 30.

Eine Initialisierung nur einmal vor beiden Schleifen behält auch die Summen früherer Zeilen. Eine Ausgabe nach jeder Zeile ergibt dann 10, 30 und 60. Beide Platzierungen bewahren ein Ergebnis, aber eine bewahrt ein Zeilenergebnis und die andere eine laufende Summe des ganzen Rasters.

Kombinationen durchlaufen

Zwei Schleifen über range(1, 7) durchlaufen alle 36 geordneten Ergebnisse für zwei Würfel. Die erste Schleife liefert den ersten Würfel und die zweite den zweiten Würfel. Eine Bedingung im inneren Körper kann Paare mit der Summe 7 zählen. Sechs erfüllen sie: (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) und (6, 1). Die Umkehrung eines Paars beschreibt ein anderes geordnetes Ergebnis.

Break und continue wirken auf die innerste Schleife, die sie enthält. Suche bei verschachteltem Code diese Schleife, bevor du vorhersagst, was als Nächstes geschieht. Ein break im inneren Körper stoppt nicht von selbst die äußere Schleife.

Einen inneren break verfolgen

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

Bei a = 1 wird das Paar 1 1 ausgegeben. Wird b zu 2, beendet der break diese innere Schleife. Die äußere Schleife geht zu a = 2 weiter und beginnt eine neue innere Schleife mit b gleich 1. Sie gibt 2 1 und 2 2 aus und bricht dann bei b gleich 3 ab. Für a gleich 3 besteht jeder Wert von b die Prüfung. Die sechs Ausgabezeilen lauten:

1 1
2 1
2 2
3 1
3 2
3 3

Beide Schleifen mit einem festgehaltenen Ergebnis stoppen

Eine Suche nach einer Kombination kann eine Merkvariable und je einen break auf jeder Ebene verwenden:

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

Die Zeilen mit a gleich 1 und 2 enthalten keinen Treffer. In Zeile 3 erreicht b den Wert 4 und das Produkt ist 12. Der innere break beendet die b-Schleife; die Merkvariable bewirkt dann, dass der äußere break ausgeführt wird. Die endgültige Ausgabe lautet 3 4.

Die Merkvariable wird vor beiden Schleifen initialisiert, weil sie ein Ergebnis für die gesamte Suche festhält. Das äußere if found: gehört nach die innere Schleife, aber innerhalb des äußeren Körpers. Durch seine Einrückung erfolgt eine Prüfung pro abgeschlossener oder unterbrochener Zeile.

Werte bewahren, wenn die Suche weiterläuft

Wird nur der äußere break entfernt, setzt sich die Suche in späteren Zeilen fort. In diesem Beispiel ist ein späterer Treffer 4 3, aber die Schleife prüft schließlich Zeile 5 und endet mit a = 5 und b = 5. Die Ausgabe der Schleifenvariablen ergibt dann 5 5, keinen gespeicherten Treffer.

Benötigt die Aufgabe das letzte passende Paar, speichere best_a = a und best_b = b bei jedem Treffer. Diese separaten Variablen behalten einen Treffer, während sich die Schleifenvariablen weiter ändern. Prüfe die Merkvariable vor ihrer Ausgabe, wenn möglicherweise kein Treffer existiert.

Ein Paar überspringen und die Zeile fortsetzen

Ein continue innerhalb der inneren Schleife geht zu deren nächstem inneren Wert. Bei zwei Schleifen, die 1 bis 4 durchlaufen, überspringt if a == b: continue vor der Verarbeitung vier gleiche Paare. Von den ursprünglichen sechzehn bleiben zwölf geordnete Paare.

Ein if kann Paare auch ohne Sprung auswählen. Zwei Würfel haben drei geordnete Paare mit der Summe 10: (4, 6), (5, 5) und (6, 4). Eine Bedingung im inneren Körper erkennt sie.

Nachvollziehen des Programmablaufs bedeutet, ein Programm von Hand Anweisung für Anweisung auszuführen und dabei seine Werte und Ausgaben festzuhalten. Eine Ablauftabelle gibt jeder relevanten Variablen eine Spalte. Kennzeichne, ob ein Wert vor oder nach einer Aktualisierung festgehalten wird, damit die Zeilen eine klare Bedeutung haben.

Eine while-Schleife nachvollziehen

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Beginne mit total = 0 und i = 1. Prüfe die Bedingung, bevor du in den Körper eintrittst. Führe bei jeder wahren Prüfung die Addition vor dem Inkrement aus:

Die nächste Prüfung ist 5 <= 4 und damit falsch. Es gibt keine fünfte Zeile für den Körper. Der Körper wird viermal ausgeführt, die Bedingung wird fünfmal geprüft und die print-Anweisung nach der Schleife gibt einmal 10 aus. Die Endwerte sind i = 5 und total = 10.

Unterscheide die fehlgeschlagene Prüfung von einem Durchlauf: Sie beendet die Schleife, ohne ihren Körper auszuführen. Ist die Anfangsbedingung bereits falsch, gibt es überhaupt keine Zeilen für den Körper und die Variablen behalten ihre Startwerte.

Die Reihenfolge der Anweisungen ändert das Ergebnis

Wird das Inkrement über die Addition verschoben, verwendet jeder Durchlauf den neuen Wert von i. Die vier Additionen werden zu 2, 3, 4 und 5 und ergeben 14. Die Bedingung prüft i weiterhin am Anfang, vor diesem Inkrement. Würde man nur die Werte im Schleifenkopf nachvollziehen, bliebe unbemerkt, welchen Wert die Addition tatsächlich verwendet.

Enthält ein Körper break oder continue, verfolge seine verbleibenden Zeilen nicht weiter, sobald der Sprung erfolgt. Kehre bei continue zum Schleifenkopf oder zum nächsten Element zurück; fahre bei break nach der Schleife fort. Eine Ablauftabelle muss diesen Wegen folgen, statt einfach alle Anweisungen des Körpers in jede Zeile zu kopieren.

Zeichen und verschachtelte Schleifen nachvollziehen

Eine for-Schleife weist zu Beginn ihres Durchlaufs das nächste Element zu:

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

Der gespeicherte Text wird zu "a", dann zu "ba" und dann zu "cba". Die Ausgabe ist cba. Halte den tatsächlichen Text einschließlich seiner Reihenfolge fest, statt nur zu schreiben, dass „ein Zeichen hinzugefügt wurde“.

Verwende bei verschachtelten Schleifen eine Zeile für jeden inneren Durchlauf. Halte beide Schleifenvariablen fest, sodass sich der äußere Wert über die zu ihm gehörenden Zeilen wiederholt. In einer Schleife mit zwei Zeilen und drei Spalten lauten die Zeilenwerte 1, 1, 1, 2, 2, 2, während die Spaltenwerte 1, 2, 3, 1, 2, 3 lauten.

Den Ablauf mit print ausgeben

Ein vorübergehendes print("i =", i, "total =", total) nach beiden Aktualisierungen in der Summenschleife zeigt i und total am Ende jedes Durchlaufs. Eine Platzierung vor den Aktualisierungen zeigt einen anderen Zeitpunkt. Vergleiche die Position der print-Anweisung mit den Spaltenbeschriftungen deiner Tabelle. Entferne diagnostische Ausgaben nach der Korrektur des Codes, damit sie nicht zu zusätzlicher Programmausgabe werden.

Halte bei einer Frage wie „Was wird ausgegeben?“ nur Anweisungen fest, die tatsächlich etwas ausgeben. Die Änderung einer Variablen ist selbst keine Ausgabe; vor einer einzigen abschließenden print-Anweisung können mehrere Aktualisierungen erfolgen.

Ein Um-eins-Fehler durchläuft einen Wert zu viel oder zu wenig oder verschiebt die durchlaufenen Werte um eins. Er entsteht häufig durch die ausgeschlossene Endgrenze eines Zahlenbereichs, die Wahl zwischen < und <= oder den Startwert eines Zählers.

Die beabsichtigten Endpunkte festlegen

Um 1 bis 10 zu addieren, ist range(1, 10) zu kurz. Es liefert nur 1 bis 9 und ergibt eine Summe von 45. range(1, 11) schließt 10 ein und ergibt 55. Für einen aufsteigenden ganzzahligen Zahlenbereich mit Schrittweite 1 verwende die Endgrenze n + 1, um den letzten Wert n einzuschließen.

Bei der Standardschrittweite 1 liefert range(a, b) b - a Werte, wenn b größer als a ist. Ein break kann die Schleife dennoch beenden, bevor alle verwendet werden. Liste bei anderen Schrittweiten einen kleinen Fall auf oder prüfe die Anzahl mit len(range(...)).

Die Anzahl der Durchläufe einer while-Schleife hängt gemeinsam von ihrem Startwert, ihrem Vergleich und ihrer Aktualisierung ab. Für eine nichtnegative ganze Zahl n, mit i += 1 am Ende jedes Durchlaufs und ohne vorzeitigen Abbruch:

Bei n gleich 0 überspringen die ersten beiden den Körper. Die dritte wird einmal mit i gleich 0 ausgeführt. Dieser kleine Fall zeigt den zusätzlichen Durchlauf, ohne eine lange Schleife nachzuvollziehen.

Grenzen beim Rückwärtszählen

Beginnend bei 5 und mit einer Ausgabe vor n -= 1 gibt while n > 0: fünf Werte aus und endet bei 1. Mit n >= 0 werden sechs Werte ausgegeben, bis 0. Die entsprechenden absteigenden Zahlenbereiche sind range(5, 0, -1) und range(5, -1, -1).

Prüfe auch die Reihenfolge. Die Aktualisierung eines Zählers vor seiner Verwendung kann jeden Wert verschieben, selbst wenn die Schleife die erwartete Anzahl von Durchläufen hat. Eine Ablauftabelle sollte die tatsächlichen ersten und letzten Werte festhalten, die die Berechnung verwendet.

Elemente und die Zwischenräume zwischen ihnen

Ein Zaunpfahlfehler verwechselt die Anzahl der Elemente mit der Anzahl der Zwischenräume. Fünf Zaunabschnitte brauchen sechs Pfähle. Fünf ausgegebene Zahlen brauchen nur vier Trennzeichen dazwischen.

for i in range(1, 6):
    print(i, end="-")

Dies gibt 1-2-3-4-5- einschließlich eines unerwünschten abschließenden Bindestrichs aus. Jede print-Anweisung fügt nach einem Element einen Bindestrich hinzu, auch nach dem letzten.

Eine Korrektur besteht darin, das erste Element separat auszugeben und dann vor jedem weiteren Element ein Trennzeichen auszugeben:

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

Die Ausgabe ist 1-2-3-4-5. Die Schleife gibt vier Stücke aus Bindestrich und Zahl aus und die letzte leere print-Anweisung beendet die Zeile. Diese Version hat ein bekanntes erstes Element; im allgemeinen Fall leerer Daten muss auch die Ausgabe des ersten Elements übersprungen werden.

Die Korrektur mit kleinen Fällen prüfen

Schreibe den beabsichtigten ersten Wert, letzten Wert und die Anzahl auf, bevor du den Code änderst. Wähle die Grenzen und den Vergleich passend dazu und vollziehe dann einen kurzen Ablauf nach. Prüfe neben einem gewöhnlichen Fall auch null und ein Element. Null zeigt Arbeit, die übersprungen werden sollte; ein Element zeigt ein unnötiges Trennzeichen oder eine zusätzliche Aktualisierung. Ändere die Grenze, die den Fehler verursacht, sodass die Wiederholung im Code zur Aufgabe passt.