Vergleich und Logik

Rangfolge der Operatoren

Die Operatorrangfolge bestimmt, wie Python einen Ausdruck gruppiert, wenn Klammern diese Gruppierung nicht ausdrücklich festlegen. Python wertet Operanden von links nach rechts aus. Die Priorität bestimmt die Gruppierung der Operationen über diesen Operanden.

Bei Potenzen wird ein unärer Operator auf der rechten Seite besonders behandelt: 2 ** -1 bedeutet 2 ** (-1) und ergibt 0.5. Dagegen bedeutet -2 ** 2 den Ausdruck -(2 ** 2) und ergibt -4.

Operatoren mit höherer Priorität binden ihre Operanden stärker. Die meisten binären Operatoren derselben Stufe gruppieren von links nach rechts. Potenzen gruppieren dagegen von rechts nach links, und Vergleiche bilden Ketten. Verwende Klammern, sobald die beabsichtigte Gruppierung nicht sofort erkennbar ist.

Vergleichsoperatoren

Vergleichsoperatoren werden verwendet, um zwei Werte zu vergleichen und boolesche Werte (True oder False) zu erzeugen. In Python verfügbare Vergleichsoperatoren:

• == gleich
• != ungleich
• < weniger als
• <= kleiner oder gleich
• > größer als
• >= größer oder gleich

Vergleiche eingebauter Werte wie Zahlen und Strings liefern boolesche Werte. Eigene Klassen können andere Vergleichsergebnisse definieren. Die Gleichheit kann Objekte verschiedener Typen vergleichen. Ordnungsvergleiche wie < benötigen jedoch Typen mit einer kompatiblen Ordnung und können sonst einen TypeError auslösen. Vergleiche teilen sich eine Prioritätsstufe und lassen sich verketten.

# Beispiel für die Verwendung von Vergleichsoperatoren
>>> 4 == 5
False

>>> 3 > 2.1  # Python unterstützt diesen gemischten Zahlenvergleich
True

Boolesche Operatoren

Mit booleschen Operatoren lassen sich mehrere Bedingungen kombinieren oder boolesche Werte negieren. Python besitzt drei boolesche Operatoren:

1. Operator and gibt den ersten Wert zurück, wenn er falsch ist, oder den zweiten Wert, wenn der erste Wert wahr ist.

2. Operator or gibt den ersten Wert zurück, wenn er wahr ist, oder den zweiten Wert, wenn der erste Wert falsch ist.

3. Operator not unterscheidet sich von den Operatoren and und or, da er immer einen neuen booleschen Wert erzeugt.

# Beispiel für boolesche Operatoren
>>> 4.0 and 5.0  # 4.0 ist wahr, dann wird 5.0 ohne eigene Wahrheitsprüfung zurückgegeben
5.0

>>> 0 and 5  # wertet 0 als falsch aus und gibt wegen Kurzschlussauswertung 0 zurück
0

>>> 4.0 or 5.0  # wertet 4.0 als wahr aus und gibt wegen Kurzschlussauswertung 4.0 zurück
4.0

>>> 0 or 5  # 0 ist falsch, dann wird 5 ohne eigene Wahrheitsprüfung zurückgegeben
5

>>> not 4.0  # wertet 4.0 als wahr aus und gibt False zurück
False

>>> not 0  # wertet 0 als falsch aus und gibt True zurück
True

Die Operatoren and und or verwenden eine Kurzschlussauswertung, was bedeutet, dass die Auswertung stoppt, wenn das Ergebnis ermittelt werden kann, ohne dass alle Operanden ausgewertet werden müssen. Beide geben das zuletzt ausgewertete Argument zurück, während der not-Operator immer einen neuen booleschen Wert erstellt.

Werte im booleschen Kontext

Jedes Python-Objekt kann einer Wahrheitsprüfung unterzogen werden, auch wenn es nicht die Werte True und False sind. Python entscheidet dann selbst, welche Werte als falsch gelten. Nach dieser Regel verhalten sich eine leere Liste, die Zahl null und die leere Zeichenkette in einem if wie False, während ein nicht leeres Behältnis wie True wirkt.

