In einem vorherigen Post haben wir uns die Rechenoperationen, Plus, Minus usw. in Python angeschaut. Um jetzt allerdings wirklich einen Schritt in Richtung Programmierung zu machen, ist es wichtig auch die Werte zweier Objekte zu vergleichen. Das heißt Vergleichsoperatoren in Python zu verwenden.
Denk einfach an folgende Ausdrücke aus der Mathematik: 7 < 5 („7 kleiner 5“) oder 0 = 0.
Offensichtlich ist der erste Ausdruck falsch, da 7 nicht kleiner ist als 5 und der zweite Ausdruck ist richtig. Die Zahl 0 ist gleich 0, das ist eine immer wahre Aussage.
Ich möchte in diesem Beitrag solche Ausdrücke, in denen Werte oder Objekte verglichen werden, betrachten, und zwar anhand der Programmiersprache Python.
Vergleichsoperatoren in Python
Um dich nicht länger hinzuhalten, werde ich dir jetzt einfach mal eine Übersicht geben, welche herkömmlichen Vergleichsoperatoren es in Python gibt. Anschließend erkläre ich dir, wozu du sie brauchst und wie du damit gut umgehen kannst.
Liste der Vergleichsoperatoren in Python
Tabelle mit Vergleichsoperatoren in Python
| == | ist gleich (wird wie das Gleichheitszeichen in Mathematik verwendet) |
| != | ungleich (auch im mathematischen Sinn gedacht) |
| < | (echt) kleiner |
| <= | kleiner oder gleich |
| > | (echt) größer |
| >= | größer oder gleich |
Vergleichsoperatoren kannst du grundsätzlich zwischen alle Datentypen in Python schreiben.
Besonders sind hierbei die Vergleichsoperatoren > und >= („größer“ und „größer gleich“), bzw. < und <= („kleiner“ und „kleiner gleich“) hervorzuheben. Diese lassen sich NICHT für den Datentyp complex, also komplexe Zahlen, und auch nicht für Dictionaries verwenden. Und auch nicht, wenn der jeweilige Datentyp der einzelnen zu vergleichenden Objekte unterschiedlich ist. Dazu habe ich einige Beispiele aufgelistet, schau sie dir in Ruhe an.
Was du in diesem Beitrag über Vergleichsoperatoren in Python finden wirst
Du kannst mehrdimensionale Objekte, wie Strings, Listen und Tupel in Python in Bezug auf > , >= oder <, <= vergleichen. Darauf werde ich in diesem Beitrag genauer eingehen.
Die Operatoren == und !=, also gleich und ungleich, kannst du grundsätzlich unabhängig vom Datentyp immer verwenden.
Mengen und Vergleiche zwischen ihnen, werde ich in diesem Beitrag nicht genauer betrachten.
Auch werden häufig die Identitätsoperatoren „is“ und „is not“ zu den Vergleichsoperatoren gezählt. Ich mache dies allerdings nicht, du wirst diese Operatoren in diesem Beitrag folglich nicht finden.
Los geht’s. Schauen wir uns ein paar Beispiele an, um die Vergleichsoperatoren in Python besser zu verstehen.
Beispiele
Lass uns mit einfachen Beispiele starten und sukzessive ein paar schwierigere Fälle betrachten.
Hier habe ich einfach mal ein paar ganz einfache Beispiele in einem kleinen Code für dich. Schau sie dir in Ruhe an, wahrscheinlich hast du relativ schnell durchschaut, was die Vergleichsoperatoren machen.
x = 7
y = 3 + 4
z = 8
print(x == y, x == z)
print(x != y, x != z)
print(x < y, x < z)
print(x <= y, x <= z)
print(x > y, x > z)
print(x >= y, x >= z)Drücke auf „Run“ und du erhälst folgende Ausgabe auf der Console. Du kannst dir auch gern selbst erstmal überlegen, welche der Vergleiche True und welche False sind, bevor du weiter liest.
True False False True False True True True False False True False
Beispiel 1: Ganze Zahlen oder Kommazahlen vergleichen
In folgendem Beispiel habe ich drei Variablen x, y und z deklariert und jeweils mit einer Ganzzahl oder Gleitkommazahl initialisiert. Auf Deutsch, ich habe die drei Variablen eingeführt und mir drei Zahlen ausgesucht, deren Wert ich diesen Variablen zugewiesen habe.
x = 3
y = 4.5
z = 1
print(x < y)
print(y < z)
print(z < x)
print(x < y < z)Lasse ich den Code durchlaufen, erhalte ich als Ergebnis:
True False True False
Das ist ein sinnvolles Ergebnis. Schauen wir uns den Code noch einmal an. Die Variable x hat den Wert 3 und dieser ist kleiner, als 4,5. Also der Wert der Variablen y.
Ich habe also jeweils die Werte der Variablen miteinander verglichen, indem ich den Vergleichsoperator < („kleiner als“) verwendet habe.
Als Ergebnis wird mir auf der Console dann der Boole’sche Wert True oder False ausgegeben. Abhängig davon, ob der Ausdruck nun mal mathematisch gesehen wahr oder falsch ist.
Im letzten Beispiel habe ich sogar mehrere Vergleichsoperatoren nacheinander aufgeführt. Python vergleicht die Werte der Variablen von links nach rechts. Und sobald eine Aussage falsch ist, wird der komplette Ausdruck als False ausgegeben.
In unserem Beispiel steht x < y < z. Es ist wahr, dass x kleiner ist, als y. Allerdings wird jetzt weiter gelesen und der Ausdruck y < z betrachtet. Diese Aussage ist falsch und somit ist der komplette Ausdruck mit falsch zu bewerten, Python gibt uns den Wert False aus.
Mit der Abfolge von mehreren Vergleichsoperatoren nacheinander befasse ich mich weiter unten erneut.
Beispiel 2: Zeichenketten (strings) miteinander vergleichen
Eine Sache, die vielleicht erstmal seltsam erscheint, ist das Vergleichen von zwei Zeichenketten, also strings.
Wenn Python zwei strings vergleicht, dann wird jedes Symbol von links nach rechts verglichen. Wenn zwei Zeichen gleich sind, dann geht Python eine Stelle weiter.
Die Entscheidung, ob nun ein string größer oder kleiner, als ein anderer ist, entscheidet sich an der ersten Stelle, an der die beiden sich in einem Symbol unterscheiden.
Hört sich kompliziert an, ist es aber nicht. Schauen wir uns ein Beispiel an.
string_1 = "mint"
string_2 = "minz"
print(string_1 < string_2)Drücken wir auf „Run“, so spuckt uns das Code-Beispiel das Ergebnis
True
aus. Die ersten drei Symbole der beiden strings waren exakt gleich. Also wird eine Stelle weiter nach rechts gelesen. Schließlich kommen wir zum letzten Buchstaben, darin unterscheiden sich die beiden Variablen string_1 und string_2.
Der Buchstabe „z“ ist „größer“, als „t“. Deshalb erhalten wir die Antwort True.
Zeichenketten werden mithilfe von Unicode verglichen
Woher wissen wir oder wie entscheidet Python, welcher Buchstabe in einem gewissen Sinne „größer“ ist?
Jedes Symbol, also alle Buchstaben, Zahlen und Sonderzeichen sowie ein Leerzeichen und weitere Zeichen werden in sogenannten Unicode übersetzt.
Welches Symbol genau welchem Code zugeordnet wird, kannst du in verschiedenen Tabellen im Internet recherchieren. Ich werde hier nicht genauer eingehen. Wichtig ist vielleicht noch anzumerken, dass in dieser Tabelle zwischen Groß- und Kleinbuchstaben unterschieden wird.
Der Buchstabe „A“ hat beispielsweise den Zahlencode U+0041 in Unicode und der Buchstabe „a“ U+0061.
Bei Python passiert also Folgendes, wenn du diese vergleichst.
print("A" < "a")True
Es sind also die Großbuchstaben „kleiner“ zu bewerten, als die Kleinbuchstaben. Etwas verwirrend, aber der zugehörige Unicode macht es deutlich.
Vergleichsoperatoren zwischen Zeichenketten (strings) unterschiedlicher Länge
Das muss man sich so vorstellen, als würde man den kürzeren string mit „None“-Zeichen auffüllen. Sprich, der längere string hat für jedes Symbol, dass er mehr hat, als der kürzere auch einen größeren Wert.
Wie immer ist ein Beispiel sehr hilfreich in diesem Fall.
string_1 = "Hallo"
string_2 = "Hal"
print(string_1 > string_2)Ausgabe:
True
Die ersten drei Stellen der beiden strings waren vom Wert her genau gleich. Also schaut sich Python die vierte Stelle an. Bei string_2 gibt es keine vierte Stelle, also None. Dadurch ist das „l“ von string_1 an der vierten Stellen größer, weil alles größer ist als None.
Beispiel 3: Vergleichsoperatoren mit Listen und Tupeln verwenden
Sehr ähnlich zu Zeichenketten verhält es sich mit iterierbaren Objekten, wie Listen und Tupeln.
Schau dir einfach folgendes Beispiel an, wahrscheinlich weißt du direkt was dabei rauskommt.
liste_1 = [1, 2]
liste_2 = [1, 3]
liste_3 = [1, 3, 4]
print(liste_1 <= liste_2)
print(liste_2 < liste_3)Ausgabe:
True True
Es funktioniert exakt, wie bei strings. Wenn der erste Eintrag gleich ist, dann wird der nächste betrachtet. Solange, bis zwei Werte ungleich sind und dann wird die Entscheidung getroffen, ob liste_1 kleiner oder gleich liste_2 in diesem Beispiel ist.
Bitte merke dir, dass ausschließlich der erste Eintrag, in dem sich die Listen unterscheiden, für den Vergleichsoperator von Bedeutung ist.
Hier ist ein weiteres Beispiel.
tupel_1 = (1, 1, 2, 3, 4)
tupel_2 = (1, 1, 1, 5, 6)
print(tupel_1 > tupel_2)Ausgabe:
True
In diesem Beispiel habe ich mich für Tupel anstatt Listen entschieden. Das hat keine große Bedeutung. Ich wollte lediglich zeigen, dass es sich für die genannten iterierbaren Objekte ähnlich verhält.
In dem Beispiel habe ich überprüft, ob tupel_1 größer ist, als tupel_2. Und die Antwort lautete True. Das liegt daran, dass der erste Eintrag, in welchem sich die beiden unterscheiden, der dritte Eintrag ist. Offensichtlich gilt 2 > 1 und somit entscheidet sich Python dafür, dass tupel_1 insgesamt mit größer als tupel_2 zu bewerten ist.
Und das, obwohl alle weiteren Einträge von tupel_2 eigentlich einen größeren Wert haben, als die von tupel_1. Sie werden aber ignoriert.
Sobald ein Wert gefunden wurde, in dem ein Vergleich, eine Unterscheidung, gemacht werden kann. Wird der Rest des Objekts außer Acht gelassen.
Besonderheiten beim Vergleichen von iterierbaren Objekten in Python
Ich möchte dich zudem auf folgende Besonderheit hinweisen. Die einzelnen Einträge dieser Objekte müssen für die Vergleichsoperatoren > und >= bzw. < und <= vom gleichen Datentyp sein.
liste_3 = [1, 3, 4]
liste_4 = [1, 3, "mint"]
print(liste_3 >= liste_4)Ausgabe:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [45], in <module>
1 liste_3 = [1, 3, 4]
2 liste_4 = [1, 3, "mint"]
----> 3 print(liste_3 >= liste_4)
TypeError: '>=' not supported between instances of 'int' and 'str'
Im dritten Eintrag haben die beiden Listen unterschiedliche Datentypen. Das sagt uns auch die Fehlermeldung. Wir können die beiden Listen, also nicht bezüglich >, >= und <, <= hin untersuchen.
Natürlich lässt sich für Python dennoch feststellen, ob sie gleich oder ungleich sind.
Beispiel 4: Komplexe Zahlen oder Dictionaries auf ihre „Größe“ hin zu vergleichen ist nicht möglich
Betrachten wir folgendes Beispiel. Es wurden zwei Variablen initialisiert und darin die Werte zweier komplexer Zahlen gespeichert. Viele lernen komplexe Zahlen erst im Studium kennen oder wenn sie sich an das Programmieren wagen. Wenn du noch nie etwas von komplexen Zahlen gehört hast, dann überspringe dieses Beispiel.
complex_1 = 1 + 2j
complex_2 = 2 + 3j
print(complex_1 > complex_2)In der dritten Zeile habe ich den Vergleichsoperator „>“ zwischen die beiden Variablen gesetzt. Ich möchte mithilfe der print-Funktion auf der Console anzeigen lassen, ob die Variable complex_1 (echt) größer ist, als der Wert der Variablen complex_2.
Wenn ich den Code durchlaufen lasse, erhalte ich folgende Fehlermeldung.
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [3], in <module>
1 complex_1 = 1 + 2j
2 complex_2 = 2 + 3j
----> 3 print(complex_1 > complex_2)
TypeError: '>' not supported between instances of 'complex' and 'complex'Die letzte Zeile ist interessant. Der Vergleichsoperator „>“ wird nicht unterstützt zwischen zwei komplexen Zahlen.
Ein ähnliches Ergebnis erhalten wir für Dictionaries. Hier ein Beispiel:
dict_1 = {"wert1": 1, "wert2": 2}
dict_2 = {"wert3": 3, "wert4": 4}
print(dict_1 <= dict_2)Ausgabe:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [50], in <module>
1 dict_1 = {"wert1": 1, "wert2": 2}
2 dict_2 = {"wert3": 3, "wert4": 4}
----> 3 print(dict_1 <= dict_2)
TypeError: '<=' not supported between instances of 'dict' and 'dict'
Vergleiche sind vom Datentyp „boolean“
Was mir sehr wichtig ist mit diesem Beitrag, ist das Verständnis für Ausdrücke, die durch Vergleichsoperatoren entstehen. Deshalb wiederhole ich mich an dieser Stelle nochmal.
Wenn du einen Ausdruck schreibst, der mindestens zwei Objekte, also bspw. zwei ganze Zahlen (int) und mindestens einen Vergleichsoperator dazwischen schreibst, dann hat dieser Ausdruck den Wert wahr oder falsch.
Was durch Vergleichsoperatoren entsteht, sind sozusagen Aussagen, die entweder wahr oder falsch sind.
So wie im „echten“ Leben. „Die Straße ist nass ist eine Aussage“, die entweder wahr oder falsch ist. „Die Zahl 5 ist kleiner als die Zahl 10,6“ ist auch eine Aussage, also ist auch diese entweder wahr oder falsch.
Reihenfolge der Operatoren
Anstatt Reihenfolge sagt man auch Priorität oder Präzedenz der Operatoren. Für herkömmliche Rechenoperationen wie Addition und Multiplikation gibt es die übliche „Punkt-vor-Strich-Regel“, die wir aus der Schule kennen.
In Python werden Vergleichsoperatoren von links nach rechts gelesen. Kein Operator hat „Priorität“.
Das ist sinnvoll, da wir uns eine Kette von Vergleichsoperatoren als Aussage vorstellen, die entweder wahr oder falsch ist.
Und in dieser Kette müssen alle Vergleiche „wahr“ sein, damit die komplette Aussage wahr ist. Sobald ein Teil der Aussage „falsch“ ist, erhalten wir ein False.
x = 3
y = 4
z = 5
print(x < y < z)
print(x < y == z)
print(z > x < y)Ausgabe:
True False True
Schau dir das Beispiel ganz in Ruhe an. Ich hoffe es konnte dir helfen, besser zu verstehen was damit gemeint ist, dass Vergleichsoperatoren in Python von links nach rechts ausgewertet werden.
Fazit
Vergleichsoperatoren sind nicht nur in Python, sondern in jeder Art von Programmiersprache von großer Bedeutung. Es lohnt sich also, sich intensiv damit zu befassen und genügend Beispiele durchzugehen.
Zum Beispiel brauchen wir sie für while-Schleifen und if-else-Blöcke.
Ich hoffe du konntest mit diesem Beitrag etwas dazulernen. Lass mir gerne ein Kommentar da, falls dir der Beitrag gefallen. Stell mir auch gerne Fragen, falls etwas ungenau war.
