Schleifen und Bedingungen in Python: for, while, range, enumerate, break, if/elif und match/case

Schleifen in Python dienen dazu, eine Aktion zu wiederholen: eine Einkaufsliste durchgehen, jede Zeile einer Datei verarbeiten oder so lange nach einer gültigen Zahl fragen, bis der Benutzer eine eingibt. Python kennt zwei Schleifen, for und while. Entscheidungen innerhalb der Schleifen treffen if/elif/else und der Operator match/case. Wir sehen uns jedes Werkzeug an praktischen Beispielen an.

Bedingungen: if, elif, else

Eine Bedingung führt einen Block nur aus, wenn der Ausdruck wahr ist. Der Block wird durch 4 Leerzeichen Einrückung gekennzeichnet. Geschweifte Klammern gibt es in Python nicht, und eine falsche Einrückung führt sofort zu einem IndentationError.

spent = 4200
limit = 5000

if spent > limit:
    print("Limit überschritten")
elif spent > limit * 0.8:
    print("Weniger als 20 % des Budgets übrig")
else:
    print("Alles in Ordnung")

Die Zweige elif werden von oben nach unten geprüft, und nur der erste passende Zweig wird ausgeführt. Deshalb stehen strengere Bedingungen weiter oben: Stünde die Prüfung spent > limit * 0.8 an erster Stelle, würde die Meldung zur Überschreitung des Limits nie erscheinen.

Was als wahr gilt

In einer Bedingung müssen Sie nicht zwingend einen Vergleich schreiben. Als falsch gelten False, None, die Null (0, 0.0) und leere Sammlungen: "", [], {}. Alles andere ist wahr. Deshalb schreibt man die Prüfung „Liste ist nicht leer“ kurz:

expenses = []
if not expenses:
    print("Bisher keine Ausgaben")

Bedingungen verknüpfen Sie mit and, or und not. Einen Wertebereich prüft man bequem mit einer Vergleichskette: if 0 < amount <= 100_000:. Für eine kurze Auswahl eines Wertes gibt es den bedingten Ausdruck: status = "hoch" if spent > limit else "normal".

Die for-Schleife in Python: Syntax und Beispiele

Die Schleife for in Python ist kein Zähler wie in C, sondern durchläuft Elemente. Sie nimmt nacheinander jedes Element eines iterierbaren Objekts: einer Liste, einer Zeichenkette, eines Dictionaries, einer Datei oder eines Bereichs. Was in anderen Sprachen foreach heißt, ist in Python einfach das normale for.

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

Die Syntax lautet for Variable in Sammlung:, gefolgt von einem eingerückten Block. Die Schleifenvariable behält nach dem Ende den letzten Wert. Das kann manchmal nützlich sein, in größeren Programmen sollten Sie sich darauf aber nicht verlassen.

Schleife über Zeichenkette, Liste und Dictionary

Eine Zeichenkette wird Zeichen für Zeichen durchlaufen, eine Liste Element für Element. Eine Schleife über ein Dictionary läuft standardmäßig über die Schlüssel. Um Schlüssel und Wert gleichzeitig zu erhalten, verwenden Sie .items():

by_category = {"Essen": 3200, "Verkehr": 900, "Kino": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} €")

Nur die Werte liefert .values(). Die Größe eines Dictionaries darf während des Durchlaufs nicht verändert werden, sonst erhalten Sie RuntimeError: dictionary changed size during iteration. Wenn Sie Elemente entfernen möchten, durchlaufen Sie eine Kopie: for key in list(d):.

Die Funktion range: Schleife über Zahlen

Wenn Sie Zahlen durchlaufen möchten, hilft range(). Die Funktion erzeugt keine Liste im Speicher, sondern liefert die Zahlen einzeln. Deshalb läuft range(10**9) sofort los.

Die wichtigste Regel: Die rechte Grenze gehört nicht zum Bereich. range(1, 10) endet bei 9. Das ist eine häufige Ursache für Fehler um eins. Die Schrittweite darf negativ sein, aber nicht null.

for i in range(1, 4):
    print(f"Tag {i}")
# Tag 1
# Tag 2
# Tag 3

enumerate: Zähler in der Schleife

Einsteiger schreiben oft for i in range(len(items)), um die Nummer eines Elements zu kennen. Das funktioniert, ist aber schlechter lesbar. Die Funktion enumerate() liefert Paare aus „Nummer und Element“, und der Parameter start legt fest, bei welcher Zahl gezählt wird:

items = ["Kaffee", "Taxi", "Mittagessen"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 Kaffee
# 2 Taxi
# 3 Mittagessen

Für einen parallelen Durchlauf zweier Listen gibt es zip(): for name, price in zip(names, prices):. Die Funktion hört bei der kürzesten Liste auf. Seit Python 3.10 können Sie strict=True übergeben, dann löst eine unterschiedliche Länge einen Fehler aus.

Die while-Schleife in Python

Die Schleife while wiederholt einen Block, solange die Bedingung wahr ist. Man wählt sie, wenn die Anzahl der Wiederholungen vorher nicht feststeht: Wir warten auf eine richtige Eingabe, lesen Daten bis zum Ende oder wiederholen eine Anfrage bis zum Erfolg.

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"Das Geld reicht für {month} Monate.")  # 4

Die größte Gefahr ist, die Variable aus der Bedingung zu vergessen zu ändern. Dann endet die Schleife nie. Wenn das Programm hängt, drücken Sie Strg+C: Python bricht die Ausführung mit KeyboardInterrupt ab.

Endlosschleife und Ersatz für do while

Eine Endlosschleife schreibt man manchmal absichtlich: while True: mit einem Ausstieg über break. Auf diese Weise bildet man auch die Schleife mit Nachprüfung nach. Python kennt kein do while, dieser Trick ersetzt es: Der Block wird mindestens einmal ausgeführt, und die Prüfung steht am Ende.

