7. Booleans und Bedingungen

In den vorherigen Kapiteln haben Sie gelernt, wie Sie mit Zahlen, Zeichenketten (Strings) und grundlegenden Datenoperationen arbeiten. Jetzt sind wir bereit zu erforschen, wie Python Entscheidungen trifft – eine grundlegende Fähigkeit, die es Programmen erlaubt, je nach Bedingung unterschiedlich zu reagieren. Im Zentrum der Entscheidungsfindung in Python stehen Boolean-Werte und Bedingungen.

Denken Sie an alltägliche Entscheidungen: „Wenn es regnet, nehme ich einen Regenschirm mit.“ „Wenn die Temperatur über 30°C liegt, schalte ich die Klimaanlage ein.“ Diese Entscheidungen basieren auf Bedingungen, die entweder wahr oder falsch sind. Python verwendet das gleiche Prinzip: Es wertet Bedingungen aus, um festzustellen, ob sie wahr oder falsch sind, und handelt dann entsprechend.

In diesem Kapitel werden wir Boolean-Werte untersuchen, lernen, wie man mit Vergleichsoperatoren Bedingungen erstellt, Pythons Konzept von „Truthiness“ („Wahrhaftigkeit“) verstehen und leistungsstarke Techniken zum Aufbau komplexer logischer Ausdrücke entdecken. Am Ende dieses Kapitels werden Sie die Bausteine beherrschen, die Sie für die if-Anweisungen und Schleifen (loops) benötigen, die Sie in den kommenden Kapiteln kennenlernen.

7.1) Boolean-Werte True und False

Python hat einen speziellen Datentyp namens bool (kurz für Boolean), der Wahrheitswerte repräsentiert. Dieser Typ hat genau zwei mögliche Werte: True und False. Beachten Sie, dass diese Werte großgeschrieben sind – das ist in Python wichtig. Wenn Sie true oder false (kleingeschrieben) schreiben, führt das zu einem Fehler, da Python sie nicht erkennt.

python

# boolean_basics.py
# Erstellen von Boolean-Variablen
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

Boolean-Werte sind grundlegend, weil sie das Ergebnis jeder Ja/Nein-Frage darstellen, die Ihr Programm stellen könnte: Ist diese Zahl größer als 10? Enthält diese Zeichenkette den Buchstaben 'a'? Ist der Benutzer eingeloggt? Jede Bedingung in Python ergibt letztlich entweder True oder False.

7.1.1) Booleans in Variablen und Ausdrücken

Sie können Boolean-Werte in Variablen speichern, genau wie Zahlen oder Zeichenketten. Das ist nützlich, wenn Sie den Zustand von etwas in Ihrem Programm verfolgen möchten:

python

# boolean_variables.py
# Verwenden von Boolean-Variablen zur Zustandsverfolgung
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Boolean-Variablen können neu zugewiesen werden
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Boolean-Variablen werden häufig mit Präfixen wie is_, has_ oder can_ benannt, um ihren Zweck deutlich zu machen. Diese Namenskonvention hilft Ihnen und anderen, die Ihren Code lesen, sofort zu verstehen, dass die Variable einen Wahr/Falsch-Wert enthält.

7.2) Vergleichsoperatoren und grundlegende Bedingungen

Auch wenn Sie Boolean-Werte direkt mit True und False erstellen können, stammen die meisten Boolean-Werte in Ihren Programmen aus Vergleichen – dem Testen von Beziehungen zwischen Werten. Python stellt mehrere Vergleichsoperatoren zur Verfügung, die zwei Werte vergleichen und ein Boolean-Ergebnis liefern.

7.2.1) Die sechs Vergleichsoperatoren

Python hat sechs primäre Vergleichsoperatoren:

Operator	Bedeutung	Beispiel	Ergebnis
`==`	Gleich	`5 == 5`	`True`
`!=`	Ungleich	`5 != 3`	`True`
`<`	Kleiner als	`3 < 5`	`True`
`>`	Größer als	`5 > 3`	`True`
`<=`	Kleiner oder gleich	`5 <= 5`	`True`
`>=`	Größer oder gleich	`5 >= 3`	`True`

