# Python Operator-Übersicht: Arithmetik, // und % (Modulo), Vergleiche, and/or/not und Runden URL: https://skillaria.top/de/guides/python/python-operatoren Der Operator / in Python liefert immer eine Fließkommazahl, // ergibt den ganzzahligen Teil nach unten gerundet, % den Rest und ** die Potenz. Die Funktion round(x, n) rundet auf n Stellen nach der Bankerregel: round(2.5) ergibt 2, round(3.5) ergibt 4; auf- und abwärts auf ganze Zahlen runden math.ceil und math.floor, den Betrag einer Zahl liefert abs. 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. | Gruppe | Operatoren | Beispiel | | --- | --- | --- | | Arithmetische | `+ - * / // % **` | `7 // 2` → 3 | | Vergleiche | `== != < > <= >=` | `3 < 5` → True | | Logische | `and or not` | `not True` → False | | Identität | `is`, `is not` | `x is None` | | Zugehörigkeit | `in`, `not in` | `"Kaf" in "Kaffee"` → True | | Zuweisungen | `= += -= *= /= //= %= **=` | `total += 250` | | Walross-Operator | `:=` | `if (n := len(s)) > 10:` | | Bitweise | `& | ^ ~ << >>` | `5 & 3` → 1 | ## 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 > 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. | a | b | a and b | a or b | not a | | --- | --- | --- | --- | --- | | True | True | True | True | False | | True | False | False | True | False | | False | True | False | True | True | | False | False | False | False | True | 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. | Funktion | Was sie tut | 2.5 | -2.5 | 2.7 | | --- | --- | --- | --- | --- | | `round(x)` | zur nächsten Zahl, bei der Hälfte zur geraden | 2 | -2 | 3 | | `math.floor(x)` | nach unten, zur minus Unendlichkeit | 2 | -3 | 2 | | `math.ceil(x)` | nach oben, zur plus Unendlichkeit | 3 | -2 | 3 | | `math.trunc(x)`, `int(x)` | Bruchteil abschneiden, zur Null | 2 | -2 | 2 | ### 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 | Fehler | Was passiert | So ist es richtig | | --- | --- | --- | | `if x = 5:` | SyntaxError: das ist eine Zuweisung | `if x == 5:` | | `2 ^ 3` statt Potenz | bitweises XOR, Ergebnis 1 | `2 ** 3` | | ganze Zahl von `8 / 2` erwartet | man erhält `4.0` | `8 // 2` | | `x == 1 or 2` | immer wahr: `or 2` | `x in (1, 2)` | | 3 von `round(2.5)` erwartet | Banker’s Rounding ergibt 2 | `Decimal` mit `ROUND_HALF_UP` | | `"5" + 5` | TypeError | `int("5") + 5` | ## 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. ## FAQ **Wie rundet man eine Zahl in Python auf zwei Nachkommastellen?** Verwenden Sie round(x, 2). Wenn Sie den Wert nur schön ausgeben möchten, nutzen Sie eine f-Zeichenkette f"{x:.2f}", die den Wert selbst unverändert lässt. **Warum ergibt round(0.5) in Python 0?** Weil round die Hälfte zur nächsten geraden Zahl rundet, und 0 ist gerade; ebenso ergeben round(1.5) und round(2.5) den Wert 2. **Wie erhält man den ganzzahligen Teil einer Division in Python?** Mit dem Operator //: 17 // 5 ergibt 3. Bei negativen Zahlen rundet er nach unten, daher ergibt -17 // 5 den Wert -4; wenn Sie den Bruchteil zur Null hin abschneiden möchten, verwenden Sie int(-17 / 5). **Gibt es in Python einen ternären Operator?** Ja, es ist der bedingte Ausdruck: wert_wenn_wahr if bedingung else wert_wenn_falsch, zum Beispiel "gerade" if n % 2 == 0 else "ungerade". **Worin unterscheiden sich & und and in Python?** and ist ein logischer Operator mit verzögerter Auswertung, & ist das bitweise UND für Zahlen und die Schnittmenge bei Mengen; in Bedingungen verwenden Sie and. --- Source: Skillaria.Top (https://skillaria.top)