Logische Operatoren in Python: Ein praxisnaher Einstieg

In der Programmierung müssen wir häufig Entscheidungen auf Basis mehrerer Bedingungen treffen. Zum Beispiel wollen wir eine Aktion nur dann ausführen, wenn mehrere Bedingungen gleichzeitig erfüllt sind. Oder wir möchten eine alternative Aktion starten, wenn eine von mehreren Bedingungen zutrifft.

Python stellt dafür eine Reihe logischer Operatoren bereit – and, or, not.

In diesem Tutorial lernst du, wie Python’s logische Operatoren funktionieren und wie du sie in der Programmierung und in der Data Science einsetzt. Zur begrifflichen Einordnung verwenden wir die Großschreibung AND, OR und NOT. Auf die Python-Schlüsselwörter verweisen wir in dieser Schreibweise: and, or und not.

Wenn du ein kuratiertes Python-Lernprogramm suchst, wirf einen Blick auf den sechsteiligen Python Programming Lernpfad.

Bevor wir ins Detail gehen, starten wir mit einer sehr kurzen Antwort für alle, die es eilig haben.

Kurzantwort: Was sind logische Operatoren in Python?

Python’s logische Operatoren (and, or, not) sind spezielle Schlüsselwörter, die in unserem Code als Verknüpfungen wirken: Sie verbinden mehrere Bedingungen in einem Ausdruck und werten sie gemeinsam aus.

Betrachte dieses Beispiel:

temperature = 25
is_sunny = True
if temperature > 20 and is_sunny:
    print("It's a perfect day for a picnic!")

It's a perfect day for a picnic!

Hier sorgt der and-Operator dafür, dass die Nachricht nur dann ausgegeben wird, wenn beide Bedingungen erfüllt sind: Die Temperatur liegt über 20 Grad und es ist sonnig.

Schauen wir uns ein weiteres Beispiel mit dem or-Operator an:

has_umbrella = False

if is_sunny or has_umbrella:
    print("Let's go for a walk!")

Let's go for a walk!

In diesem Fall gehen wir spazieren, wenn entweder die Sonne scheint oder wir einen Regenschirm dabeihaben.

Zuletzt kehrt der not-Operator den Wahrheitswert einer Bedingung um:

if not is_sunny:
    print("Maybe we should stay indoors.")

Hier wird die Nachricht nur gedruckt, wenn es nicht sonnig ist.

Logische Operatoren bieten eine knappe und zugleich starke Möglichkeit, komplexe Bedingungen auszudrücken und Programme Entscheidungen auf Basis mehrerer Faktoren treffen zu lassen. Schauen wir nun genauer hin und starten mit dem logischen Operator and.

Python: Der and-Operator

In der Booleschen Logik vergleicht eine AND-Operation zwei Werte oder Ausdrücke. Sie liefert nur dann wahr, wenn beide Werte wahr sind. Ist einer oder sind beide Werte falsch, ist das Ergebnis der AND-Operation falsch. Hier eine Zusammenfassung des Verhaltens von AND:

Diese Wahrheitstafel können wir mit Python’s and-Operator nachbauen:

options = True, False
for a in options:
    for b in options:
        print(f"{a} and {b} gives {a and b}")

True and True gives True
True and False gives False
False and True gives False
False and False gives False

Die Variable options enthält die beiden Booleschen Werte. Die geschachtelten for-Schleifen iterieren zweimal über options, um alle Kombinationen von True und False zu erzeugen.

Häufig enthalten die Ausdrücke, die als Operanden für and dienen, Vergleichs- oder Gleichheitsoperatoren:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
   if len(name) < 5 and name[0] == "J":
      print(name)

Jane

Der Name wird nur dann ausgegeben, wenn er weniger als fünf Buchstaben hat und mit "J" beginnt. Beide Anforderungen müssen erfüllt sein.

Vergleichs- und Gleichheitsoperatoren wie < und == ergeben True oder False.

