Python-Operatoren: Arithmetik, Vergleich, Logik, Zugehörigkeit und Identität

Operatoren sind nur Symbole für Aktionen

Ein Operator ist ein Symbol (oder ein kurzes Schlüsselwort), das Python sagt, etwas mit einem oder zwei Werten zu tun — sie addieren, vergleichen, prüfen, ob einer den anderen enthält. Aus der Grundrechenart kennst du ein paar; Python hat noch eine Handvoll mehr für Logik, Zugehörigkeit und Identität.

Wir gehen die Hauptkategorien nacheinander durch.

Arithmetische Operatoren

Die Standard-Mathematikoperatoren plus ein paar Python-Spezialitäten:

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.3333333... — / always returns a float
print(10 // 3)  # 3 — floor division, drops the remainder
print(10 % 3)   # 1 — modulo, the remainder
print(10 ** 3)  # 1000 — exponent

Zwei Punkte aus dieser Liste vergisst man leicht:

• / liefert auch bei zwei Ganzzahlen einen Float. 10 / 2 ergibt 5.0. Für Ganzzahldivision nimm //.
• % ist Modulo. n % 2 == 0 ist der sauberste Test, ob n gerade ist.

Python folgt der üblichen mathematischen Vorrangregel: ** bindet stärker als * und /, die wiederum stärker binden als + und -. Klammern überschreiben alles:

print(2 + 3 * 4)      # 14, not 20
print((2 + 3) * 4)    # 20

Setz Klammern großzügig, wenn Zweifel bestehen. Sie kosten nichts und machen die Absicht offensichtlich.

Vergleichsoperatoren

Sechs Vergleiche, jeder gibt einen Boolean zurück:

print(5 == 5)    # True — equal?
print(5 != 6)    # True — not equal?
print(5 < 6)     # True
print(5 <= 5)    # True
print(6 > 5)     # True
print(6 >= 6)    # True

Python lässt dich Vergleiche verketten, was ungewöhnlich und nützlich ist:

age = 25

if 18 <= age < 65:
    print("Working age")

Das liest sich als „age ist mindestens 18 und kleiner als 65“. Intern entspricht es 18 <= age and age < 65, liest sich aber näher an der Mathematik.

Logische Operatoren

Als englische Wörter statt als Symbole geschrieben:

logged_in = True
is_admin = False

print(logged_in and is_admin)   # False — both must be true
print(logged_in or is_admin)    # True — at least one must be true
print(not logged_in)            # False — flips the boolean

Zwei Details lohnen sich zu kennen:

Kurzschluss-Auswertung. and stoppt beim ersten falsy Wert; or stoppt beim ersten truthy Wert. Die rechte Seite wird gar nicht ausgewertet, wenn die linke schon entscheidet. So kannst du dich gegen Fehler absichern:

name = None

# name.upper() would blow up if name is None,
# but short-circuit saves us.
if name is not None and name.upper() == "ADMIN":
    print("Admin access")
else:
    print("Not admin")

and/or liefern den Wert, nicht immer True/False. Sie geben den Operand zurück, der das Ergebnis entschieden hat:

print(0 or "default")    # "default"
print("" or "default")   # "default"
print("value" or "fallback")  # "value"

print(1 and "end")       # "end"
print(0 and "never")     # 0

In echtem Code siehst du name = user_input or "anonymous" — das ist ein Default-Wert-Muster, das auf diesem Verhalten aufbaut.

Zuweisungsoperatoren

= weist zu. Die zusammengesetzten Formen kombinieren eine Operation mit einer Zuweisung:

n = 10

n += 5    # same as n = n + 5
n -= 2    # n = n - 2
n *= 3    # n = n * 3
n //= 2   # n = n // 2
n %= 4    # n = n % 4
n **= 2   # n = n ** 2

print(n)

Die zusammengesetzten Formen funktionieren auch für Strings (s += "more") und Listen (lst += [4, 5]). Sie sind nicht schneller als die volle Form; sie sind nur kürzer.

Zugehörigkeit: in und not in

Testet, ob ein Wert in einem Container vorkommt:

colors = ["red", "green", "blue"]

print("red" in colors)         # True
print("yellow" not in colors)  # True

text = "hello world"
print("world" in text)         # True
print("z" not in text)         # True

contacts = {"alice": 1, "bob": 2}
print("alice" in contacts)     # True (checks keys)

in funktioniert mit jeder Iterable — Listen, Tupeln, Sets, Strings, Dicts und mehr. Bei großen Suchen ist in auf einer Liste O(n); in auf einem Set oder Dict ist O(1). Das zählt, sobald du oft auf Zugehörigkeit prüfst.

Identität: is und is not

is prüft, ob zwei Variablen auf dasselbe Objekt im Speicher zeigen, nicht nur auf gleiche Werte:

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True — same contents
print(a is b)   # False — different objects
print(a is c)   # True — both name the same list

Fast immer willst du ==. Der eine Ort, an dem is wirklich glänzt, ist die Prüfung gegen None, True und False:

value = None

if value is None:
    print("no value")

Die Community-Konvention ist klar: is None, nicht == None. Dasselbe für is True (obwohl du das selten brauchst).

Bitweise Operatoren (beim ersten Lesen überspringen)

Python hat auch bitweise Operatoren — &, |, ^, ~, <<, >> — zum Manipulieren einzelner Bits einer Ganzzahl. Sie sind in Kryptografie, Low-Level-Netzwerkcode und bestimmten Algorithmen nützlich. Beim ersten Durchgang kannst du sie gefahrlos ignorieren.

Der Walross-Operator (:=)

Python 3.8 hat := hinzugefügt, das in einem Ausdruck zuweist und einen Wert zurückgibt. Nützlich in Bedingungen, bei denen du ein Ergebnis sowohl erfassen als auch prüfen willst:

numbers = [1, 2, 3, 4, 5]

if (count := len(numbers)) > 3:
    print(f"Got {count} items — more than expected")

Ohne den Walross müsstest du len(numbers) zweimal aufrufen oder eine zusätzliche Zeile schreiben. Er ist nicht essenziell; setz ihn ein, wo er Wiederholung spart.

Spickzettel zur Operatorrangfolge

Von der engsten zur losesten Bindung für die Operatoren, die du tatsächlich nutzt:

1. ** — Exponent
2. *, /, //, % — Multiplikation und Division
3. +, - — Addition und Subtraktion
4. <, <=, >, >=, ==, != — Vergleiche
5. not
6. and
7. or

Im Zweifel: Klammern setzen. Klarheit schlägt Cleverness.

Weiter zum Kontrollfluss

Mit Operatoren im Gepäck kannst du Bedingungen schreiben. Die nächste Seite ist if/elif/else — die Konstruktion, die dein Programm einen Weg oder einen anderen gehen lässt, je nachdem, was die Operatoren sagen.