Falsche und wahre Werte

Diese eingebauten Werte folgen Wahrheitsregeln, die du mit bool() prüfen kannst.

Der String "0" und die Liste [0] gelten als wahr, weil sie nicht leer sind. Der Wert eines Elements bestimmt nicht den Wahrheitswert des eingebauten Containers.

Eigene Objekte können ihre Wahrheitsprüfung mit __bool__() oder __len__() festlegen. Ist keine der beiden Methoden definiert, gilt eine Instanz standardmäßig als wahr.

Boolescher Datentyp

Der Typ bool in Python stellt die Wahrheitswerte False und True dar, ist ein Untertyp der Ganzzahl (int) und boolesche Werte verhalten sich in mathematischen Operationen wie $0$ und $1$.

# Bool-Konstruktor und arithmetische Operationen
>>> bool(-1)
True

>>> bool(0.0)
False

>>> True + True
2

>>> 3 * False
0

Operatoren kombinieren

Vergleichsoperatoren lassen sich mit booleschen Operatoren zu mehrteiligen Bedingungen verbinden. Python unterstützt außerdem verkettete Vergleiche wie 1 < 2 < 3.

# Beispiel einer Operatorkombination
>>> 4.0 > 3 and 2 >= 3  # ⇔ True and False
False

>>> 7 < 6 or 4 != 2  # ⇔ False or True
True

>>> not 0 < 2  # ⇔ not (0 < 2) ⇔ not True
False

# Vergleichsverkettung
>>> 1 < 2 < 3  # ⇔ (1 < 2) and (2 < 3)
True

>>> 5 <= 7 < 10  # ⇔ (5 <= 7) und (7 < 10), Anwendung: Intervalltest
True

Vergleich von Gleitkommazahlen

Viele Dezimalbrüche besitzen keine exakte endliche binäre Gleitkommadarstellung. Arithmetische Operationen runden Zwischenergebnisse. Zwei mathematisch gleichwertige Rechnungen können deshalb nahe beieinanderliegende, aber ungleiche Floats liefern. Ein Vergleich mit == schlägt dann fehl, obwohl beide Werte als gleich gelten sollten.

Genauigkeitsprobleme bei Float Werten

Ein Dezimalbruch kann eine binäre Rundung erfordern. Das Diagramm unterscheidet exakt darstellbare Werte von Werten, die gerundet werden müssen.

# Gleitkomma-Präzisionsproblem
>>> a = 0.01
>>> b = 0.1**2  # b ist 0.010000000000000002
>>> a == b
False

# Lösung mit math.isclose()
>>> import math
>>> math.isclose(0.01, 0.1**2)
True

>>> math.isclose(100, 95, rel_tol=0.05)  # relative Toleranz ist 5%
True

>>> math.isclose(100, 95, abs_tol=5)  # Die absolute Toleranz ist 5
True

Lösung mit der Funktion Isclose

Python bietet die Funktion math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0) zum Testen der ungefähren Gleichheit. Diese Funktion verwendet relative und absolute Toleranzen über rel_tol und abs_tol, um zu bestimmen, ob zwei Werte nahe genug beieinander liegen.

Bei math.isclose(100, 95, rel_tol=0.05) beträgt der absolute Unterschied 5. Die relative Toleranz verwendet den größeren Absolutwert, hier 100.

Der Unterschied überschreitet die Toleranz nicht. Deshalb ist das Ergebnis True. Mit abs_tol=5 reicht die absolute Toleranz von 5 ebenfalls für diesen Unterschied aus.

Verwende exakte Gleichheit, wenn wirklich der genaue Gleitkommawert übereinstimmen muss. Wähle für gemessene oder berechnete Größen fachlich begründete Toleranzen und nutze math.isclose(). In der Nähe von null ist eine passende abs_tol unverzichtbar, weil die relative Toleranz mit den verglichenen Werten schrumpft.