Der Python-Operator and arbeitet jedoch mit beliebigen Datentypen, nicht nur mit den Booleschen True und False. Auch der Rückgabewert kann jeder Datentyp sein.

In diesem Abschnitt betrachten wir den and-Operator ausführlicher. Zuerst sprechen wir über Truthiness.

Python: truthy und falsy

Jedes Python-Objekt lässt sich mit der eingebauten Funktion bool() in einen Booleschen Wert umwandeln. Ein Objekt ist truthy, wenn bool(object) True zurückgibt. Für ein falsy-Objekt liefert bool(object) False.

Python’s and-Operator betrachtet die Truthiness seiner Operanden. Sind beide Operanden truthy, gibt and ebenfalls einen truthy Wert zurück. Ist einer oder sind beide Operanden falsy, liefert and einen falsy Wert. Beispiele:

if 42 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

Both operands are truthy

Betrachten wir nun dieses Beispiel:

if 42 and "":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

Und zum Schluss dieses Beispiel:

if 0 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

Zahlentypen wie Integer und Float sind truthy, wenn sie ungleich Null sind, und falsy, wenn sie gleich Null sind. Sequenzen wie Strings sind truthy, wenn sie nicht leer sind, und falsy, wenn sie leer sind.

Daher erfüllt nur das erste der drei Beispiele oben die Bedingung, dass beide Operanden truthy sein müssen, damit der and-Operator truthy ergibt.

Der and-Operator liefert nicht immer einen Booleschen Wert. Ein Ausdruck mit and kann auch zu einem der Operanden auswerten. Sehen wir uns das mit denselben Beispielen an, diesmal ohne if-Anweisung, sondern durch direkte Auswertung:

print(42 and "python")
print(42 and "")
print(0 and "python")

python

0

Erkennst du, was hier passiert?

Beginnen wir mit dem letzten Beispiel mit den Operanden 0 und "python". Der and-Operator erwartet zwei truthy Operanden. Da der erste Operand 0 ist, ist er falsy. Das Programm muss den zweiten Operanden nicht mehr prüfen, da der gesamte Ausdruck unabhängig vom zweiten Wert falsy sein wird.

Allerdings gibt der and-Operator nicht False zurück. Stattdessen liefert er direkt den ersten Operanden. Da dieser falsy ist, wertet der gesamte and-Ausdruck zu falsy aus. In Python ist das unproblematisch, denn überall dort, wo Python einen Wahrheitswert benötigt, wird die Truthiness eines Objekts verwendet.

Im ersten Beispiel ist der erste Operand 42, also truthy. Das Programm wertet den zweiten Operanden aus und gibt ihn zurück. Da der zweite Operand der String "python" ist und truthy ist, ist der gesamte Ausdruck truthy.

Im zweiten Beispiel ist der erste Operand ebenfalls 42. Da er truthy ist, wird der zweite Operand ausgewertet und zurückgegeben – hier der leere String. Ein leerer String ist falsy, also ist der gesamte and-Ausdruck falsy.

Wenn der erste Operand truthy ist, gibt der and-Operator stets den zweiten Operanden zurück, egal ob dieser truthy oder falsy ist.

Ist der erste Operand falsy, wertet Python den zweiten Operanden nicht aus. Das nennt man Short-Circuiting und es ist eine Form der Lazy Evaluation. Du kannst das mit folgendem Code bestätigen:

0 and 5/0

0

Der zweite Operand ist 5/0, was normalerweise eine ZeroDivisionError auslöst. Da der erste Operand aber falsy ist, wird 5/0 hier nicht ausgewertet. Die Ausnahme tritt nicht auf.

Beispiel: Der Online-Shop für Programmierer

Betrachten wir ein einfaches Beispiel aus der Praxis. Transaktionen in einem Online-Shop für Programmierer werden über eine API erfasst und abgerufen. Die Daten werden in eine Liste von Dictionaries umgewandelt. Jedes Element steht für eine Transaktion, und jede Transaktion ist ein Dictionary mit den relevanten Informationen:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Jede Transaktion enthält den Artikelnamen und -preis, die bestellte Menge und die Information, ob die Transaktion erfolgreich war.

