Vergleiche in

Über Vergleiche

Ein Vergleichsoperator in Python (auch als relationaler Operator in Python bezeichnet) betrachtet die Werte zweier Operanden und gibt den booleschen Wert True oder False zurück, je nachdem, ob die comparison-Bedingung erfüllt ist oder nicht.

Die folgende Tabelle zeigt die gebräuchlichsten Vergleichsoperatoren in Python:

Sie haben alle dieselbe Priorität (die höher ist als die von booleschen Operationen, aber niedriger als die von arithmetischen oder bitweisen Operationen).

Vergleich zwischen verschiedenen Datentypen

Objekte unterschiedlichen Typs (außer numerischen Typen) sind standardmäßig niemals gleich. Instanzen, die nicht identisch sind, sind ebenfalls nicht gleich, es sei denn, die class definiert spezielle Rich-Comparison-Methoden, die das standardmäßige Vergleichsverhalten von object anpassen. Für (wesentlich) mehr Details siehe Wertvergleiche in der Python-Dokumentation.

Numerische Typen sind (größtenteils) eine Ausnahme von dieser Typübereinstimmungsregel. Ein Wert vom Typ integer kann als gleich einem Wert vom Typ float betrachtet werden (oder eine octal gleich einer hexadecimal), solange die Typen für den Vergleich implizit umgewandelt werden können.

Für die anderen numerischen Typen (komplexe Zahlen, Dezimalzahlen, Brüche) sind Vergleichsoperatoren dort definiert, wo sie „Sinn ergeben“ (wo eine implizite Konvertierung das Ergebnis nicht ändert), lösen aber einen TypeError aus, wenn die zugrunde liegenden Objekte für den Vergleich nicht genau umgewandelt werden können. Weitere Informationen zu den Regeln, die Python für numerische Konvertierungen verwendet, findest du unter arithmetische Konvertierungen in der Python-Dokumentation.

>>> import fractions

# A string cannot be converted to an int.
>>> 17 == '17'
False

# An int can be converted to float for comparison.
>>> 17 == 17.0
True

# The fraction 6/3 can be converted to the int 2
# The int 2 can be converted to 0b10 in binary.
>>> 6/3 == 0b10
True

# An int can be converted to a complex 
# number with a 0 imaginary part.
>>> 17 == complex(17)
True

# The fraction 2/5 can be converted to the float 0.4
>>> 0.4 == 2/5
True

>>> complex(2/5, 1/2) == complex(0.4, 0.5)
True

Jeder geordnete Vergleich einer Zahl mit einem NaN-Typ (keine Zahl) ist False. Ein verwirrender Nebeneffekt von Pythons NaN-Definition ist, dass NaN nie gleich NaN ist. Wenn du neugierig bist, warum NaN in Python so definiert wurde, ist dieser Stack-Overflow-Beitrag zu NaN rund um die Festlegung des internationalen Standards eine interessante Lektüre.

>>> x = float('NaN')

>>> 3 < x
False

>>> x < 3
False

# NaN never compares equal to NaN
>>> x == x
False

Strings vergleichen

Strings (str) werden lexikografisch verglichen, anhand ihrer einzelnen Unicode-Codepunkte (das Ergebnis der Übergabe jedes Codepunkts im str an die eingebaute Funktion ord(), die einen int zurückgibt). Wenn alle Codepunkte in beiden Strings übereinstimmen und in derselben Reihenfolge stehen, gelten die beiden Strings als gleich. Dieser Vergleich erfolgt „paarweise“: erstes mit erstem, zweites mit zweitem usw. In Python 3.x können str und bytes nicht direkt umgewandelt/verglichen werden.

>>> 'Python' > 'Rust'
False

>>> 'Python' > 'JavaScript'
True

# Examples with Mandarin.
# hello < goodbye
>>> '你好' < '再见'
True

# ord() of first characters
>>> ord('你'), ord('再')
(20320, 20877)

# ord() of second characters
>>> ord('好'), ord('见')
(22909, 35265)

# And with Korean words.
# Pretty < beautiful.
>>> '예쁜' < '아름다운'
False

>>> ord('예'), ord('아')
(50696, 50500)

Vergleich von Container-Datentypen

Container-Datentypen (lists, tuples, sets, dicts usw.) werden ebenfalls lexikografisch verglichen: Sie sind gleich, wenn beide Container dieselben Daten und dieselben Datentypen haben (im Fall von lists und tuples müssen sie auch dieselbe Reihenfolge haben), andernfalls sind sie ungleich.

