Bedingungen und boolesche Logik in Python

Ein Vergleich stellt eine Frage über Werte. Sein Ergebnis ist ein boolescher Wert: True oder False. Das sind Werte vom Datentyp bool, die mit großem Anfangsbuchstaben und ohne Anführungszeichen geschrieben werden. "True" ist Text; das kleingeschriebene true ist ein Name und löst einen NameError aus, wenn er nicht definiert wurde.

Wähle den Operator, der zur Regel passt

Die Operatoren aus zwei Zeichen werden zusammengeschrieben, mit = an zweiter Stelle. Schreibe <=, nicht =<. Eine ganze Zahl und eine Gleitkommazahl können beim Vergleich gleich sein: 7 == 7.0 ergibt True, weil ihre Zahlenwerte übereinstimmen.

Ein Vergleich ist ein Ausdruck, daher kannst du sein Ergebnis ausgeben oder speichern:

x = 7
is_big = x > 5
print(is_big)

Python wertet x > 5 aus, erhält True und weist diesen Wert is_big zu. Die Ausgabe ist True. Durch einen Namen wie is_big oder has_ticket liest sich eine boolesche Variable wie eine Ja-Nein-Frage.

Halte Zuweisung und Vergleich auseinander

x = 5 speichert einen neuen Wert in x. x == 5 prüft den aktuellen Wert, ohne ihn zu ändern. if x = 5: ist ein Syntaxfehler. Der umgekehrte Fehler ist schwerer zu bemerken:

x = 7
x == 5
print(x)

In einem Skript wird das Ergebnis des Vergleichs nicht verwendet. Die Ausgabe bleibt 7; die mittlere Zeile weist nie 5 zu.

Erst rechnen, dann vergleichen

Bei 2 + 3 > 4 addiert Python zuerst und erhält 5, dann vergleicht es 5 > 4. Das Ergebnis ist True. Ein nützlicher Test für ganze Zahlen ist n % 2 == 0: % liefert den Rest einer Division, und gerade Zahlen lassen bei der Division durch 2 den Rest 0.

Für n = 10 lauten die Schritte 10 % 2, dann 0 == 0, was True ergibt. Für n = -7 ist -7 % 2 gleich 1, also ist der Test auf gerade Zahlen False. Mit dem positiven Divisor 2 liefert Python für eine ungerade ganze Zahl den Rest 1, auch für eine negative.

Entscheide, ob die Grenze dazugehört

„Mindestens 18“ schließt 18 ein: age >= 18. „Über 18“ schließt sie aus: age > 18. Ebenso ist „unter 13“ age < 13, und „höchstens 3“ ist bags <= 3. Prüfe beim Wählen eines Operators genau den Grenzwert. Bei age = 18 ist der erste Alterstest wahr und der zweite falsch.

Rechne mit winzigen Abweichungen bei Gleitkommazahlen

Viele Dezimalbrüche lassen sich binär nur näherungsweise darstellen. Python speichert 0.1 + 0.2 als 0.30000000000000004, daher ergibt 0.1 + 0.2 == 0.3 den Wert False.

Für einen Vergleich mit der absoluten Toleranz 1e-9 verwendest du:

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() liefert die Größe der Differenz ohne ihr Vorzeichen. Diese Differenz ist kleiner als ein Milliardstel, daher gibt dieser Test True aus. Die Toleranz legt fest, wie viel Abweichung diese Prüfung zulässt; sie ist keine exakte Gleichheit.

Die Werte auf beiden Seiten eines Vergleichs sind ebenso wichtig wie der Operator. Text kann wie eine Zahl aussehen und trotzdem den Regeln für Zeichenketten folgen.

Vergleiche Texte exakt

Die Gleichheit von Zeichenketten prüft jedes Zeichen, einschließlich Groß- und Kleinschreibung und Leerzeichen. "yes" == "Yes" ist False, und "yes" == "yes " ist ebenfalls False. Um übliche Unterschiede in der Groß- und Kleinschreibung und Leerzeichen am Rand zuzulassen, vergleichst du eine bereinigte Kopie:

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() entfernt Leerraumzeichen an beiden Enden. lower() wandelt Buchstaben in Kleinbuchstaben um. Der bereinigte Text ist "yes", daher ist das Ergebnis True. Der gespeicherte Wert von answer bleibt unverändert, es sei denn, du weist ihm den bereinigten Wert zu.

Verstehe die Reihenfolge von Zeichenketten

Python vergleicht Zeichenketten von links nach rechts anhand der Unicode-Codepunkte, also der Zahlen, die den Zeichen zugeordnet sind. Der Vergleich endet beim ersten ungleichen Zeichenpaar. Bei Buchstaben von a bis z ohne Akzente oder Umlaute in einheitlicher Groß- oder Kleinschreibung entspricht das der alphabetischen Reihenfolge: "apple" < "banana" ist True. Ist eine Zeichenkette der Anfang der anderen, kommt die kürzere zuerst: "cat" < "catalog" ist True.

