Zahlen in

Über Zahlen

Python hat drei verschiedene Arten eingebauter Zahlen: Ganzzahlen (int), Gleitkommazahlen (float) und komplexe Zahlen (complex). Brüche (fractions.Fraction) und Dezimalzahlen (decimal.Decimal) sind ebenfalls über einen Import aus der Standardbibliothek verfügbar.

Ganze Zahlen, einschließlich hexadezimaler (hex()), oktaler (oct()) und binärer (bin()) Zahlen ohne Nachkommastellen, werden ebenfalls als ints erkannt:

# Ints are whole numbers.
>>> 1234
1234
>>> type(1234)
<class 'int'>

>>> -12
-12

Zahlen mit einem Dezimalpunkt (mit oder ohne Nachkommateil) werden als floats erkannt:

>>> 3.45
3.45
>>> type(3.45)
<class 'float'>

Arithmetik

Python unterstützt die Arithmetik zwischen diesen verschiedenen Zahlentypen vollständig und wandelt schmalere Zahlen in ihre weniger schmalen Gegenstücke um, wenn du sie mit den binären arithmetischen Operatoren (+, -, *, /, // und %) verwendest.

Alle Zahlen (außer komplexen) unterstützen alle arithmetischen Operationen, die gemäß der Operatorrangfolge ausgewertet werden. Unterstützung für mathematische Funktionen (über + und - hinaus) für komplexe Zahlen findest du im Modul cmath.

Addition und Subtraktion

Die Operatoren für Addition und Subtraktion verhalten sich wie in der normalen Mathematik. Wenn einer oder mehrere der Operanden ein float ist, werden die übrigen ints ebenfalls in floats umgewandelt:

>>> 5 - 3
2
# The int is widened to a float here, and a float is returned.
>>> 3 + 4.0
7.0

Multiplikation

Wie bei Addition und Subtraktion wandelt die Multiplikation schmalere Zahlen in ihre weniger schmalen Gegenstücke um:

>>> 3 * 2
6

>>> 3 * 2.0
6.0

Division

Die Division gibt immer einen float zurück, selbst wenn das Ergebnis eine ganze Zahl ist:

>>> 6/5
1.2

>>> 6/2
3.0

Ganzzahldivision

Wenn du ein int-Ergebnis brauchst, kannst du mit der Ganzzahldivision das Ergebnis abschneiden. Die Ganzzahldivision führst du mit dem Operator // aus:

>>> 6//5
1

>>> 6//2
3

Modulo

Der Modulo-Operator (%) gibt den Rest der Division der beiden Operanden zurück:

# The result of % is zero here, because dividing 8 by 2 leaves no remainder
>>> 8 % 2
0

# The result of % is 2 here, because 3 only goes into 5 once, with 2 left over
>>> 5 % 3
2

Eine andere Sichtweise auf 5 % 3:

>>> whole_part = int(5/3)
1

>>> decimal_part = 5/3 - whole_part
0.6666666666666667

>>> whole_remainder = decimal_part * 3
2.0

Potenzierung

Zum Potenzieren verwendest du den Operator **:

>>> 2 ** 3
8

>>> 4 ** 0.5
2

Umwandlungen

Zahlen lassen sich mit den eingebauten Funktionen int() und float() von int in floats und von floats in int umwandeln:

>>> int(3.45)
3

>>> float(3)
3.0

Runden

Python bietet die eingebaute Funktion round(<number>, <decimal_places>), um eine Gleitkommazahl auf eine bestimmte Anzahl von Nachkommastellen zu runden. Wenn keine Anzahl von Nachkommastellen angegeben wird, wird die Zahl auf die nächste ganze Zahl gerundet und gibt einen int zurück:

>>> round(3.1415926535, 2)
3.14

>>> round(3.1415926535)
3

Priorität und Klammern

Python erlaubt dir, mit Klammern Ausdrücke zu gruppieren. Das ist praktisch, wenn du die Standardreihenfolge der Operationen überschreiben möchtest.

>>> 2 + 3 * 4
14

>>> (2 + 3) * 4
20

Python folgt bei der Operatorrangfolge der PEMDAS-Regel. Das bedeutet, dass Berechnungen innerhalb von () die höchste Priorität haben, gefolgt von **, dann *, /, //, %, + und -:

>>> 2 + 3 - 4 * 4
-11

>>> (2 + 3 - 4) * 4
4

# In the following example, the `**` operator has the highest priority, then `*`, then `+`
# Meaning we first do 4 ** 4, then 3 * 256, then 2 + 768
>>> 2 + 3 * 4 ** 4
770

Genauigkeit und Darstellung

Ganzzahlen in Python haben eine beliebige Genauigkeit; die Anzahl der Ziffern ist nur durch den verfügbaren Arbeitsspeicher des Hostsystems begrenzt.

Gleitkommazahlen werden üblicherweise mit einem double in C implementiert (15 Dezimalstellen Genauigkeit), ihre Darstellung kann aber je nach Hostsystem variieren. Komplexe Zahlen haben einen real- und einen imaginary-Teil, die beide durch Gleitkommazahlen dargestellt werden.

Für eine ausführlichere Diskussion der Probleme und Grenzen der Gleitkommaarithmetik über Programmiersprachen hinweg, schau dir 0.30000000000000004.com und The Python Tutorial an.