Zahlen¶

Die vier Zahlentypen von Python sind ganze Zahlen, Gleitkommazahlen, komplexe Zahlen und Boolesche Zahlen:

Typ	Beispiele
Ganzzahlen	`-1`, `42`, `90000000`
Gleitkommazahlen	`90000000.0`, `-0.005`, `9e7`, `-5e-3`
Komplexe Zahlen	`3 + 2j`, `-4- 2j`, `4.2 + 6.3j`
Boolesche Zahlen	`True`, `False`

Sie können mit den arithmetischen Operatoren manipuliert werden:

Operator	Beschreibung
`+`	Addition
`-`	Subtraktion
`*`	Multiplikation
`/`, `//`	Division [1]
`**`	Potenzierung
`%`	Modulus

Bemerkung

Ganzzahlen können unbegrenzt groß sein, begrenzt nur durch den verfügbaren Speicher.

Beispiele:

>>> 8 + 3 - 5 * 3
-4
>>> 8 / 3
2.6666666666666665
>>> 8 // 3
2
>>> x = 4.2 ** 3.4
>>> x
131.53689544409096
>>> 9e7 * -5e-3
-450000.0
>>> -5e-3 ** 3
-1.2500000000000002e-07

Siehe auch

Julia Evans: Examples of floating point problems
David Goldberg: What Every Computer Scientist Should Know About Floating-Point Arithmetic

Komplexe Zahlen¶

Komplexe Zahlen bestehen aus einem Realteil und einem Imaginärteil, der in Python den Suffix j erhält.

>>> 7 + 2j
(7+2j)

Bemerkung

Python drückt die resultierende komplexe Zahl in Klammern aus, um anzuzeigen, dass die Ausgabe den Wert eines einzelnen Objekts darstellt:

>>> (7+2j) - (4+4j)
(3-2j)

>>> 2j * 4j
(-8+0j)

Bemerkung

Die Berechnung von 2j * 4j ergibt die erwartete Antwort von -8, aber das Ergebnis bleibt ein Python-Objekt für komplexe Zahlen. Komplexe Zahlen werden nie automatisch in entsprechende reelle oder ganzzahlige Objekte umgewandelt. Ihr könnt aber leicht auf ihre realen und imaginären Teile mit real und imag zugreifen.

>>> x = 2j * 4j
>>> x
(-8+0j)
>>> x.real
-8.0
>>> x.imag
0.0

Bemerkung

Die Real- und Imaginärteile einer komplexen Zahl werden immer als Fließkommazahlen zurückgegeben.

Built-in numerische Funktionen¶

Mehrere eingebaute Funktionen können mit Zahlen arbeiten:

abs(): gibt den absoluten Wert einer Zahl zurück. Dabei kann das Argument eine Ganzzahl, eine Fließkommazahl oder ein Objekt sein, das __abs__() implementiert. Bei komplexen Zahlen als Argument wird ihr Betrag zurückgegeben.
divmod(): nimmt zwei (nicht-komplexe) Zahlen als Argumente und gibt ein Zahlenpaar zurück, das aus ihrem Quotienten und dem Rest besteht, wenn eine ganzzahlige Division verwendet wird.
float: Gibt eine Fließkommazahl zurück, die aus einer Zahl oder Zeichenkette x gebildet wird.
hex(): konvertiert eine Integer-Zahl in eine klein geschriebene hexadezimale Zeichenkette mit dem Präfix 0x.
int: gibt ein Integer-Objekt zurück, das aus einer Zahl oder Zeichenkette x konstruiert wurde, oder 0, wenn keine Argumente angegeben werden.
max(): gibt das größte Element in einem iterable oder das größte von zwei oder mehr Argumenten zurück.
min(): gibt das kleinste Element in einem Iterable oder das kleinste von zwei oder mehr Argumenten zurück.
oct(): konvertiert eine Integer-Zahl in eine oktale Zeichenkette mit dem Präfix 0o. Das Ergebnis ist ein gültiger Python-Ausdruck. Wenn x kein Python int()-Objekt ist, muss es eine __index__()-Methode definieren, die eine ganze Zahl zurückgibt.
pow(): gibt base als Potenz von exp zurück.
round(): gibt eine Zahl zurück, die auf ndigits nach dem Dezimalpunkt gerundet ist. Wird ndigits weggelassen oder ist None, wird die nächstgelegene Ganzzahl zur Eingabe zurückgegeben.

Boolsche Werte¶

In den folgenden Beispielen werden Boolesche Werte verwendet:

>>> x = False
>>> x
False
>>> not x
True

>>> y = True * 2
>>> y
2

Abgesehen von ihrer Darstellung als True und False verhalten sich Boolesche Werte wie die Zahlen 1 (True) und 0 (False).

Erweiterte numerische Funktionen¶