Sehen wir uns diese Operatoren in Aktion an:

python

# comparison_operators.py
# Vergleichen von Zahlen
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Vergleiche mit gleichen Werten
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Vergleiche von Zahlen und Zeichenketten

Vergleichsoperatoren funktionieren mit vielen Wertetypen, nicht nur mit Ganzzahlen:

python

# comparing_types.py
# Vergleichen von Gleitkommazahlen
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Vergleichen von Zeichenketten (alphabetische/lexikographische Reihenfolge)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# Vergleiche von Zeichenketten sind groß-/kleinschreibungssensitiv
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Vergleichen von Zeichenkettenlängen mit len()
print(len(name1) == len(name2))  # Output: False

Beim Vergleichen von Zeichenketten verwendet Python eine lexikographische Ordnung, im Wesentlichen alphabetische Reihenfolge basierend auf Unicode-Zeichenwerten. Großbuchstaben kommen in dieser Ordnung vor Kleinbuchstaben, weshalb "Python" und "python" nicht gleich sind.

7.2.3) Speichern von Vergleichsergebnissen

Das Ergebnis eines jeden Vergleichs ist ein Boolean-Wert, den Sie in einer Variable speichern können:

python

# storing_comparisons.py
# Vergleichsergebnisse zur späteren Verwendung speichern
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Wir lernen bald mehr über verkettete Vergleiche
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Gespeicherte Vergleiche in Berechnungen oder anderen Ausdrücken verwenden
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Das Speichern von Vergleichsergebnissen in aussagekräftig benannten Variablen macht Ihren Code lesbarer. Anstatt überall im Programm age >= 18 zu schreiben, können Sie die Variable is_adult verwenden, die klar vermittelt, was geprüft wird.

7.3) Booleans aus Vergleichen, Ausdrücken und der bool()-Funktion

Wir haben gesehen, dass Vergleiche Boolean-Werte liefern. Es gibt aber weitere Möglichkeiten, in Python Boolean-Werte zu erhalten, unter anderem mit der Funktion bool(), um andere Typen in Booleans umzuwandeln.

7.3.1) Die bool()-Funktion

Die Funktion bool() konvertiert jeden Wert in sein Boolean-Äquivalent. Das ist nützlich, wenn Sie explizit prüfen möchten, ob ein Wert in einem Boolean-Kontext als wahr oder falsch gelten würde:

python

# bool_function.py
# Konvertieren von Zahlen in Booleans
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Konvertieren von Zeichenketten in Booleans
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Konvertieren von None in Boolean
print(bool(None))    # Output: False

Die Funktion bool() folgt bestimmten Regeln für die Umwandlung, die wir im nächsten Abschnitt über Truthiness und Falsiness ausführlich untersuchen werden. Für den Moment sehen Sie, dass die meisten Werte zu True werden, aber bestimmte spezielle Werte wie 0, 0.0, leere Zeichenketten ("") und None zu False konvertiert werden.

7.4) Truthiness und Falsiness in Bedingungen

Eine von Pythons mächtigsten Eigenschaften ist das Konzept von Truthiness und Falsiness. In Python hat jeder Wert – nicht nur True und False – eine inhärente Boolean-Interpretation. Das bedeutet, Sie können jeden Wert dort verwenden, wo ein Boolean erwartet wird, und Python behandelt ihn als wahr oder falsch.

7.4.1) Falsche Werte (Falsy Values): Was als False zählt

In Python werden die folgenden Werte als falsy betrachtet (sie verhalten sich in Boolean-Kontexten wie False):

Der Boolean-Wert False selbst
Der spezielle Wert None
Numerische Nullen in jeder Form: 0, 0.0, 0j (komplexe Null)
Leere Sequenzen: "" (leere Zeichenkette), [] (leere Liste), () (leeres Tupel)
Leere Abbildungen: {} (leeres Dictionary)
Leere Mengen: set()