Das ist keine vollständige Sortierregel wie im Wörterbuch. A bis Z haben die Codepunkte 65–90, a bis z die Codepunkte 97–122. Deshalb ist "Zebra" < "apple" True. Auch das é mit Akzent kommt nach z, daher ist "zebra" < "éclair" True.

Ziffern in Zeichenketten folgen derselben Zeichenregel. "10" < "9" ist True: Verglichen werden zuerst "1" und "9", nicht die Zahlen zehn und neun.

Wandle Eingaben für Zahlenentscheidungen um

input() gibt eine Zeichenkette zurück. Tippt jemand 5 ein, ergibt "5" == 5 den Wert False; der Gleichheitstest wandelt den Text nicht um. Bei Größenvergleichen ist es anders: "5" < 10 löst einen TypeError aus, weil Python diese Zeichenkette und diese ganze Zahl nicht in eine Reihenfolge bringen kann.

age = int(input("Age: "))
print(age >= 18)

Für den eingetippten Text "18" liefert int() die ganze Zahl 18, und der Test gibt True aus. Verwende float(), wenn die Eingabe eine Dezimalzahl darstellt.

Prüfe Bereiche mit einer Kette

0 <= score <= 100 verlangt, dass beide benachbarten Vergleiche wahr sind. Es bedeutet 0 <= score and score <= 100. Für score = 105 ist der untere Test erfüllt, der obere aber nicht, daher ist die ganze Kette False.

Eine Kette vergleicht nur Nachbarn. 1 < 3 > 2 ist True, weil 1 < 3 und 3 > 2 beide wahr sind; 1 wird nicht direkt mit 2 verglichen.

Wähle bei Bedarf Zugehörigkeit oder Identität

Die Zugehörigkeitsoperatoren prüfen, ob ein Text in einem anderen vorkommt. "nan" in "banana" ist True; "Ban" in "banana" ist False. "x" not in "banana" ist True.

None steht für „kein Wert“. Prüfe es mit result is None oder result is not None. Der Operator is fragt nach genau demselben Objekt, == dagegen nach gleichen Werten. Verwende == für die Gleichheit von Zahlen und Zeichenketten: Eine Identitätsprüfung wie x is 5 ist dafür unzuverlässig und erzeugt eine SyntaxWarning.

Eine if-Anweisung führt einen Block nur aus, wenn ihre Bedingung wahr ist. Die Kopfzeile beginnt mit if, nennt die Bedingung und endet mit einem Doppelpunkt. Die Zeilen darunter sind eingerückt, um zu zeigen, dass sie zum Körper der Anweisung gehören.

Verfolge eine einseitige Verzweigung

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

In der Kopfzeile liest Python den aktuellen Wert von temperature. Der Vergleich 31 > 30 ist True, daher werden beide eingerückten Zeilen ausgeführt. Danach erreicht das Programm die Zeile außerhalb des Blocks. Die Ausgabe lautet:

Hot day
Drink water
Done

Ändere die erste Zeile in temperature = 25. Jetzt ist 25 > 30 False, daher überspringt Python den ganzen Körper. Nur Done wird ausgegeben. Die Bedingung wird einmal geprüft, wenn Python die Kopfzeile erreicht; ein if prüft sie nicht fortlaufend weiter.

Lass die Einrückung zeigen, was dazugehört

Üblich sind 4 Leerzeichen pro Einrückungsebene. Zeilen auf derselben Ebene gehören zum selben Block. Kehrst du zur äußeren Ebene zurück, endet der Block. Rückst du print("Done") um 4 Leerzeichen ein, wandert die Zeile in den Körper des if und gibt nur dann etwas aus, wenn die Bedingung erfüllt ist.

Ein Programmablaufplan zeigt dieselbe Wahl als Raute. Der True-Pfad führt in den Körper, der False-Pfad daran vorbei, und beide Pfade treffen sich bei der nächsten Anweisung außerhalb des Blocks.

Python meldet bei diesen Problemen möglicherweise SyntaxError, IndentationError oder TabError. Prüfe zuerst die Kopfzeile und die Einrückung rund um die gemeldete Zeile. Runde Klammern um die Bedingung sind optional; if temperature > 30: ist die übliche Form.

Ein Körper darf nicht leer sein. Willst du einen Platz für eine spätere Aktion freihalten, schreibst du ein eingerücktes pass. Das ist eine gültige Anweisung, die nichts tut:

if temperature > 30:
    pass

Getrennte Prüfungen sind unabhängig

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

Python erreicht beide Kopfzeilen. Beide Bedingungen sind wahr, daher werden beide Meldungen ausgegeben. Getrennte if-Anweisungen passen zu Regeln, deren Aktionen alle für dieselbe Eingabe gelten können.

Gib späterem Code einen Wert, den er verwenden kann

Ein Name, der nur im Körper zugewiesen wird, entsteht unter Umständen nie:

x = 0
if x > 0:
    message = "positive"
print(message)

In einem frisch gestarteten Skript wird der Körper übersprungen, und message hat keinen Wert, daher löst die letzte Zeile einen NameError aus. Eine Lösung ist, vor der Verzweigung einen Startwert festzulegen:

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

