Python Operator-Übersicht: Arithmetik, // und % (Modulo), Vergleiche, and/or/not und Runden

Operatoren in Python sind Zeichen, die Werte in neue Werte verwandeln: + addiert, // dividiert ganzzahlig, and verknüpft Bedingungen. Im Folgenden finden Sie eine vollständige Übersicht der Operatoren mit Beispielen, den Unterschied zwischen / und //, die Logik von and, or, not sowie die Rundungsfunktionen: python runden mit round, math.ceil, math.floor und abs. Alle Beispiele lassen sich in der REPL direkt ausprobieren.

Liste der Python-Operatoren

Operatoren gliedern sich nach ihrem Zweck. Die ganze Tabelle muss man nicht auswendig lernen: Im praktischen Code begegnen einem vor allem Arithmetik, Vergleiche und logische Verknüpfungen.

Arithmetische Operatoren

Addition, Subtraktion und Multiplikation funktionieren wie in der Schule. Wenn im Ausdruck mindestens ein float vorkommt, ist auch das Ergebnis ein float: 2 + 1.0 ergibt 3.0. Ganze Zahlen laufen in Python nicht über — 2 ** 100 wird exakt berechnet, egal wie viele Stellen herauskommen.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Potenzieren in Python: der Operator **

Potenzen schreibt man mit zwei Sternchen, nicht mit ^: Das Zeichen ^ bedeutet in Python das bitweise „exklusive ODER“, und 2 ^ 3 ergibt 1 statt 8. Ein gebrochener Exponent liefert eine Wurzel: 9 ** 0.5 ergibt 3.0. Es gibt außerdem die Funktion pow(x, y) — dasselbe, mit einem dritten Argument für den Rest: pow(2, 10, 1000) ergibt 24.

Beachten Sie die Priorität: ** wird vor dem unären Minus ausgeführt, daher ergibt -2 ** 2 den Wert -4. Wenn Sie das Quadrat einer negativen Zahl brauchen, setzen Sie Klammern: (-2) ** 2.

Division in Python: /, // und %

Python kennt zwei Arten der Division, und genau das sorgt bei Einsteigern für die meisten Überraschungen. Die normale Division / liefert immer einen float, auch wenn sie glatt aufgeht. Die ganzzahlige Division // verwirft den Nachkommateil, und % liefert den Rest.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Ganzzahlige Division // und Rest %: in der Praxis

Das Paar // und % löst Aufgaben der Art „wie viele ganze und wie viel bleibt übrig“. Im Kurs speichert der Ausgabentracker Geld in Cent, um keine Genauigkeit zu verlieren, und zerlegt die Summe in Euro und Cent:

cents = 125050            # Geld in Cent gespeichert
eur = cents // 100        # 1250 — ganze Euro
ct = cents % 100          # 50 — Rest
print(eur, ct)            # 1250 50