>>> [1, 2] == [1, 2]
True

# But if the data is not in the same order, they are not equal.
>>> [2, 1] == [1, 2]
False

# The same holds true for tuples
>>> (3,4,5) == (5,4,3)
False

# Length is also compared
>>> [1, 2] < [1, 2, 3]
True

# Comparing dicts
>>> {'name': 'John', 'age': 19} == {'name': 'John', 'age': 18}
False

>>> {'name': 'John', 'age': 19} == {'name': 'John', 'age': 19}
True

Verkettete Vergleiche

Vergleichsoperatoren können beliebig verkettet werden. Beachte, dass die Auswertung eines Ausdrucks von left nach right erfolgt. Zum Beispiel ist x < y <= z äquivalent zu x < y and y <= z, mit der Ausnahme, dass y nur einmal ausgewertet wird. In beiden Fällen wird z überhaupt nicht ausgewertet, wenn x < y als False erkannt wird. Das nennt man oft short-circuit evaluation: Die Auswertung stoppt, wenn der Wahrheitswert des Ausdrucks bereits bestimmt wurde.

Short circuiting wird von verschiedenen booleschen Operatoren, Funktionen und auch von der Vergleichsverkettung in Python unterstützt. Anders als in vielen anderen Programmiersprachen, darunter C, C++, C# und Java, haben verkettete Ausdrücke wie a < b < c in Python eine konventionelle mathematische Interpretation und Priorität.

>>> x = 2
>>> y = 5
>>> z = 10

>>> x < y < z
True

>>> x < y > z
False

>>> x > y < z
False

Identitätsvergleiche

Die Operatoren is und is not prüfen die Identität eines Objekts, im Gegensatz zum Wert eines Objekts. Die Identität eines Objekts ändert sich nach der Erstellung nie und kann mit der Funktion id() ermittelt werden.

<apple> is <orange> ergibt True und nur dann, wenn id(<apple>) == id(<orange>) ist. <apple> is not <orange> liefert das Gegenteil.

Aufgrund ihres Singleton-Status sollten None und NotImplemented immer unter Verwendung von is und is not mit Elementen verglichen werden. Siehe die Python-Referenzdokumentation zu Wertvergleichen und PEP8 für weitere Details zu dieser Konvention.

# A list of favorite numbers.
>>> my_fav_numbers = [1, 2, 3]

>>> your_fav_numbers = my_fav_numbers

>>> my_fav_numbers is your_fav_numbers
True

# The returned id will differ by system and Python version.
>>> id(my_fav_numbers)
4517478208

# your_fav_numbers is only an alias pointing to the original my_fav_numbers object.
# Assigning a new name does not create a new object.
>>> id(your_fav_numbers)
4517478208


>>> my_fav_numbers is not your_fav_numbers
False

>>> my_fav_numbers is not None
True

>>> my_fav_numbers is NotImplemented
False

Mitgliedschaftsvergleiche

Die Operatoren in und not in prüfen die Mitgliedschaft. <fish> in <soup> ergibt True, wenn <fish> ein Mitglied von <soup> ist (wenn <fish> eine Teilmenge von <soup> ist oder in <soup> enthalten ist), andernfalls ergibt es False. <fish> not in <soup> liefert die Negation, also das Gegenteil von <fish> in <soup>.

Bei den Typen String und bytes ist <name> in <fullname> True und nur dann, wenn <name> ein Teilstring von <fullname> ist.

# A set of lucky numbers.
>>> lucky_numbers = {11, 22, 33}
>>> 22 in lucky_numbers
True

>>> 44 in lucky_numbers
False

# A dictionary of employee information.
>>> employee = {'name': 'John Doe', 'id': 67826, 'age': 33, 'title': 'ceo'}

# Checking for the membership of certain keys.
>>> 'age' in employee
True

>>> 33 in employee
False

>>> 'lastname' not in employee
True

# Checking for substring membership
>>> name = 'Super Batman'
>>> 'Bat' in name
True

>>> 'Batwoman' in name
False

Das Vergleichsverhalten für Objekte lässt sich durch die Implementierung von rich comparison methods anpassen. Weitere Informationen findest du im Python-Tutorial: Klassen, in Python Classes and Magic Methods (Dan Bader) und unter Spezielle Methodennamen.