Jetzt hat die spätere Zeile auf beiden Pfaden einen Wert. Für null gibt sie not positive aus; für ein positives x ersetzt der Körper diesen Text durch positive.

Eine if–else-Anweisung wählt einen von zwei Blöcken. Ist die Bedingung wahr, führt Python den if-Körper aus, sonst den else-Körper. Erreicht die Ausführung diese Verzweigung, wird genau einer von beiden ausgeführt.

Richte die Alternativen bündig aus

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

Bei der Eingabe 14 ist der Rest 0, daher lautet die Ausgabe 14 is even. Bei der Eingabe -7 ist der Rest 1, daher lautet die Ausgabe -7 is odd. Das else gehört zu dem if auf derselben Einrückungsebene. Sein Körper hat eine eigene Einrückung.

Nach else steht keine Bedingung: Es bedeutet, dass die vorherige Bedingung falsch war. else number < 0: ist ein Syntaxfehler. Schreibe die Klausel direkt nach den if-Körper; eine fremde, nicht eingerückte Anweisung dazwischen zerstört die Struktur.

Prüfe, was „alles andere“ umfasst

Bei if answer == "yes": bedeutet ein else nicht nur "no". Es erfasst auch "maybe", "Yes" und "", weil keiner dieser Werte gleich "yes" ist. Das ist nützlich, wenn alle übrigen Eingaben dieselbe Aktion verdienen. Brauchen mehrere abgelehnte Eingaben unterschiedliche Reaktionen, sind weitere Prüfungen nötig.

Weise auf beiden Pfaden zu

Eine Versandregel gewährt ab einem Gesamtbetrag von 50 € kostenlosen Versand und berechnet sonst 5,99 €:

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

Zuerst ergibt 42.50 >= 50 den Wert False. Python überspringt die Zuweisung von 0, führt das else aus und speichert 5.99. Die letzte Zeile steht außerhalb beider Körper und gibt 48.49 aus. Ändere total in 60: Der erste Körper speichert 0, der andere wird übersprungen, und die letzte Zeile gibt 60 aus. Auf beiden Wegen wird shipping definiert, bevor es verwendet wird.

Wähle einen Wert mit einem bedingten Ausdruck

Wenn sich die Zweige nur im zugewiesenen Wert unterscheiden, kann ein bedingter Ausdruck das in einer Zeile ausdrücken:

shipping = 0 if total >= 50 else 5.99

Seine Form ist value_if_true if condition else value_if_false. Obwohl der Wert für den wahren Fall zuerst dasteht, wertet Python zuerst die Bedingung aus. Es wertet nur den gewählten Wert aus und weist das Ergebnis dann shipping zu.

Ein weiteres Beispiel ist label = "even" if n % 2 == 0 else "odd". Für n = 14 wählt der Ausdruck "even", für n = -7 wählt er "odd".

Der Ausdruck braucht beide Werte. x = 1 if flag ist unvollständig und löst einen SyntaxError aus, weil der else-Wert fehlt. Eine vollständige if-Anweisung darf else weglassen, weil sie auf dem False-Pfad einfach nichts tun kann; ein Ausdruck muss trotzdem einen Wert liefern.

Mit elif, kurz für „else if“, ergänzt du eine Entscheidung um eine weitere Prüfung. Python prüft die Bedingungen von oben nach unten. Die erste wahre Bedingung gewinnt, und der Rest der Kette wird übersprungen.

Verfolge eine Notenentscheidung

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

Die erste Prüfung, 85 >= 90, ist falsch. Die zweite, 85 >= 80, ist wahr, daher speichert Python "B". Die übrigen Bedingungen prüft es nicht, und den else-Zweig betritt es nicht. Die Ausgabe ist B.

Nutze, was frühere fehlgeschlagene Prüfungen verraten

Wird elif score >= 80: erreicht, steht bereits fest, dass die Punktzahl unter 90 liegt. Bei ganzzahligen Punktzahlen deckt dieser Zweig 80 bis 89 ab. Ein zusätzliches and score < 90 würde eine Prüfung wiederholen, die das Programm schon erledigt hat.

Die Reihenfolge ist wichtig, weil sich diese Bereiche überschneiden. Steht score >= 60 zuerst, erfasst diese Prüfung 85 und 95, bevor die Prüfungen für die besseren Noten erreicht werden. Bei Prüfungen auf eine untere Schranke mit >= stellst du den höchsten Schwellenwert an den Anfang. Bei Prüfungen auf eine obere Schranke mit < beginnst du mit dem niedrigsten.

Fasse eine Entscheidung in einer Kette zusammen

Ersetzt du die Schlüsselwörter elif durch if, ändert sich das Verhalten. Bei einer Punktzahl von 85 weist die Prüfung für 80 den Wert "B" zu, danach die Prüfung für 70 den Wert "C" und die Prüfung für 60 den Wert "D". Der Endwert ist "D". Jedes neue if beginnt eine unabhängige Entscheidung.