Fortgeschrittenere numerische Funktionen wie Trigonometrie sowie einige nützliche Konstanten sind nicht in Python integriert, sondern werden in einem Standardmodul namens math bereitgestellt. Module werden später noch ausführlicher erklärt. Für den Moment genügt, dass ihr die mathematischen Funktionen in diesem Abschnitt verfügbar machen müsst, indem ihr math importiert:

import math

Eingebaute Funktionen sind immer verfügbar und werden mit einer Standard-Syntax für Funktionsaufrufe aufgerufen. Im folgenden Code wird round mit einem Float als Eingangsargument aufgerufen.

>>> round(2.5)
2

Mit ceil aus der Standardbibliothek math und der Attributschreibweise MODUL.FUNKTION(ARGUMENT) wird aufgerundet:

>>> math.ceil(2.5)
3

Das math-Modul bietet u.a.

die zahlentheoretischen und Darstellungsfunktionen math.ceil(), math.modf(), math.frexp() und math.ldexp(),
die Potenz- und logarithmische Funktionen math.exp(), math.log(), math.log10(), math.pow() und math.sqrt(),
die trigonometrischen Funktionen math.acos(), math.asin(), math.atan(), math.atan2(), math.ceil(), math.cos(), math.hypot() und math.sin(),
die hyperbolischen Funktionen math.cosh(), math.sinh() und math.tanh()
und die Konstanten math.e und math.pi.

Erweiterte Funktionen für komplexe Zahlen¶

Die Funktionen im Modul math sind nicht auf komplexe Zahlen anwendbar; einer der Gründe hierfür dürfte sein, dass die Quadratwurzel aus -1 einen Fehler erzeugen soll. Daher wurden ähnliche Funktionen für komplexe Zahlen arbeiten im cmath-Modul bereitgestellt:

cmath.acos(), cmath.acosh(), cmath.asin(), cmath.asinh(), cmath.atan(), cmath.atanh(), cmath.cos(), cmath.cosh(), python3:cmath.e(), cmath.exp(), cmath.log(), cmath.log10(), python3:cmath.pi(), cmath.sin(), cmath.sinh(), cmath.sqrt(), cmath.tan(), cmath.tanh().

Um im Code deutlich zu machen, dass es sich bei diesen Funktionen um spezielle Funktionen für komplexe Zahlen handelt, und um Namenskonflikte mit den normaleren Äquivalenten zu vermeiden, empfiehlt sich der einfache Import des Moduls um bei der Verwendung der Funktion ausdrücklich auf das cmath-Paket zu verweisen, z.B.:

>>> import cmath
>>> cmath.sqrt(-2)
1.4142135623730951j

Warnung

Nun wird auch verständlicher, weswegen wir nicht den Import aller Funktionen eines Moduls empfehlen mit from MODULE import *. Wenn ihr damit zuerst das Modul math und dann das Modul cmath importieren würdet, hätten die Funktionen in cmath Vorrang vor denen von math. Außerdem ist es beim Verstehen des Codes viel mühsamer, die Quelle der verwendeten Funktionen herauszufinden.

Kaufmännisch runden¶

Üblicherweise rechnet Python Gleitkommazahlen der IEEE 754-Norm entsprechend, wobei Zahlen in der Mitte in der Hälfte der Fälle abgerundet werden und in der anderen Hälfte aufgerundet werden um eine statistische Drift bei längeren Rechnungen zu vermeiden. Für das kaufmännische Runden werden daher Decimal und ROUND_HALF_UP aus dem decimal-Modul benötigt:

>>> import decimal
>>> num = decimal.Decimal("2.5")
>>> rounded = num.quantize(decimal.Decimal("0"), rounding = decimal.ROUND_HALF_UP)
>>> rounded
Decimal('3')

Numerische Berechnungen¶

Die Python-Standardinstallation eignet sich aufgrund von Geschwindigkeitseinschränkungen nicht gut für intensive numerische Berechnungen. Aber die leistungsstarke Python-Erweiterung NumPy bieten hocheffiziente Implementierungen vieler fortgeschrittener numerischer Operationen. Der Schwerpunkt liegt dabei auf Array-Operationen, einschließlich mehrdimensionaler Matrizen und fortgeschrittener Funktionen wie der schnellen Fourier-Transformation.

Eingebaute Module für Zahlen¶

Die Python-Standardbibliothek enthält eine Reihe eingebauter Module, mit denen ihr Zahlen managen könnt:

Modul	Beschreibung
`numbers`	für numerische abstrakte Basisklassen
`math`, `cmath`	für mathematische Funktionen für reelle und komplexe Zahlen
`decimal`	für dezimale Festkomma- und Gleitkomma-Arithmetik
`statistics`	für Funktionen zur Berechnung von mathematischen Statistiken
`fractions`	für rationale Zahlen
`random`	zum Erzeugen von Pseudozufallszahlen und -auswahlen sowie zum Mischen von Sequenzen
`itertools`	für Funktionen, die Iteratoren für effiziente Schleifen erzeugen
`functools`	für Funktionen höherer Ordnung und Operationen auf aufrufbaren Objekten
`operator`	für Standardoperatoren als Funktionen