2.3. Mathematische Operationen

Python funktioniert von Haus aus als Taschenrechner. Diese Seite behandelt die Operatoren, die Sie am häufigsten verwenden werden: Arithmetik mit Zahlen, Vergleiche, die boolesche Werte erzeugen, logische Operatoren, die Bedingungen kombinieren, und bitweise Operatoren für hardwarenahe Arbeit.

2.3.1. Arithmetik

Die üblichen arithmetischen Operatoren auf int- und float-Werten:

  • + – Addition

  • - – Subtraktion (oder Negation als Präfix: -x)

  • * – Multiplikation

  • / – Division. Gibt immer einen float zurück, selbst wenn beide Operanden ganze Zahlen sind.

  • // – Ganzzahldivision. Gibt den ganzzahligen Quotienten zurück, abgerundet in Richtung minus unendlich.

  • % – Modulo (Rest).

  • ** – Potenzierung (2 ** 10 ergibt 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

Arithmetik mit gemischten Typen wandelt ganze Zahlen automatisch in Gleitkommazahlen um:

>>> 3 + 0.5
3.5

Die erweiterte Zuweisung kombiniert den Operator mit = für eine kompakte In-Place-Aktualisierung:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

Die Operatorrangfolge folgt der üblichen Reihenfolge: zuerst **, dann unäres -, dann *, /, // und %, danach + und -. Verwenden Sie Klammern, wenn Sie unsicher sind – sie kosten zur Laufzeit nichts.

2.3.2. Vergleich

Vergleichsoperatoren geben einen bool (True oder False) zurück:

  • == und != – gleich / ungleich.

  • <, <=, >, >= – Anordnung.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

Das letzte Beispiel ist ein verketteter Vergleich und genau äquivalent zu 3 < 5 and 5 <= 5.

Warnung

= weist zu; == vergleicht. Der Ausdruck if x = 5: ist gerade deshalb ein Syntaxfehler, weil Python sich weigert, die beiden stillschweigend zu verwechseln.

2.3.3. Boolesche Logik

Drei Operatoren kombinieren boolesche Werte:

  • and – True nur, wenn beide Seiten wahr sind.

  • or – True, wenn eine der beiden Seiten wahr ist.

  • not – invertiert einen einzelnen booleschen Wert.

and und or werten kurzgeschlossen aus: Sie hören mit der Auswertung auf, sobald das Ergebnis feststeht. False and slow_check() ruft slow_check nie auf.

and und or geben außerdem einen ihrer Operanden zurück statt eines literalen True oder False, womit Sie Standardwerte kompakt schreiben können:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Bitweise Operatoren

Für hardwarenahe Arbeit – das Packen von Registerfeldern, das Maskieren von Bits, das Parsen von Protokoll-Headern – greifen Sie zu den bitweisen Operatoren. Sie wirken auf die binäre Darstellung eines int:

  • & – bitweises UND

  • | – bitweises ODER

  • ^ – bitweises XOR

  • ~ – bitweises NICHT (Einerkomplement)

  • << – Linksverschiebung

  • >> – Rechtsverschiebung

Die hexadezimale und binäre Literalschreibweise ist beim Lesen und Schreiben dieser Werte praktisch:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Für jeden gibt es erweiterte Formen: |=, &=, ^=, <<=, >>=.

Bemerkung

and / or arbeiten mit booleschen Werten (oder mit Wahrheitsgehalt); & / | arbeiten mit Bits. Verwechseln Sie sie nicht. 0b1100 and 0b1010 ergibt 0b1010, weil beide Operanden wahr sind – nicht das, was Sie beim Manipulieren von Bits üblicherweise wollen.

2.3.5. Nützliche eingebaute Funktionen für Zahlen

Eine Handvoll eingebauter Funktionen deckt gängige numerische Operationen ab, die die Operatoren allein nicht bieten:

  • round() – nächste ganze Zahl, oder die nächste auf ndigits Dezimalstellen gerundete Zahl, wenn ein zweites Argument angegeben wird. Gibt für round(x) einen int zurück, für round(x, n) einen float. Bei Gleichständen (0.5, 1.5, …) wird zur nächsten geraden Zahl gerundet, nicht immer aufgerundet.

  • divmod() – gibt in einem einzigen Aufruf (quotient, remainder) zurück. Praktisch, um eine Größe in Einheiten aufzuteilen (Sekunden in Minuten und Sekunden, Bytes in Seiten und Offsets).

  • pow() – in der Form mit zwei Argumenten dasselbe wie **. Die Form mit drei Argumenten pow(base, exp, mod) berechnet (base ** exp) % mod, ohne jemals den riesigen Zwischenwert zu erzeugen, was die einzige praktikable Methode ist, modulare Exponentiation für große Exponenten durchzuführen.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Konvertierungen von Ganzzahlen in Zeichenketten zu verschiedenen Basen (bin, oct, hex) werden in String-Methoden und -Formatierung behandelt.

2.3.6. Das math-Modul

Gängige mathematische Funktionen leben im Modul math. Importieren Sie es einmal und rufen Sie seine Funktionen über einen Namen mit Punktnotation auf:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

Das MicroPython-Modul math deckt die üblichen Verdächtigen ab (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Für Zufallszahlen siehe das Modul random; für Festkomma-Bitmanipulation reichen die obigen Operatoren in der Regel aus.

2.3.7. Komplexe Zahlen

Für numerische Arbeit, die imaginäre Komponenten benötigt, hat Python einen complex-Typ mit Literalen, die das Suffix j tragen (1 + 2j). Das Modul cmath spiegelt math für komplexe Eingaben wider. Beide sind in den meisten MicroPython-Builds vorhanden, werden aber für Kameraarbeit selten benötigt; sie werden hauptsächlich erwähnt, damit sie keine Überraschung sind, falls Sie Code portieren, der sie verwendet.