Dieser Unterschied betrifft auch else. In einer Gruppe getrennter if-Anweisungen gehört ein abschließendes else nur zu seinem passenden if, nicht zur ganzen Gruppe. Halte die Zweige zusammen, wenn sie eine einzige Einteilung darstellen.

Denk an Grenzen und Eingaben, die zu keinem Fall passen

Eine elif-Kette kann beliebig viele weitere Prüfungen haben, und ihr abschließendes else ist optional. Ohne Auffangzweig wird unter Umständen kein Körper ausgeführt:

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

Keine der beiden Bedingungen ist erfüllt. Ergänze else: mit einem eingerückten print("Comfortable"), wenn jede Temperatur eine Meldung braucht. Ebenso lässt t < 18, gefolgt von t > 18, genau 18 unberücksichtigt. Bei den Notenschwellen würde score > 90 den Wert 90 in den "B"-Zweig schicken.

Textmenüs haben denselben Aufbau: Prüfe choice == "1", dann choice == "2", und reagiere auf alles andere mit "Unknown option". Diese Prüfungen vergleichen Zeichenketten, weil input() Text zurückgibt. Wenn viele Prüfungen einen Wert mit festen Auswahlmöglichkeiten vergleichen, bietet match eine andere Möglichkeit, die Entscheidung aufzubauen.

Mit den booleschen Operatoren and, or und not baust du eine Bedingung aus einfacheren Bedingungen auf. Python schreibt sie als kleingeschriebene Wörter.

Lies alle Möglichkeiten ab

Bei booleschen Eingangswerten ergibt and nur dann True, wenn beide wahr sind. or ergibt True, wenn mindestens einer wahr ist, auch wenn beide wahr sind. Das ist ein einschließendes Oder.

not kehrt einen Wahrheitswert um: not True ergibt False, und not False ergibt True. Eine Wahrheitstabelle listet jede Kombination boolescher Eingangswerte auf. Zwei Eingangswerte brauchen vier Zeilen, drei brauchen acht. Jeder zusätzliche unabhängige boolesche Eingangswert verdoppelt die Anzahl der Kombinationen.

Für A and not B kehrst du zuerst B um und verknüpfst das Ergebnis dann mit A. In der Zeile A = True, B = False ist not B gleich True, also ist das Ergebnis True. Die anderen drei Zeilen ergeben False.

Übersetze eine Regel in vollständige Prüfungen

Ein Museum ermäßigt den Eintritt für Besucher unter 12 oder ab 65 Jahren:

has_discount = age < 12 or age >= 65

Beim Alter 10 ist der erste Vergleich erfüllt, bei 65 der zweite. Die Alterswerte 30 und 64 erfüllen keinen der beiden. Mit and müsste dasselbe Alter zugleich unter 12 und mindestens 65 sein, was unmöglich ist.

Ein Fahrgeschäft verlangt eine Körpergröße von mindestens 120 Zentimetern und keine Herzerkrankung:

can_ride = height >= 120 and not has_heart_condition

Beide Anforderungen müssen zugleich erfüllt sein. Bei der Mindestgröße und has_heart_condition = False sind beide Teile erfüllt. Ist eine der Anforderungen nicht erfüllt, ist can_ride gleich False.

Unterscheide innerhalb und außerhalb eines Bereichs

Der Test auf „innerhalb“ braucht beide Schranken. Der Test auf „außerhalb“ braucht eine der beiden Überschreitungen. score < 0 and score > 100 kann für eine einzelne Zahl nie wahr sein.

Jeder Vergleich braucht beide Seiten. score >= 0 and <= 100 ist unvollständige Syntax. Ein subtileres Problem läuft ohne Fehlermeldung:

if answer == "y" or "yes":
    print("Accepted")

Python liest (answer == "y") or "yes". Ist der Vergleich falsch, sorgt die nicht leere Zeichenkette "yes" trotzdem dafür, dass die Bedingung als wahr ausgewertet wird. Wiederhole den Vergleich: answer == "y" or answer == "yes".

Alltagssprache braucht dieselbe Sorgfalt. „Am Samstag und Sonntag geschlossen“ bedeutet day == "Saturday" or day == "Sunday"; ein Tag muss nicht beide Namen zugleich haben. Eine boolesche Variable verneinst du direkt mit not is_member. Einen verneinten Vergleich wie not (age >= 18) kannst du auch einfacher als age < 18 schreiben. Die Operatoren von Python sind hier Wörter, nicht &&, || oder !.

Bei einer längeren Bedingung sind zwei Fragen zu klären: wie ihre Teile gruppiert werden und welche Teile Python tatsächlich auswertet. Der Operatorvorrang beantwortet die erste Frage, die Kurzschlussauswertung die zweite.

Lies zuerst die Gruppierung ab

Für die hier verwendeten Operatoren reicht der Vorrang von stärker zu schwächer bindend:

1. Potenzierung: **.
2. Multiplikation, Division, abrundende Division, Rest: *, /, //, %.
3. Addition und Subtraktion: +, -.
4. Vergleiche, einschließlich in, not in, is und is not.
5. not, dann and, dann or.
6. Der bedingte Ausdruck: a if condition else b.