Überprüfen wir das mit der Funktion bool():

python

# falsy_values.py
# Alle diese Werte sind falsy
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Wahre Werte (Truthy Values): Alles andere

Alle anderen Werte in Python werden als truthy betrachtet (sie verhalten sich in Boolean-Kontexten wie True). Dazu gehören:

Der Boolean-Wert True selbst
Jede von Null verschiedene Zahl (positiv oder negativ)
Jede nicht-leere Zeichenkette, Liste, jedes Tupel, Dictionary oder Set
Die meisten Objekte, die Sie erstellen

python

# truthy_values.py
# Alle diese Werte sind truthy
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Wichtiger Hinweis: Die Zeichenkette "False" ist truthy, weil sie eine nicht-leere Zeichenkette ist. Die Zeichenkette "0" ist aus demselben Grund ebenfalls truthy. Nur der eigentliche Boolean-Wert False und der numerische Wert 0 sind falsy.

7.4.3) Warum Truthiness wichtig ist

Das Verständnis von Truthiness ist wichtig, weil es ein grundlegendes Konzept in Python ist, das Ihnen häufig begegnen wird. In Kapitel 8 lernen Sie if-Anweisungen kennen, die Entscheidungen auf Basis von Bedingungen treffen. Diese Anweisungen können jeden Wert verwenden, nicht nur explizite Boolean-Vergleiche, da Python die Truthiness von Werten automatisch auswertet.

Truthiness erlaubt es Ihnen, kompakten Code zu schreiben, der prüft, ob Sammlungen Elemente enthalten, ob Zeichenketten Inhalt haben oder ob optionale Werte vorhanden sind. Hier ist ein Vorgeschmack darauf, wie Truthiness nützlich sein wird (in Kapitel 8 lernen wir die vollständige if-Syntax):

python

# truthiness_preview.py
# Demonstration von Truthiness mit bool()
# (In Kapitel 8 verwenden wir diese direkt in if-Anweisungen)
 
# Prüfen, ob eine Zeichenkette Inhalt hat
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Prüfen, ob eine Liste Elemente hat
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Prüfen, ob ein Wert existiert (nicht None ist)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Wenn Sie Truthiness verstehen, wird Ihr Code „pythonic“ – er folgt Pythons Konventionen und Idiomen. Wenn Sie sehen, dass erfahrene Python-Programmierer Bedingungen ohne explizite Vergleiche prüfen, nutzen sie Truthiness, um saubereren und besser lesbaren Code zu schreiben.

7.5) Verkettete Vergleiche und häufige Boolean-Fallstricke

Python bietet eine leistungsfähige Funktion namens verkettete Vergleiche (chained comparisons), die bestimmte Bedingungen lesbarer und näher an der mathematischen Notation macht. Allerdings können diese Funktion und andere Aspekte der Boolean-Logik auch zu häufigen Fehlern führen.

7.5.1) Verkettete Vergleiche

In der Mathematik könnte man „10 < x < 20“ schreiben, um auszudrücken, dass x zwischen 10 und 20 liegt. Python erlaubt Ihnen, dies auf genau diese Weise zu schreiben:

python

# chained_comparisons.py
# Prüfen, ob ein Wert in einem Bereich liegt
x = 15
 
# Die mathematische Schreibweise (verketteter Vergleich)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Das entspricht der Kombination von zwei Vergleichen
# (Wir lernen 'and' in Kapitel 9 kennen)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Test mit einem Wert außerhalb des Bereichs
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Test mit Randwerten
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Einschließen der Randwerte mit <= und >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

Verkettete Vergleiche funktionieren, indem jedes Paar benachbarter Elemente ausgewertet wird. Der Ausdruck 10 < x < 20 wird als (10 < x) and (x < 20) ausgewertet. Alle Vergleiche müssen wahr sein, damit die gesamte Kette wahr ist.