Angenommen, wir benötigen erfolgreiche Transaktionen für Artikel ab 100 $. Wir können den and-Operator nutzen, um diese Zeilen zu filtern:

for item in data:
    if item["Success"] and item["Price"] >= 100:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}

Die Ausgabe zeigt die einzige Transaktion, die beide Anforderungen erfüllt. Für jedes Element in der Transaktionsliste prüft die if-Anweisung die Truthiness zweier Ausdrücke:

• Die Werte zum Schlüssel "Success" in jedem Dictionary sind entweder True oder False.
• Der Größer-gleich-Operator in item["Price"] >= 100 liefert ebenfalls True oder False.

Das Python-Buch und die Kabel erfüllen die Preisvorgabe nicht, da sie unter 100 $ liegen. Die Kaffeemaschine liegt zwar darüber, aber die Transaktion war nicht erfolgreich und wird daher nicht ausgegeben.

Auf dieses Shop-Beispiel kommen wir später im Tutorial zurück.

Im nächsten Abschnitt konzentrieren wir uns auf den or-Operator.

Python: Der or-Operator

Der OR-Operator in der Booleschen Logik benötigt zwei Operanden. Er wertet zu wahr aus, wenn mindestens einer der Operanden wahr ist:

Diese Wahrheitstafel können wir mit Python’s or-Operator reproduzieren:

options = True, False
for a in options:
    for b in options:
        print(f"{a} or {b} gives {a or b}")

True or True gives True
True or False gives True
False or True gives True
False or False gives False

Wir können auch das Beispiel mit den Personennamen von oben erneut betrachten, ersetzen aber den and- durch den or-Operator:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
    if len(name) < 5 or name[0] == "J":
        print(name)

James
Bob
Jane
Kate
Mary

Die if-Anweisung enthält nun einen or-Ausdruck. Daher gibt die for-Schleife alle Namen aus, die entweder weniger als fünf Buchstaben haben oder mit dem Buchstaben "J" beginnen. Der String "Jane" erfüllt beide Anforderungen. Die übrigen ausgegebenen Namen erfüllen jeweils eine der beiden.

Python or-Operator: truthy und falsy

Der or-Operator arbeitet ebenfalls mit truthy- und falsy-Werten und nicht nur mit den Booleschen True und False. Beispiele:

if 42 or [10, 20, 30]:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

Betrachten wir dieses Beispiel:

if 42 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

Und auch dieses abschließende Beispiel:

if 0 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

None of the operands is truthy

Im ersten Beispiel sind die Ganzzahl 42 und die nicht leere Liste [10, 20, 30] truthy. Da der or-Operator mindestens einen truthy Operanden benötigt, ist der gesamte Ausdruck truthy.

Im zweiten Beispiel ist 42 truthy, die leere Liste [] jedoch falsy, da es sich um eine leere Sequenz handelt. Da einer der beiden Operanden truthy ist, ist der gesamte or-Ausdruck truthy.

Im letzten Beispiel sind sowohl 0 als auch [] falsy. Daher ist der gesamte Ausdruck falsy.

Der or-Operator verwendet bei der Auswertung ebenfalls Short-Circuiting, um unnötige Auswertungen zu vermeiden. Hier ein paar Beispiele zur Veranschaulichung:

print(42 or [10, 20, 30])
print(42 or [])
print([] or 42)
print([] or 0)

42
42
42
0

Im ersten Beispiel ist der erste Operand 42 truthy. Da or für die Gesamtwahrheit des Ausdrucks nur einen truthy Operanden benötigt, wird dieser erste Operand sofort zurückgegeben. Der zweite wird nicht ausgewertet, da sein Wert das Ergebnis nicht mehr beeinflusst. Der or-Operator gibt den ersten Operanden 42 zurück, nicht den Booleschen Wert True. In Python wirken alle truthy Werte in Kontexten wie if- und while-Anweisungen wie True.