Runde Klammern ändern die Gruppierung. So wird zum Beispiel x > 3 or x < 0 and x != 5 als x > 3 or (x < 0 and x != 5) gruppiert. Bei x = 5 ist der linke Vergleich wahr, und die gesamte rechte Gruppe wird übersprungen. Das Ergebnis ist True.

Bei (x > 3 or x < 0) and x != 5 machen die Klammern dagegen die erste Gruppe zu einem Operanden von and. Bei x = 5 ist diese Gruppe wahr, aber x != 5 ist falsch, daher ist das Ergebnis False.

Deshalb akzeptiert is_weekend or is_holiday and is_sunny jedes Wochenende, auch bei Regen. Für die Regel „ein freier Tag, der außerdem sonnig ist“ schreibst du (is_weekend or is_holiday) and is_sunny.

Verfolge die Auswertung von links nach rechts

Bei and hat ein falscher erster Teil die gesamte Anforderung bereits ausgeschlossen. Bei or hat ein wahrer erster Teil sie bereits erfüllt. Der Vorrang zwingt Python nicht, einen übersprungenen Operanden zu berechnen, nur weil er stärker bindende Operatoren enthält.

Das kannst du nutzen, um eine Schutzbedingung vor eine Operation zu setzen, die sonst fehlschlagen würde:

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 ist falsch, daher versucht Python 50 / 0 gar nicht erst. Es speichert False und gibt es aus. Vertauschst du die Operanden, wird zuerst die Division versucht, und es kommt zu einem ZeroDivisionError; die spätere Prüfung kann eine frühere Berechnung nicht schützen.

Ziehe not in eine geklammerte Prüfung hinein

Die de Morganschen Gesetze formen eine Verneinung um, indem sie jeden Teil umkehren und den verbindenden Operator austauschen:

„Kein Teenager“ lässt sich als not (age >= 13 and age <= 19) prüfen. Der äquivalente direkte Test ist age < 13 or age > 19. Die Alterswerte 12 und 20 bestehen ihn, 13, 16 und 19 nicht.

Behältst du and bei, nachdem du beide Teile verneint hast, ändert sich die Regel. Bei A = True, B = False ist not (A and B) wahr, aber not A and not B falsch. Vergleiche jede Zeile der Wahrheitstabelle, wenn du prüfst, ob zwei boolesche Formen äquivalent sind.

Für eine Variable, die bereits einen booleschen Wert enthält, schreibst du if is_valid: oder if not is_valid:. Ein Vergleich mit True oder False fügt eine Prüfung hinzu, die die Bedingung nicht braucht.

Eine verschachtelte Verzweigung setzt eine Entscheidung in einen Zweig einer anderen. Die innere Entscheidung wird nur erreicht, wenn die Ausführung diesen äußeren Zweig betritt. Jede Verschachtelungsebene fügt 4 Leerzeichen Einrückung hinzu.

Verfolge die äußere Wahl vor der inneren

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

Zuerst ist has_ticket wahr, daher betritt Python den äußeren Körper. Dann prüft es 15 >= 13, erhält wahr und gibt Enjoy the movie aus. Die Körper des inneren und des äußeren else werden beide übersprungen.

Ändere das Alter auf 10 und lass das Ticket unverändert. Python betritt weiterhin den äußeren Körper, aber die innere Bedingung ist nicht erfüllt, daher gibt es This movie needs an adult aus. Mit has_ticket = False wird die Altersprüfung nie erreicht; das äußere else gibt Please buy a ticket first aus.

Ordne jedes else über die Einrückung zu

Ein else gehört zu dem if auf seiner eigenen Einrückungsebene. Verschiebst du es, kann sich das Verhalten ändern, auch wenn das Skript gültig bleibt. Betrachte diese kleinere Variante:

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

Das else gehört zu if has_ticket:. Ein 10-jähriges Kind mit Ticket erhält keine Meldung. Rückst du dieses else samt seinem Körper um eine Ebene nach innen, gehört es stattdessen zu if age >= 13:. Jetzt erhält dasselbe Kind Buy a ticket, während jemand ohne Ticket keine Meldung erhält. Die geänderte Anordnung drückt eine andere Regel aus.

Im vollständigen Kinobeispiel hat das innere if bereits ein else. Würdest du dort das äußere else nach innen verschieben, entstünden zwei Alternativen für dasselbe if, und es käme zu einem Syntaxfehler.

Flache zwei Anforderungen ab

Gibt es nur eine Aktion und hat keine der beiden Ebenen ein else, lässt sich mit and oft eine Verschachtelungsebene einsparen:

if is_member and total >= 50:
    print("Free shipping")

Das führt dieselbe Aktion aus wie ein äußeres if is_member: mit einem inneren if total >= 50:. Beide Anforderungen müssen erfüllt sein, und die zweite wird erst erreicht, wenn die erste erfüllt ist. Behalte die Verschachtelung bei, wenn die äußeren Zweige eigene, unterschiedliche Aktionen brauchen, wie beim Ticketkauf.