print(40 // 7, "Wochen und", 40 % 7, "Tage")   # 5 Wochen und 5 Tage

Beide Ergebnisse liefert zugleich die eingebaute Funktion divmod: divmod(125050, 100) ergibt das Tupel (1250, 50). Der Rest eignet sich auch zur Prüfung auf Geradzahligkeit: n % 2 == 0 ist für gerade Zahlen wahr.

Negative Zahlen: // rundet nach unten

Der Operator // verwirft den Bruchteil nicht einfach, sondern rundet nach unten, zur minus Unendlichkeit. Bei positiven Zahlen gibt es keinen Unterschied, bei negativen schon. Das Vorzeichen des Rests % in Python entspricht dem Vorzeichen des Divisors, daher gilt immer die Gleichung a == (a // b) * b + a % b.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # den Bruchteil abschneiden, nicht abrunden
-3

Division durch null: welcher Fehler

Eine Division durch null löst mit jedem der drei Operatoren die Ausnahme ZeroDivisionError aus, bei ganzen wie bei Dezimalzahlen. Sie können sie mit try/except abfangen oder den Divisor vorher prüfen.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

Vergleichsoperatoren

Vergleiche liefern True oder False. Gleichheit prüft man mit zwei Gleichheitszeichen ==, ein einzelnes = ist eine Zuweisung. Zeichenketten werden zeichenweise nach den Zeichencodes verglichen, daher ist "B" < "a" wahr: Großbuchstaben kommen vor Kleinbuchstaben.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # Kette: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Vergleichsketten wie 0 <= x < 100 sind eine praktische Eigenheit von Python: Ein and ist nicht nötig. Die letzte Zeile erinnert an die Ungenauigkeit von Dezimalzahlen: 0.1 + 0.2 ergibt 0.30000000000000004. Vergleichen Sie Dezimalzahlen über math.isclose(a, b), und speichern Sie Geldbeträge in Cent oder in Decimal.

Logische Operatoren and, or, not

Logische Operatoren schreibt man in Python als Wörter und nicht als Symbole && und || wie in anderen Sprachen. and ist wahr, wenn beide Teile wahr sind, or, wenn mindestens einer wahr ist, und not kehrt den Wert um.

Priorität: zuerst not, dann and, dann or. Der Ausdruck True or False and False ergibt True, weil and zuerst berechnet wird. Setzen Sie bei komplexen Bedingungen Klammern — so bleibt der Code für Sie selbst und für Kollegen verständlich.

Was and und or tatsächlich zurückgeben

and und or liefern nicht zwingend True oder False, sondern einen der Operanden. or gibt den ersten wahren Wert zurück (oder den letzten, falls keiner wahr ist), and den ersten falschen (oder den letzten). Als falsch gelten 0, 0.0, leere Zeichenketten, leere Sammlungen, None und False.

>>> name = ""
>>> name or "Gast"
'Gast'
>>> 5 and 0
0
>>> not ""
True

Die Auswertung ist verzögert: Steht das Ergebnis schon nach dem linken Teil fest, wird der rechte nicht berechnet. Deshalb löst count and total / count bei count == 0 keine Division durch null aus. Der Operator not liefert im Unterschied zu den beiden anderen immer einen bool.

Die Operatoren is und in

== vergleicht Werte, is prüft, ob zwei Namen auf dasselbe Objekt zeigen. Zwei verschiedene leere Einkaufskörbe sind gleich, aber sie sind nicht dasselbe Objekt. Die einzige Stelle, an der man is ständig braucht, ist die Prüfung auf None: if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

Vergleichen Sie Zahlen und Zeichenketten nicht mit is: Das „funktioniert“ manchmal wegen des internen Zwischenspeichers von Objekten, das Ergebnis hängt aber von der Implementierung ab, und Python warnt bei Konstruktionen wie x is 5 mit einer SyntaxWarning.

Der Operator in prüft die Zugehörigkeit: einen Teilstring in einer Zeichenkette, ein Element in einer Liste, einen Schlüssel in einem Dictionary. not in ist die Umkehrung.

>>> "Kaffee" in "Kaffee mit Milch"
True
>>> "Essen" in {"Essen": 450, "Taxi": 300}
True
>>> 5 not in [1, 2, 3]
True

Zuweisungsoperatoren und der Walross-Operator :=

Die zusammengesetzten Operatoren +=, -=, *=, //= und andere sind Kurzschreibweisen: total += 250 bedeutet total = total + 250. Die Operatoren ++ und -- gibt es in Python nicht: x++ führt zu einem Syntaxfehler.

Der Walross-Operator := (benannt nach der Ähnlichkeit mit den Augen und Stoßzähnen eines Walrosses) weist einen Wert direkt innerhalb eines Ausdrucks zu. Er ist nützlich, wenn der Wert sowohl geprüft als auch weiterverwendet werden soll:

items = ["Kaffee", "Taxi", "Mittag", "Kino"]
if (n := len(items)) > 3:
    print(f"Zu viele Ausgaben: {n}")

while (line := input("Betrag: ")) != "":
    print(int(line) * 2)

Ohne den Walross-Operator müsste man len zweimal aufrufen oder die Zuweisung in eine eigene Zeile auslagern. Übertreiben sollte man es nicht: Wird eine Zeile unleserlich, ist eine normale Zuweisung besser.

Runden in Python: round, ceil, floor

Zum Runden gibt es in Python die eingebaute Funktion round und die Funktionen des Moduls math. Sie lösen unterschiedliche Aufgaben, und sie zu verwechseln ist ein häufiger Fehler.

Die Funktion round in Python und das Banker’s Rounding

Die Funktion round(x, n) rundet auf n Nachkommastellen; ohne zweites Argument liefert sie eine ganze Zahl int. Die größte Falle: round rundet nach dem Banker’s Rounding — die Hälfte zur nächsten geraden Zahl. Deshalb ergibt round(2.5) den Wert 2, round(3.5) dagegen 4. So sammeln sich bei großen Rechnungen die Rundungsfehler nicht einseitig an.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # auf Hunderter
1200
>>> round(2.675, 2)     # nicht 2.68: binär ist es 2.67499...
2.67

Wenn Sie das gewohnte kaufmännische Runden „Hälfte aufwärts“ brauchen, etwa auf einer Rechnung, verwenden Sie Decimal mit dem Modus ROUND_HALF_UP. Die Zahl übergeben Sie als Zeichenkette, damit der Fehler von float nicht übernommen wird:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

Und noch eine Regel aus dem Kurs: Runden Sie erst bei der Ausgabe. Für die schöne Darstellung braucht man kein round — eine f-Zeichenkette genügt: f"{amount:.2f}" zeigt zwei Stellen, der Wert selbst bleibt genau.

math.ceil und math.floor: aufrunden und abrunden

math.ceil braucht man, wenn ein Fehlbetrag nicht akzeptabel ist: Wie viele Busse bestellen wir, wie viele Seiten hat die Ausgabe. math.floor nimmt man, wenn nur vollständige Einheiten zählen. Beide Funktionen liefern einen int.

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 Busse
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil ohne math, Trick mit //

Im Modul math gibt es weitere nützliche Funktionen: math.sqrt (Wurzel), math.isclose (Vergleich von Dezimalzahlen), math.pi, math.gcd. In Python 3.15 kam das Untermodul math.integer hinzu (PEP 791) für ganzzahlige Mathematik: darin comb, factorial, gcd, isqrt, lcm, perm; die alten Funktionen wie math.gcd funktionieren weiter.

Die Funktion abs: der Betrag einer Zahl

abs(x) liefert den Betrag — den Abstand von null ohne Vorzeichen. Ein Import ist nicht nötig, die Funktion ist eingebaut. Sie funktioniert mit ganzen, Dezimal- und sogar komplexen Zahlen: Für 3+4j liefert sie die Länge des Vektors, also 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # um wie viel wir abgewichen sind
320

Typische Anwendung ist eine Differenz ohne Berücksichtigung der Richtung und der Vergleich mit einer Toleranz: abs(a - b) < 0.001. Bei Dezimalzahlen ist math.isclose zuverlässiger, weil es die Größenordnung der Zahlen berücksichtigt.

Priorität der Operatoren

Wenn in einem Ausdruck mehrere Operatoren vorkommen, führt Python sie nach ihrer Priorität aus — von hoch nach niedrig:

1. **
2. unäre -x, +x, ~x
3. * / // %
4. + -
5. bitweise Verschiebungen und Operationen
6. Vergleiche, in, is
7. not
8. and
9. or
10. :=

So ergibt 2 + 3 * 4 den Wert 14, (2 + 3) * 4 dagegen 20. Wenn Sie unsicher sind, setzen Sie Klammern: Überflüssige Klammern kosten nichts, ein Fehler durch falsche Priorität wird dagegen lange gesucht.

Häufige Fehler mit Operatoren

Fazit

Merken Sie sich das Wesentliche: / liefert immer float, // rundet nach unten, % liefert den Rest mit dem Vorzeichen des Divisors, und die Potenz ist **. Die logischen Operatoren and, or, not schreibt man als Wörter und sie werden verzögert ausgewertet, is braucht man für die Prüfung auf None. Die Funktion python round rundet zur geraden Zahl, zum Aufrunden und Abrunden gibt es math.ceil und math.floor, den Betrag liefert abs. Im Kurs werden diese Operatoren praktisch angewendet — etwa im Ausgabentracker, in dem Geld in Cent gespeichert wird.