Python and, or, not: logische Operatoren, Kurzschluss-Auswertung und Wahrheitswerte

Drei Wörter statt Symbole

Die logischen Operatoren von Python sind die englischen Wörter and, or und not. Andere Sprachen schreiben sie als &&, || und !. In Python sind && und || ein SyntaxError, und ! kommt nur als Teil von != („ungleich“) vor.

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: both must be true
print(has_ticket or is_adult)    # True: at least one is true
print(not is_adult)              # True: flips the value

Mit True und False gelten die Regeln, die du erwartest:

and braucht zwei wahre Seiten. or braucht mindestens eine. not nimmt einen einzelnen Wert und kehrt ihn um.

In echtem Code sind die Seiten meist Vergleiche, und das Ergebnis landet in einem if oder einem while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

Ausgabe:

eligible
standard ticket

Für die meisten Bedingungen reicht das. Der Rest dieser Seite zeigt, was die Operatoren mit Werten machen, die nicht True oder False sind, und nach welchen Regeln entschieden wird, welche Seite eines Ausdrucks ausgeführt wird.

Truthy und falsy Werte

and, or und not akzeptieren jeden Wert, nicht nur Booleans. Ob ein Wert als wahr gilt, entscheidet Python anhand seines Wahrheitswerts. Diese Werte sind falsy:

• False und None
• die Null jedes Zahlentyps: 0, 0.0
• leere Container und Strings: "", [], (), {}, set(), range(0)

Alles andere ist truthy, auch "0", "False", [0] und -1. Wie Python einen Wert einordnet, siehst du mit bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

Ausgabe:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

Der String "0" ist truthy, weil er ein nicht leerer String ist. Darauf fällt herein, wer Zahlen aus einer Eingabe liest und sie vor der Umwandlung prüft. Wie bool mit int zusammenhängt, steht auf der Seite zu Zahlen und Booleans.

and und or geben einen Operanden zurück

Hier unterscheidet sich Python von den meisten Sprachen. and und or erzeugen kein neues True oder False. Sie geben einen der beiden Werte zurück, die du ihnen gegeben hast:

• x or y liefert x, wenn x truthy ist, sonst liefert es y.
• x and y liefert x, wenn x falsy ist, sonst liefert es y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, and no ZeroDivisionError

Wenn beide Operanden Booleans sind, ist „einen Operanden zurückgeben“ dasselbe wie „einen Boolean zurückgeben“. Deshalb fällt der Unterschied erst auf, wenn andere Typen ins Spiel kommen.

not ist die Ausnahme: Es liefert immer True oder False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

Wenn du aus einem and/or-Ausdruck einen echten Boolean brauchst, etwa um ihn zu speichern oder aus einer Funktion zurückzugeben, die bool verspricht, pack ihn in bool():

name = "Ada"
email = ""

print(name and email)         # prints an empty line: the value is ""
print(bool(name and email))   # False

Kurzschluss-Auswertung

Python wertet and und or von links nach rechts aus und hört auf, sobald die Antwort feststeht:

• and stoppt beim ersten falsy Wert, weil nichts danach den ganzen Ausdruck noch wahr machen kann.
• or stoppt beim ersten truthy Wert, weil nichts danach den ganzen Ausdruck noch falsch machen kann.

Die übersprungene Seite wird gar nicht ausgeführt. Mit Funktionen, die beim Aufruf etwas ausgeben, kannst du dabei zusehen:

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

Ausgabe:

and:
  checking A
False
or:
  checking A
True

B wird in keinem der beiden Fälle geprüft. Die Kurzschluss-Auswertung macht Schutzbedingungen sicher. Die zweite Hälfte jeder Bedingung unten würde allein abstürzen, läuft aber erst, nachdem die erste Hälfte den problematischen Fall ausgeschlossen hat:

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

Setz den billigen oder schützenden Test an den Anfang. Mit umgekehrter Reihenfolge, user.startswith("admin") and user is not None, gibt es einen AttributeError, wenn user gleich None ist.

Muster mit or und and

Weil or seinen ersten truthy Operanden zurückgibt, ergibt es einen Standardwert in einer Zeile:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

Ausgabe:

Hello, Ada!
Hello, guest!
Hello, guest!