Ein else, dessen einzige Aktion eine weitere if–else-Anweisung ist, kann zu einer elif-Kette werden. Für positiv, negativ und null lautet die flache Form if x > 0:, dann elif x < 0:, dann else:. Sie behält dieselben drei Ergebnisse bei weniger Einrückung bei.

Validiere, bevor du einordnest

Eine Notenentscheidung muss Punktzahlen außerhalb des zulässigen Bereichs zurückweisen, bevor sie einen Notenbuchstaben vergibt:

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

Bei score = 150 schlägt die äußere Prüfung fehl, daher wird keine Note vergeben. Verschachtelung macht auch unmögliche Pfade sichtbar: Ein inneres if x < 5: unter if x > 10: kann nie erfüllt sein. Wird die Einrückung tief, suche nach Anforderungen, die sich zusammenfassen lassen, nach einer elif-Kette oder nach einer früheren Validierung, die die übrigen Pfade übersichtlicher macht.

Python kann einen Wert direkt in einer Bedingung prüfen. Seine Wahrheitswertauswertung entscheidet, ob der Körper ausgeführt wird. Das spart Vergleiche, aber das Ergebnis der Wahrheitswertauswertung kann von dem abweichen, was der Text des Werts zu sagen scheint.

Erkenne als falsch ausgewertete Werte

Bei den hier verwendeten eingebauten Datentypen werden False, None, die Zahl null, leere Zeichenketten und leere Sammlungen als falsch ausgewertet. Zahlen ungleich null und nicht leere Zeichenketten oder Sammlungen werden als wahr ausgewertet.

bool() wandelt einen Wert in seinen booleschen Wahrheitswert um. In einer Bedingung wählt if value: denselben Zweig wie if bool(value):. Der gespeicherte Wert wird dabei nicht in einen booleschen Wert umgewandelt.

Prüfe auf leere Eingaben, ohne sie falsch zu deuten

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Drückst du die Eingabetaste, ohne etwas einzutippen, ergibt das "", daher wird der zweite Körper ausgeführt. Ein Name, der nur aus Leerzeichen besteht, ist nicht leer und besteht den ersten Test. if name.strip(): prüft dagegen den Text, nachdem die Leerraumzeichen am Rand entfernt wurden, sodass auch eine Antwort aus lauter Leerzeichen durchfällt.

Eine Ja-Nein-Antwort braucht eine andere Frage. if answer: führt seinen Körper für "no" und "False" aus, weil beide Zeichen enthalten. Um eine Zustimmung zu erkennen, vergleichst du den Text, zum Beispiel mit answer == "yes". Die Wahrheitswertauswertung prüft, ob etwas leer ist, nicht, was ein Wort bedeutet.

Unterscheide eine zulässige Null von fehlenden Daten

Angenommen, quantity ist None, solange noch kein Wert angegeben wurde, und kann zulässigerweise 0 sein. if quantity: lehnt beides ab. Verwende quantity is not None, um zu fragen, ob ein Wert vorhanden ist; dieser Test akzeptiert null.

Bei einer echten booleschen Variablen ist die direkte Prüfung klar. Bei anderen Werten tut x == True etwas anderes als if x:. Mit x = 5 besteht der Test über die Wahrheitswertauswertung, aber 5 == True ist falsch; bei der Gleichheit von Zahlen gilt True als gleich 1, nicht als gleich jeder Zahl ungleich null.

and und or geben einen der geprüften Werte zurück

Diese Operatoren geben einen Operanden zurück, der nicht unbedingt ein boolescher Wert ist:

Bei or gibt Python den linken Wert zurück, wenn er als wahr ausgewertet wird; andernfalls wertet es den rechten Wert aus und gibt ihn zurück. Bei and gibt es den linken Wert zurück, wenn er als falsch ausgewertet wird; andernfalls wertet es den rechten Wert aus und gibt ihn zurück.

display_name = name or "Guest" liefert einen Standardwert für eine leere Eingabe. Dasselbe Vorgehen ersetzt mit quantity or 1 eine echte Null durch 1. Setze einen Standardwert auf diese Weise nur ein, wenn jeder als falsch ausgewertete Wert „fehlt“ bedeutet. not verhält sich anders: Es gibt immer True oder False zurück. Muss eine gespeicherte Merkvariable boolesch sein, wandelt has_name = bool(name or nickname) den ausgewählten Text in einen Wahrheitswert um.

Ein Skript kann ohne Syntaxfehler laufen und trotzdem den falschen Zweig wählen. Beim Nachvollziehen des Programmablaufs verfolgst du einen Durchlauf von Hand. Beim Testen führst du das Programm mit ausgewählten Eingaben aus und vergleichst das beobachtete Ergebnis mit dem Ergebnis, das die Regel verlangt.

Plane einen Pfad und vollziehe ihn nach

Bevor du Code schreibst, formulierst du die Entscheidungen als Schritte in Alltagssprache, also als Pseudocode. Ein Programmablaufplan stellt jede Bedingung als Raute mit True- und False-Pfeil dar. Beide Pfade brauchen einen klaren nächsten Schritt oder ein Ende.