while True:
    raw = input("Betrag: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Bitte geben Sie eine ganze Zahl ein")

Eine for-Schleife wird nur selten endlos, und zwar nur bei einem unendlichen Iterator wie itertools.count().

break und continue: Schleife verlassen und Durchlauf überspringen

break beendet die Schleife sofort, und das Programm läuft mit dem Code nach ihr weiter. continue überspringt den Rest des aktuellen Durchlaufs und springt zum nächsten.

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # Durchlauf überspringen
    if amount > 50_000:
        print("Verdächtiger Betrag, Stopp")
        break             # Schleife verlassen
    print(amount)

Es werden 350 und 1200 ausgegeben, dann die Meldung. Bei 89 kommt die Schleife nicht mehr an. Beide Anweisungen wirken nur auf die nächstgelegene Schleife, in der sie stehen.

else bei Schleifen

Bei for und while gibt es einen ungewöhnlichen Zweig else: Er wird ausgeführt, wenn die Schleife von selbst endet, also ohne break. Das ist praktisch bei der Suche:

for amount in expenses:
    if amount > 50_000:
        print("Große Ausgabe gefunden")
        break
else:
    print("Keine großen Ausgaben")

Verschachtelte Schleifen

Eine Schleife in einer Schleife führt die innere bei jedem Durchlauf der äußeren vollständig aus. So durchläuft man Tabellen, Matrizen oder bildet Paare.

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

Zwei Dinge sind dabei zu beachten. Erstens wächst der Aufwand schnell: Zwei verschachtelte Schleifen über je 10 000 Elemente ergeben 100 Millionen Operationen. Zweitens beendet break nur die innere Schleife. Um beide zu verlassen, lagern Sie die Schleifen in eine Funktion aus und verwenden return. Das ist sauberer als Flags.

Der Operator match/case

Eine lange Kette if cmd == ... elif ... lässt sich seit Python 3.10 durch den Operator match ersetzen (PEP 634). Das ist mehr als ein switch: Er vergleicht den Wert mit einem Muster nach seiner Form und zerlegt die Teile direkt in Variablen.

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"Ausgabe hinzufügen: {item}: {amount}"
        case ["list"] | ["ls"]:
            return "Ausgaben anzeigen"
        case ["quit"]:
            return "Beenden"
        case _:
            return "Unbekannter Befehl"

print(parse("add Kaffee 250"))  # Ausgabe hinzufügen: Kaffee: 250
print(parse("add Kaffee"))      # Unbekannter Befehl

Das Listenmuster ["add", item, amount] passt nur auf eine Liste mit genau drei Elementen, deren erstes "add" ist. Ein Befehl ohne Betrag landet deshalb im Zweig _, der alles Übrige auffängt. Das Zeichen | verbindet Varianten.

Dictionary-Muster, Typen und Wächter

Ein Dictionary-Muster prüft nur die angegebenen Schlüssel, zusätzliche werden ignoriert. Die Schreibweise int(a) prüft den Typ und erfasst den Wert, und ein if nach dem Muster ergänzt eine zusätzliche Bedingung (Wächter, englisch guard):

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Große Ausgabe", a)
    case {"type": "expense", "amount": int(a)}:
        print("Ausgabe", a)

Die wichtigste Falle bei match

Ein nacktes Namenswort im case ist eine Erfassung und kein Vergleich mit einer Variablen. case limit: passt auf jeden Wert und schreibt ihn in limit. Zum Vergleich mit Konstanten verwenden Sie einen Namen mit Punkt, etwa case Color.RED:, oder Literale.

Die Syntax von match hat sich seit 3.10 kaum verändert. In Python 3.15 wurde eine kleine Unsymmetrie beseitigt: Bei Literalmustern war bisher nur ein Minus vor einer Zahl erlaubt, jetzt können Sie auch case +1: schreiben. Auf älteren Versionen verursacht ein solcher Code einen Syntaxfehler.

Typische Fehler in Schleifen

• Liste während des Durchlaufs verändern. Beim Entfernen von Elementen in einer for-Schleife werden benachbarte übersprungen. Besser eine neue Liste aufbauen: clean = [x for x in items if x > 0].
• Grenze von range. range(1, n) enthält n nicht.
• Vergessene Änderung der Bedingung in while — Endlosschleife.
• Zeichenketten mit += in einer Schleife zusammensetzen ist bei großen Datenmengen langsamer als "".join(parts).
• Zuweisung statt Vergleich: if x = 5 ist ein Syntaxfehler, der Vergleich lautet ==.

Übungsaufgaben zu Schleifen

1. Berechnen Sie Summe und Durchschnitt einer Liste von Ausgaben und überspringen Sie negative Werte.
2. Geben Sie das Einmaleins von 1 bis 9 mit verschachtelten Schleifen aus.
3. Fragen Sie Zahlen ab, bis der Benutzer eine leere Zeile eingibt, und geben Sie dann das Maximum aus.
4. Finden Sie die erste Zahl größer als 1000 in einer Liste und melden Sie, falls es keine gibt (mit for ... else).
5. Verarbeiten Sie die Befehle add, del und list mit match.

Fazit

Schleifen in Python bestehen aus zwei Konstruktionen: for durchläuft die Elemente einer Sammlung oder von range(), while arbeitet, solange die Bedingung gilt. break und continue steuern den Ablauf, enumerate() und zip() ersetzen manuelle Zähler, und if/elif/else sowie match/case treffen die Entscheidungen. Alle diese Werkzeuge werden im Kurs am Beispiel des Ausgabentrackers in einer Lektion praktisch durchgespielt.