Im zweiten Beispiel ist der erste Operand ebenfalls 42, und der Ausdruck gibt diese Ganzzahl zurück, auch wenn der zweite Operand falsy ist.

Im dritten und vierten Beispiel ist der erste Operand die leere Liste und damit falsy. Daher wird in beiden Fällen der zweite Operand zurückgegeben.

Beispiel: Der Online-Shop für Programmierer

Kehren wir zu den Transaktionen aus dem Online-Shop zurück. Hier sind die vier Beispieltransaktionen, die wir verwenden:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Du möchtest einige Transaktionen identifizieren, um das Kundenverhalten genauer zu untersuchen. Gesucht sind Transaktionen, die entweder fehlgeschlagen sind oder einen Artikel unter 75 $ enthalten. Da du zwei Bedingungen hast und mindestens eine davon erfüllt sein soll, kannst du den or-Operator verwenden:

for item in data:
    if item["Success"] == False or item["Price"] < 75:
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Diese for-Schleife zeigt alle Zeilen, die mindestens eine der Anforderungen erfüllen. Das Python-Buch und die Kabel sind dabei, weil ihr Preis unter 75 $ liegt. Die Kaffeemaschine ist enthalten, weil die Transaktion nicht erfolgreich war.

Es gibt eine alternative Möglichkeit, fehlgeschlagene Transaktionen zu filtern. Die sehen wir uns im nächsten Abschnitt an.

Python: Der not-Operator

Der NOT-Operator unterscheidet sich von AND und OR, da er nur einen Operanden benötigt. NOT macht aus wahr falsch und umgekehrt. Hier ist die Wahrheitstafel für NOT:

Das können wir mit Python’s not-Operator nachstellen:

options = True, False
    for a in options:
        print(f"not {a} evaluates to {not a}")

not True evaluates to False
not False evaluates to True

Python not-Operator: truthy und falsy

Wie bei and und or muss der Operand für not kein Boolescher Wert sein. Da jedes Objekt entweder truthy oder falsy ist, kann jedes Objekt mit not verwendet werden.

if not "python":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `False`

Schauen wir uns auch dieses Beispiel an:

if not "":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `True`

Truthy-Werte werden mit dem not-Operator zu False, falsy-Werte zu True.

Im Unterschied zu and und or gibt der not-Operator immer einen Booleschen Wert zurück:

print(not "python")
print(not "")

False
True

Beispiel: Der Online-Shop für Programmierer

In den vorherigen Abschnitten haben wir Transaktionen aus einem Online-Shop verwendet. Wir möchten hier alle nicht erfolgreichen Transaktionen ausgeben. Eine Möglichkeit ist, mit dem Gleichheitsoperator == zu prüfen, ob data["Success"] False ist. Alternativ können wir den not-Operator verwenden:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

for item in data:
    if not item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Da item["Success"] für die fehlgeschlagenen Transaktionen False ist, ergibt not item["Success"] True. Daher gibt die Schleife die nicht erfolgreichen Transaktionen aus:

Im nächsten Abschnitt lernen wir, wie sich mehrere logische Operatoren in einem Ausdruck kombinieren lassen.

Python: Operatorrangfolge

In den bisherigen Beispielen haben wir jeweils nur einen logischen Operator verwendet. In diesem Abschnitt sehen wir, was passiert, wenn wir mehrere logische Operatoren in einem Ausdruck kombinieren.

Python: and hat Vorrang vor or

Wir arbeiten weiter mit den Transaktionen aus dem Online-Shop. Probieren wir folgende Bedingung:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
​
for item in data:
    if item["Price"] > 100 or item["Quantity"] > 2 and item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Die if-Anweisung enthält zwei logische Operatoren. Bevor wir sehen, wie Python diesen Ausdruck auswertet, formulieren wir ihn in natürlichem Deutsch: Wenn der Artikelpreis über 100 $ liegt oder die verkaufte Menge größer als zwei ist und der Verkauf erfolgreich war, dann gib den Artikel aus.