Um Code nachzuvollziehen, notierst du die Startwerte, wertest jede erreichte Bedingung aus, hältst Zuweisungen fest und schreibst die Ausgabe exakt ab. Für die Notenkette mit score = 72:

„Nicht ausgewertet“ ist etwas anderes als falsch. Python hat bereits einen Zweig gewählt und braucht die späteren Vergleiche daher nicht.

Decke jeden Zweig und jede Grenze ab

Eine Kette mit vier Zweigen braucht mindestens vier Eingaben, damit jeder Zweig einmal ausgeführt wird. Wähle sie nach den vorgesehenen Wegen aus, nicht danach, wie verschieden die Zahlen aussehen. Mehrere hohe Punktzahlen führen womöglich alle durch denselben ersten Körper.

Zweigüberdeckung allein übersieht unter Umständen eine falsche Grenze. Für age >= 18 testest du 17, 18 und 19. Ein irrtümliches > verhält sich bei den beiden äußeren Werten wie erwartet, weist aber genau den Grenzwert ab. Für die Notenschwelle 90 vergleichst du 89, 90 und 91; an den anderen Schwellen gehst du genauso vor. Bei Dezimaleingaben wählst du benachbarte Werte, die zur Genauigkeit der Messung passen.

Finde Zweige, die nie ausgeführt werden können

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

Der zweite Zweig ist unerreichbar. Jede Punktzahl ab 90 hat bereits die erste Prüfung bestanden. Stelle den strengeren Schwellenwert an den Anfang, oder passe die Bereiche an die beabsichtigte Regel an.

Eine Lücke lässt einen beabsichtigten Fall unbehandelt: t < 0, gefolgt von t > 0, überspringt die Null. Eine Überschneidung kann mehrere unabhängige Aktionen auslösen: Die getrennten Prüfungen t >= 0 und t <= 10 sind für 5 beide erfüllt. Eine Kette lässt nur ihren ersten wahren Zweig zu, aber ihre Reihenfolge entscheidet trotzdem, welche der sich überschneidenden Bedingungen gewinnt.

Teste auch unbequeme Eingaben

Teste negative Werte, null, leeren Text und großgeschriebene Antworten, wenn das Skript Kleinbuchstaben erwartet. Werden nur "y" und "n" akzeptiert, gib auf jeden anderen Text eine klare Antwort wie "Please answer y or n".

Verhält sich ein Test unerwartet, untersuche den Wert und seinen Datentyp, bevor du den verdächtigen Vergleich auswertest:

print(repr(age), type(age))

Für age = "18" gibt das '18' <class 'str'> aus. Wandle den Text um, bevor du age >= 18 ausprobierst; würdest du den fehlerhaften Vergleich in dasselbe print() zur Fehlersuche schreiben, käme es zu einem TypeError, bevor die diagnostische Ausgabe erscheint. Bei Fehlern im Aufbau prüfst du die Einrückung und die Syntaxfehlermeldung.

Schließlich kann ein Vergleich eine boolesche Merkvariable (Flag) direkt setzen: is_adult = age >= 18. Das ersetzt zwei Zweige, die nur True bzw. False zuweisen. Verwende bool(), wenn der zugrunde liegende Ausdruck eine andere Art von Wert liefern kann.

Eine match-Anweisung, verfügbar ab Python 3.10, gleicht einen Wert nacheinander mit einer Reihe von Mustern ab. Dieser Wert ist das Vergleichsobjekt. Jedes case liefert ein Muster und einen eingerückten Körper.

Verfolge den ersten passenden Fall

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

Das Vergleichsobjekt ist "stop". Es passt nicht auf "start", daher probiert Python den nächsten Fall. "stop" passt, und der Körper gibt Stopping aus. Danach verlässt Python die gesamte match-Anweisung und gibt Ready aus. Nur ein Fallkörper wird ausgeführt; die Ausführung läuft nicht in den nächsten Körper weiter, und ein break ist nicht nötig.

Das Vergleichsobjekt "jump" erreicht das abschließende Platzhaltermuster _, das jeden Wert akzeptiert. Die Ausgabe ist Unknown command, dann Ready. Ohne diesen Fall führt ein Vergleichsobjekt, auf das nichts passt, einfach keinen Fallkörper aus, und das Programm macht nach der Anweisung weiter.

Halte Aufbau und Auffangfall in Ordnung

Die case-Kopfzeilen sind unter match um 4 Leerzeichen eingerückt, ihre Körper um weitere 4 Leerzeichen. Jede Kopfzeile endet mit einem Doppelpunkt. Ein case _: ohne Fallbedingung muss der letzte Fall sein, weil es alles akzeptiert. Stehen weitere Fälle danach, kommt es zu einem SyntaxError: Diese späteren Muster könnten nie erreicht werden.

Ein Platzhalter mit Fallbedingung darf weiter oben stehen, weil seine zusätzliche Bedingung falsch sein kann. Eine match-Anweisung in einem Skript ohne Schleifen kann außerdem kein break enthalten; diese Anweisung braucht eine umgebende Schleife.