Sie können mehr als zwei Vergleiche verketten:

python

# multiple_chains.py
# Mehrere Vergleiche verketten
a = 5
b = 10
c = 15
d = 20
 
# Prüfen, ob Werte in aufsteigender Reihenfolge sind
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Hier ist eine visuelle Darstellung, wie verkettete Vergleiche funktionieren:

7.5.2) Häufiger Fallstrick: Zuweisung vs. Vergleich

Einer der häufigsten Fehler von Anfängern ist, Zuweisung (=) zu verwenden, wenn sie eigentlich Vergleich (==) meinen:

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Dies ist eine Zuweisung, kein Vergleich
# Es weist x den Wert 20 zu, statt x mit 20 zu vergleichen
# x = 20  # Dies würde x auf 20 ändern
 
# Dies ist ein Vergleich
result = (x == 20)  # Dies prüft, ob x gleich 20 ist
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# In Kapitel 8 lernen Sie, dass die Verwendung von = in Bedingungen einen Fehler verursacht
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# Der korrekte Vergleich
# In Kapitel 8 werden Sie schreiben: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python hilft, diesen Fehler in if-Anweisungen (die Sie in Kapitel 8 kennenlernen) zu vermeiden, indem es einen SyntaxError auslöst, wenn Sie Zuweisung statt Vergleich verwenden. In anderen Kontexten kann die Verwendung von =, wenn Sie == meinten, jedoch subtile Fehler erzeugen, die schwer zu finden sind.

7.5.3) Häufiger Fallstrick: Vergleiche mit Gleitkommazahlen

Beim Vergleich von Gleitkommazahlen (floating-point numbers) müssen Sie sich über Genauigkeitsprobleme im Klaren sein:

python

# floating_point_comparison.py
# Gleitkomma-Arithmetik kann Genauigkeitsprobleme haben
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Direkte Vergleiche funktionieren eventuell nicht wie erwartet
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# Der tatsächliche Wert ist sehr nah, aber nicht genau 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Für Vergleiche mit Gleitkommazahlen eine kleine Toleranz verwenden
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+ stellt math.isclose() dafür bereit
# Wir lernen in Kapitel 23, wie man Module importiert
# import math
# is_close = math.isclose(result, 0.3)

Dieses Problem entsteht, weil Computer Gleitkommazahlen binär speichern und einige Dezimalzahlen (wie 0,1) im Binärsystem nicht exakt dargestellt werden können. Wenn Sie mit diesen Zahlen rechnen, summieren sich winzige Rundungsfehler. Für die meisten praktischen Zwecke sind diese Fehler vernachlässigbar, können aber dazu führen, dass direkte Gleichheitsvergleiche unerwartet fehlschlagen.

7.6) Booleans als Ganzzahlen (1 und 0) und warum Sie Arithmetik vermeiden sollten

Eine überraschende Tatsache: In Python sind True und False tatsächlich Spezialfälle von Ganzzahlen (integers). True ist gleichbedeutend mit 1 und False mit 0. Dies ist ein historisches Überbleibsel aus dem Design von Python, hat aber einige interessante Auswirkungen. Das Verständnis dieser Beziehung hilft, Verwirrung zu vermeiden, aber Sie sollten sie in Ihrem Code nur selten direkt nutzen.

7.6.1) Booleans sind Ganzzahlen

Sie können überprüfen, dass Booleans Ganzzahlen sind, indem Sie ihren Typ prüfen und Ganzzahloperationen durchführen:

python

# booleans_as_integers.py
# Booleans sind ein Subtyp von Ganzzahlen
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True ist gleich 1, False ist gleich 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Sie können Booleans in arithmetischen Ausdrücken verwenden (sollten es aber nicht!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Booleans können als Listenindizes verwendet werden
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

Die Funktion isinstance() prüft, ob ein Wert eine Instanz eines Typs ist. Wenn wir isinstance(True, int) prüfen, gibt Python True zurück, weil der Typ bool eine Unterklasse des Typs int ist.

7.6.2) Warum Sie Boolean-Arithmetik vermeiden sollten