Dieser Satz ist ohne zusätzliche Interpunktion mehrdeutig und kann auch mit Kommata noch verwirren. Soll beispielsweise die Kaffeemaschine enthalten sein? Der Preis liegt über dem Schwellwert, aber die Transaktion war nicht erfolgreich.

Python löst die Mehrdeutigkeit, indem and Vorrang vor or hat. Das bedeutet: Zuerst wird der and-Ausdruck ausgewertet, und sein Ergebnis geht in den or-Ausdruck ein.

Daher wird der Ausdruck item["Quantity"] > 2 and item["Success"] zuerst ausgewertet. Er liefert nur für die Transaktion mit den Kabeln einen truthy Wert und ist für die übrigen Einträge falsy.

Der Wert dieses and-Ausdrucks wird dann mit dem or-Operator kombiniert. Der or-Ausdruck ist truthy für jeden Eintrag, der beim and truthy war — das war nur die Kabel-Transaktion — und für alle Artikel mit einem Preis über 100 $. Über diesem Schwellwert liegen die Kaffeemaschine und die Kopfhörer.

Python: Klammern und logische Operatoren

Was aber, wenn wir Transaktionen mit Artikeln über 100 $ oder mit einer Menge über zwei suchen, dabei aber zusätzlich nur erfolgreiche Verkäufe berücksichtigen wollen? In diesem Fall soll der or-Ausdruck Vorrang vor and haben und zuerst ausgewertet werden. Das erreichen wir, indem wir den or-Teil einklammern:

for item in data:
    if (item["Price"] > 100 or item["Quantity"] > 2) and item["Success"]:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Die zusätzlichen Klammern geben dem or-Ausdruck Vorrang. Die Kaffeemaschinen-Transaktion ist nun ausgeschlossen, da sie beim zweiten and-Operanden falsy ist.

Python: not hat Vorrang vor and und or

Der not-Operator hat Vorrang vor and und or. Er wird also vor den beiden anderen logischen Operatoren ausgewertet.

Betrachten wir diese if-Anweisung, die not und and kombiniert:

for item in data:
    if not item["Success"] and item["Price"] > 100:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Da not zuerst ausgewertet wird, wird zunächst der Wert für item["Success"] negiert. Das Ergebnis dieses not-Ausdrucks dient dann als erster Operand im and-Ausdruck. Nur der Eintrag zur Kaffeemaschine erfüllt diese Bedingung — das ist die einzige fehlgeschlagene Transaktion mit einem Preis über 100 $.

Wir können dem and-Operator Vorrang geben, indem wir Klammern setzen:

for item in data:
    if not (item["Success"] and item["Price"] > 100):
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Hier wird zuerst der and-Ausdruck ausgewertet. Nur der Kopfhörer-Eintrag ergibt True, da dies die einzige erfolgreiche Transaktion mit einem Preis über 100 $ ist. Durch das vorangestellte not wird das Ergebnis negiert, und der Code gibt die übrigen drei Transaktionen aus.

Generell gilt: Wenn ein Ausdruck durch zu viele Operatoren unübersichtlich wird, solltest du ihn zur besseren Lesbarkeit aufteilen.

Fazit

Die logischen Operatoren and, or und not werden in einer Vielzahl von Programmier- und Data-Science-Anwendungen intensiv genutzt. Sie bilden das Verhalten der in Logik und Mathematik verbreiteten Booleschen Operatoren AND, OR und NOT ab.

Python’s Operatoren können jedoch mit beliebigen Objekten arbeiten, nicht nur mit Booleschen Werten. Die Operatoren and und or nutzen Short-Circuit-Evaluation und geben einen der Operanden als Ergebnis zurück.

Die logischen Operatoren in Python sind zentrale Werkzeuge, um Daten zu filtern, Merkmale in Datensätzen zu erkennen und komplexe Regeln zur Steuerung des Programmablaufs zu erstellen. Wenn du tiefer einsteigen möchtest, sieh dir den neunteiligen Data Analyst With Python Karrierepfad an.