Verstehe, wie Literale passen

Ein Literalmuster besteht aus einer festen Zahl, einer Zeichenkette, True, False oder None. Muster aus Zeichenketten passen nur exakt und beachten Groß- und Kleinschreibung: "stop" passt nicht auf "Stop". Zahlenmuster beruhen auf Gleichheit, daher passt case 1: auf 1, 1.0 und True, das gleich 1 ist.

Die Muster True, False und None beruhen dagegen auf Identität. Deshalb passt case True: auf den booleschen Wert True, aber nicht auf die ganze Zahl 1. Die Reihenfolge der Muster ist wichtig, wenn ein Zahlenfall und ein boolescher Fall beide das Vergleichsobjekt akzeptieren könnten.

Verbinde feste Alternativen mit einem senkrechten Strich

Ein Oder-Muster verbindet Alternativen mit |:

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

Bei 6 wird der erste Körper ausgeführt, bei 3 der zweite, bei 9 der Platzhalterfall. Ohne int() bleibt die Eingabe "6" eine Zeichenkette und passt nicht auf die Zahl 6.

Verwende das Trennzeichen für Muster |, nicht das boolesche Wort or. case "y" or "yes": ist ungültig, case "y" | "yes": ist gültig.

Bei festen Befehlen kann eine if–elif-Kette mit Gleichheitstests dieselben Ausgaben erzeugen. Wähle den Aufbau, bei dem sich die Fälle am leichtesten lesen lassen.

Muster können mehr, als ein festes Literal zu prüfen. Ein Muster kann dem Vergleichsobjekt einen Namen geben, und eine Fallbedingung kann eine zusätzliche Bedingung prüfen, bevor der Fall akzeptiert wird.

Erst binden, dann die Fallbedingung prüfen

Ein Bindungsmuster ist ein einfacher Name wie n. Es akzeptiert jedes Vergleichsobjekt und weist es dem Namen zu. Eine Fallbedingung folgt dem Muster mit if condition; der Körper wird nur ausgeführt, wenn das Muster passt und die Fallbedingung wahr ist.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

Bei -5 passt das erste Literal nicht. Das nächste Muster bindet -5 an t und prüft dann t < 0. Die Fallbedingung ist wahr, daher lautet die Ausgabe Below freezing by 5 degrees.

Bei 0 gewinnt der Literalfall, bevor die Bindung versucht wird. Bei 12 gelingt die Bindung, aber die Fallbedingung ist falsch, daher probiert Python den Platzhalter und gibt Above freezing aus. Eine nicht erfüllte Fallbedingung beendet die Suche nach einem passenden Fall nicht.

Ein einfacher Name schlägt keine Konstante nach

Angenommen, QUIT = "q". Es liegt nahe, case QUIT: zu schreiben, um zu prüfen, ob das Vergleichsobjekt diesem Wert gleich ist. Ein einfacher Name ist aber immer eine Bindung, auch wenn er großgeschrieben ist. Der Fall akzeptiert jedes Vergleichsobjekt und überschreibt QUIT damit.

Folgen einer Bindung ohne Fallbedingung weitere Fälle, meldet Python einen Syntaxfehler, weil die Bindung sie unerreichbar macht. Steht die Bindung am Ende, kann der Fehler unbemerkt bleiben. Vergleiche ausdrücklich mit einer Fallbedingung:

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Hier bindet k den Wert "x". Die Fallbedingung vergleicht ihn mit dem vorhandenen "q", ist nicht erfüllt und überlässt dem Platzhalter die Ausgabe Keep working. Ein Literal case "q": ist einfacher, wenn sich der feste Wert direkt hinschreiben lässt.

Erkenne ein Wertmuster mit Punkt

Ein Name mit Punkt wie math.pi ist ein Wertmuster, keine Bindung. Es schlägt einen vorhandenen Wert nach und vergleicht das Vergleichsobjekt mit == damit. Benannte Konstanten aus Modulen oder Klassen lassen sich in dieser Form verwenden. Der entscheidende Unterschied ist der Punkt: case n: weist einem Namen einen Wert zu; ein Muster mit Punkt prüft einen vorhandenen Wert.

Benenne einen erfolgreichen spezifischen Treffer mit as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

Das Oder-Muster prüft die erlaubten Zeichenketten, und as speichert das passende Vergleichsobjekt in accepted. Für "y" lautet die Ausgabe Accepted: y. Die Eingabe wird nicht durch ein Standardwort ersetzt: "yes" würde "yes" speichern. "Yes" passt auf keine der beiden Zeichenketten, weil die Groß- und Kleinschreibung weiterhin zählt.

Ein oder zwei Fallbedingungen fügen sich gut zwischen feste Fälle ein. Ist fast jeder Fall eine Bereichsprüfung oder betrifft er verschiedene Variablen, ist eine if–elif-Kette meist übersichtlicher. Beide Strukturen brauchen am Ende einen Auffangfall, wenn jede Eingabe eine Reaktion erhalten muss.