Auch wenn Python es erlaubt, Booleans in arithmetischen Ausdrücken zu verwenden, sollten Sie dies vermeiden. Die Verwendung von Booleans als Zahlen macht Ihren Code verwirrend und schwerer zu verstehen. Die Beziehung zwischen Booleans und Ganzzahlen ist größtenteils ein historisches Detail, das Sie kennen sollten, aber nur selten direkt nutzen.

Hier ist, warum Boolean-Arithmetik problematisch ist:

python

# boolean_arithmetic_problems.py
# Beispiel für verwirrenden Code
count = 0
has_error = True
has_warning = False
 
# Das funktioniert, ist aber verwirrend
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# Was soll das bedeuten? Es ist nicht klar!
# Besserer Ansatz: explizit sein
# Wir werden in Kapitel 10 den if-else-Ausdruck kennenlernen.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

Die einzige gängige Ausnahme von dieser Regel ist das Zählen von True-Werten in einer Sammlung:

python

# counting_trues.py
# Zählen, wie viele Bedingungen wahr sind
conditions = [True, False, True, True, False]
 
# Das ist akzeptabel, weil die Absicht klar ist
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Dies funktioniert, weil sum() die Werte aufsummiert
# True wird als 1 behandelt, False als 0
# Also ist sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

In diesem Fall ist die Verwendung von sum() auf einer Liste von Booleans ein gängiges Python-Idiom, das weithin verstanden wird. Die Absicht – zu zählen, wie viele Bedingungen wahr sind – ist aus dem Kontext klar ersichtlich.

7.6.3) Booleans bei Typumwandlungen

Weil Booleans Ganzzahlen sind, ist ihre explizite Umwandlung in Ganzzahlen redundant:

python

# boolean_conversion.py
# Konvertieren von Booleans in Ganzzahlen (unnötig)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Aber das Konvertieren von Ganzzahlen in Booleans ist nützlich
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

Die Umwandlung eines Boolean-Werts in eine Ganzzahl mit int() ist unnötig, weil Booleans sich bereits wie Ganzzahlen verhalten. Die Umwandlung von Ganzzahlen (oder anderen Typen) in Booleans mit bool() ist jedoch nützlich, wenn Sie Truthiness explizit prüfen möchten.

7.6.4) Der historische Grund

Der Grund, warum Booleans in Python Ganzzahlen sind, ist historisch. Frühere Python-Versionen (vor Version 2.3) hatten keinen eigenen Boolean-Typ. Programmierer verwendeten 1 für wahr und 0 für falsch. Als der Typ bool hinzugefügt wurde, machte man ihn zu einer Unterklasse von int, um die Abwärtskompatibilität mit bestehendem Code zu erhalten.

Heute sollten Sie True und False in erster Linie als Boolean-Werte betrachten. Ihre Beziehung zu 1 und 0 ist ein Implementierungsdetail, über das Sie nur selten nachdenken müssen – außer wenn Sie ihm an unerwarteten Stellen begegnen.

7.7) Verwendung von in und not in in Bedingungen

Die Operatoren in und not in testen die Mitgliedschaft – also ob ein Wert in einer Sammlung vorhanden ist. Diese Operatoren sind äußerst nützlich, um gut lesbare Bedingungen zu formulieren, insbesondere bei der Arbeit mit Zeichenketten, Listen und anderen Sammlungen.

7.7.1) Mitgliedschaft in Zeichenketten testen

Der Operator in prüft, ob eine Zeichenkette innerhalb einer anderen Zeichenkette vorkommt:

python

# string_membership.py
# Prüfen, ob eine Teilzeichenkette in einer Zeichenkette existiert
text = "Python programming is fun"
 
# 'in' verwenden, um nach Teilzeichenketten zu suchen
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Groß-/Kleinschreibungssensitive Suche
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# 'not in' verwenden, um Abwesenheit zu prüfen
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