Der Haken: or ersetzt jeden falsy Wert, nicht nur None. Wenn 0, "" oder [] eine zulässige Eingabe ist, wirft or sie weg:

volume = 0
print(volume or 50)                           # 50: the 0 was replaced

print(volume if volume is not None else 50)   # 0: only None is replaced

Nimm x if x is not None else default, wenn null oder leer ein gültiger Wert ist. Diesen bedingten Ausdruck erklärt die if/else-Seite.

Zu and gibt es ein passendes Muster: „nimm diesen Wert nur, wenn der erste gesetzt ist“. Es ist seltener und als if oft klarer, also setz es sparsam ein:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

Rangfolge: not, dann and, dann or

Wenn ein Ausdruck alle drei mischt, wendet Python zuerst not an, dann and, dann or. Vergleiche wie ==, < und in kommen vor allen dreien.

a, b, c = True, False, False

print(a or b and c)      # True: read as a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: read as (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: read as not (1 == 2)

a or b and c und (a or b) and c liefern bei denselben Werten unterschiedliche Antworten. Eine gemischte Bedingung sollte deshalb Klammern tragen, auch wenn die Standardreihenfolge zufällig stimmt. Sie kosten nichts und ersparen der nächsten Person die Frage.

and/or vs. &/|

& und | sehen and und or ähnlich und liefern manchmal dieselbe Antwort, sind aber andere Operatoren.

• and / or prüfen den Wahrheitswert, werten mit Kurzschluss aus und geben einen der Operanden zurück.
• & / | sind bitweise Operatoren. Bei Ganzzahlen verknüpfen sie die Bits der beiden Zahlen. Bei Sets bedeuten sie Schnittmenge und Vereinigung. Bei True und False liefern sie einen Boolean. Sie werten nie mit Kurzschluss aus: Beide Seiten werden immer ausgewertet.

print(6 and 3)   # 3: 6 is truthy, so and returns the second operand
print(6 & 3)     # 2: 110 & 011 = 010 in binary

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

Die bitweisen Operatoren haben außerdem eine höhere Rangfolge als Vergleiche. Dadurch wird eine mit & geschriebene Bedingung zu etwas völlig anderem:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: read as x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, but the parentheses are required

1 & y ist 1 & 5, also 1. Die mittlere Zeile wird damit zur Kette 5 > 1 > 1, und 1 > 1 ist falsch. In normalem Python-Code nimmst du für Bedingungen and, or und not.

Der eine Ort, an dem &, | und ~ für Bedingungen richtig sind, sind NumPy und pandas. Ein Array enthält viele Werte und hat deshalb keinen einzelnen Wahrheitswert, und and wirft ValueError: The truth value of an array ... is ambiguous. Die Bibliotheken überladen & und | so, dass sie Element für Element arbeiten. Deshalb sehen pandas-Filter aus wie df[(df.age > 18) & (df.country == "CA")], mit Klammern um jeden Vergleich, aus dem oben genannten Grund der Rangfolge.

any() und all(): and und or über eine Liste

Um eine ganze Folge von Bedingungen zu verknüpfen, nimm die eingebauten Funktionen all() (ein and über alle Elemente) und any() (ein or über alle Elemente). Beide werten auf dieselbe Weise mit Kurzschluss aus:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: every score passed
print(any(s >= 90 for s in scores))   # True: at least one A
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nothing failed
print(any([]))   # False: nothing passed

Anders als and und or liefern any() und all() immer einen Boolean.

Häufige Fehler

Eine Variable mit or gegen mehrere Werte vergleichen. Diese Bedingung ist immer wahr:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

Python liest die erste Bedingung als (color == "red") or "blue". Der Vergleich ist False, also liefert or den Wert "blue", einen nicht leeren String, und der ist truthy. Wiederhole den Vergleich auf beiden Seiten oder, besser, prüf die Zugehörigkeit mit in.

&& oder || schreiben. Beides ist ein SyntaxError. Nimm and und or.

Von and/or einen Boolean erwarten. x = a or b speichert a oder b selbst. Das ist oft genau richtig, aber wenn eine Funktion True oder False zurückgeben soll, wandle mit bool() um.

Sich in gemischten Bedingungen auf die Rangfolge verlassen. a or b and c ist zulässig und eindeutig definiert, aber setz Klammern, damit sich niemand an die Regel erinnern muss.