Der Operator in führt eine groß-/kleinschreibungssensitive Suche durch. Wenn Sie eine Suche ohne Beachtung der Groß-/Kleinschreibung benötigen, können Sie beide Zeichenketten in die gleiche Schreibweise umwandeln:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Groß-/Kleinschreibungssensitive Suche (kein Treffer)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Groß-/Kleinschreibungsunabhängige Suche (beide in Kleinbuchstaben)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# Die Originalzeichenkette bleibt unverändert
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Mitgliedschaft in Listen testen

Der Operator in funktioniert auch mit Listen (die wir in Kapitel 14 ausführlich kennenlernen):

python

# list_membership.py
# Prüfen, ob ein Wert in einer Liste vorhanden ist
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# 'not in' verwenden
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Funktioniert auch mit Zeichenketten in Listen
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Mitgliedschaftsprüfung mit Ranges

Sie können in auch mit range-Objekten verwenden (die wir in Kapitel 12 kennenlernen):

python

# range_membership.py
# Prüfen, ob eine Zahl in einem Range liegt
age = 25
 
# 'in' mit range verwenden
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Vergleichsoperatoren sind für numerische Bereiche jedoch effizienter
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' mit range ist für bestimmte Sequenzen nützlich
valid_ages = range(18, 66)  # Erwerbsalter
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) Der Operator not in

Der Operator not in ist das Gegenteil von in – er gibt True zurück, wenn der Wert NICHT in der Sammlung gefunden wird:

python

# not_in_operator.py
# 'not in' für klarere Logik verwenden
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# 'not in' zu verwenden ist besser lesbar
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Prüfen auf fehlende Pflichtfelder
provided_fields = ["name", "email"]
 
# Fehlende Felder finden
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Die Operatoren in und not in machen Ihre Bedingungen lesbarer und ausdrucksstärker. Anstatt komplexe Vergleiche zu schreiben, können Sie direkt ausdrücken „Ist dieser Wert in dieser Sammlung enthalten?“, was genau Ihrer Denkweise über das Problem entspricht.

In diesem Kapitel haben Sie die Grundlagen von Boolean-Werten und Bedingungen in Python kennengelernt. Sie verstehen nun:

Die Boolean-Werte True und False und ihre Rolle bei Entscheidungen
Vergleichsoperatoren (==, !=, <, >, <=, >=) zum Erstellen von Bedingungen
Die Funktion bool() zur Umwandlung von Werten in Booleans
Truthiness und Falsiness – wie Python alle Werte als wahr oder falsch interpretiert
Verkettete Vergleiche für gut lesbare Bereichsprüfungen
Häufige Fallstricke beim Arbeiten mit Booleans und wie man sie vermeidet
Die Beziehung zwischen Booleans und Ganzzahlen (und warum man Boolean-Arithmetik vermeiden sollte)
Mitgliedschaftsprüfungen mit den Operatoren in und not in

Diese Konzepte bilden die Grundlage für die Kontrollstrukturen, die Sie in den nächsten Kapiteln kennenlernen werden. In Kapitel 8 werden Sie Boolean-Ausdrücke in if-Anweisungen verwenden, um Ihre Programme auf unterschiedliche Bedingungen reagieren zu lassen. In Kapitel 9 lernen Sie, mehrere Bedingungen mit logischen Operatoren wie and, or und not zu kombinieren. Und in den Kapiteln 10 und 11 werden Sie Bedingungen nutzen, um Schleifen zu steuern, die Aktionen wiederholen.

Das Verständnis von Booleans und Bedingungen ist entscheidend, um Programme zu schreiben, die Entscheidungen treffen, Eingaben validieren und angemessen auf unterschiedliche Situationen reagieren können. Üben Sie den Umgang mit diesen Konzepten, und Sie werden feststellen, dass Entscheidungslogik in Python schnell natürlich und intuitiv wird.