math — Mathematische Funktionen

---

Dieses Modul bietet Zugriff auf gängige mathematische Funktionen und Konstanten, einschließlich derer, die vom C-Standard definiert werden.

Diese Funktionen können nicht mit komplexen Zahlen verwendet werden; verwenden Sie Funktionen mit demselben Namen aus dem cmath-Modul, wenn Sie Unterstützung für komplexe Zahlen benötigen. Die Unterscheidung zwischen Funktionen, die komplexe Zahlen unterstützen und solchen, die dies nicht tun, wird getroffen, da die meisten Benutzer nicht so viel Mathematik lernen möchten, wie zur zum Verständnis komplexer Zahlen erforderlich ist. Das Erhalten einer Ausnahme anstelle eines komplexen Ergebnisses ermöglicht eine frühere Erkennung der unerwarteten komplexen Zahl als Parameter, sodass der Programmierer bestimmen kann, wie und warum sie überhaupt generiert wurde.

Die folgenden Funktionen werden von diesem Modul bereitgestellt. Sofern nicht ausdrücklich anders angegeben, sind alle Rückgabewerte floats.

Zahlentheoretische Funktionen
comb(n, k)	Anzahl der Möglichkeiten, k Elemente aus n Elementen ohne Wiederholung und ohne Reihenfolge auszuwählen
factorial(n)	n Fakultät
gcd(*integers)	Größter gemeinsamer Teiler der ganzzahligen Argumente
isqrt(n)	Ganzzahliger Quadratwurzel einer nicht-negativen ganzen Zahl n
lcm(*integers)	Kleinstes gemeinsames Vielfaches der ganzzahligen Argumente
perm(n, k)	Anzahl der Möglichkeiten, k Elemente aus n Elementen ohne Wiederholung und mit Reihenfolge auszuwählen
Gleitkomma-Arithmetik
ceil(x)	Decken Sie x ab, die kleinste ganze Zahl, die größer oder gleich x ist
fabs(x)	Absolutwert von x
floor(x)	Boden von x, die größte ganze Zahl, die kleiner oder gleich x ist
fma(x, y, z)	Fused multiply-add-Operation: (x * y) + z
fmod(x, y)	Rest der Division x / y
modf(x)	Bruchteilige und ganzzahlige Teile von x
remainder(x, y)	Rest von x in Bezug auf y
trunc(x)	Ganzzahliger Teil von x
Funktionen zur Manipulation von Gleitkommazahlen
copysign(x, y)	Betrag (absoluter Wert) von x mit dem Vorzeichen von y
frexp(x)	Mantisse und Exponent von x
isclose(a, b, rel_tol, abs_tol)	Prüfen Sie, ob die Werte a und b nahe beieinander liegen
isfinite(x)	Prüfen Sie, ob x weder unendlich noch NaN ist
isinf(x)	Prüfen Sie, ob x eine positive oder negative Unendlichkeit ist
isnan(x)	Prüfen Sie, ob x ein NaN (keine Zahl) ist
ldexp(x, i)	x * (2**i), Inverse der Funktion frexp()
nextafter(x, y, steps)	Gleitkommazahl steps Schritte nach x in Richtung y
ulp(x)	Wert des niedrigstwertigen Bits von x
Potenz-, Exponential- und Logarithmusfunktionen
cbrt(x)	Kubikwurzel von x
exp(x)	e hoch x
exp2(x)	2 hoch x
expm1(x)	e hoch x, minus 1
log(x, base)	Logarithmus von x zur gegebenen Basis (standardmäßig e)
log1p(x)	Natürlicher Logarithmus von 1+x (Basis e)
log2(x)	Basis-2-Logarithmus von x
log10(x)	Basis-10-Logarithmus von x
pow(x, y)	x hoch y
sqrt(x)	Quadratwurzel von x
Summen- und Produktfunktionen
dist(p, q)	Euklidische Entfernung zwischen zwei Punkten p und q, gegeben als iterierbare Koordinaten
fsum(iterable)	Summe der Werte im Eingabe-iterable
hypot(*coordinates)	Euklidische Norm eines iterierbaren Satzes von Koordinaten
prod(iterable, start)	Produkt der Elemente im Eingabe-iterable mit einem Start-Wert
sumprod(p, q)	Summe der Produkte aus zwei iterierbaren Elementen p und q
Winkelkonvertierung
degrees(x)	Wandelt Winkel x von Radiant in Grad um
radians(x)	Wandelt Winkel x von Grad in Radiant um
Trigonometrische Funktionen
acos(x)	Arcuscosinus von x
asin(x)	Arcussinus von x
atan(x)	Arcustangens von x
atan2(y, x)	atan(y / x)
cos(x)	Kosinus von x
sin(x)	Sinus von x
tan(x)	Tangens von x
Hyperbolische Funktionen
acosh(x)	Arcushyperbolicus-Kosinus von x
asinh(x)	Arcushyperbolicus-Sinus von x
atanh(x)	Arcushyperbolicus-Tangens von x
cosh(x)	Hyperbolischer Kosinus von x
sinh(x)	Hyperbolischer Sinus von x
tanh(x)	Hyperbolischer Tangens von x
Spezialfunktionen
erf(x)	Fehlerfunktion bei x
erfc(x)	Komplementäre Fehlerfunktion bei x
gamma(x)	Gammafunktion bei x
lgamma(x)	Natürlicher Logarithmus des Absolutbetrags der Gammafunktion bei x
Konstanten
pi	π = 3.141592…
e	e = 2.718281…
tau	τ = 2π = 6.283185…
inf	Positive Unendlichkeit
nan	„Keine Zahl“ (NaN)

Zahlentheoretische Funktionen

math.comb(n, k)

Gibt die Anzahl der Möglichkeiten zurück, k Elemente aus n Elementen ohne Wiederholung und ohne Reihenfolge auszuwählen.

Gleich n! / (k! * (n - k)!) wenn k <= n und null wenn k > n.

Auch Binomialkoeffizient genannt, da er dem Koeffizienten des k-ten Terms in der Polynomexpansion von (1 + x)ⁿ entspricht.

Löst TypeError aus, wenn eines der Argumente keine Ganzzahl ist. Löst ValueError aus, wenn eines der Argumente negativ ist.

Hinzugefügt in Version 3.8.

math.factorial(n)

Gibt die Fakultät der nicht-negativen ganzen Zahl n zurück.

Geändert in Version 3.10: Floats mit ganzzahligen Werten (wie 5.0) werden nicht mehr akzeptiert.

math.gcd(*integers)

Gibt den größten gemeinsamen Teiler der angegebenen ganzzahligen Argumente zurück. Wenn eines der Argumente ungleich Null ist, dann ist der zurückgegebene Wert die größte positive ganze Zahl, die ein Teiler aller Argumente ist. Wenn alle Argumente Null sind, dann ist der zurückgegebene Wert 0. gcd() ohne Argumente gibt 0 zurück.

Hinzugefügt in Version 3.5.

Geändert in Version 3.9: Unterstützung für eine beliebige Anzahl von Argumenten hinzugefügt. Zuvor wurden nur zwei Argumente unterstützt.

math.isqrt(n)

Gibt die ganzzahlige Quadratwurzel der nicht-negativen ganzen Zahl n zurück. Dies ist der Boden der exakten Quadratwurzel von n, oder gleichbedeutend die größte ganze Zahl a, so dass a² ≤ n.

Für einige Anwendungen mag es bequemer sein, die kleinste ganze Zahl a zu haben, so dass n ≤ a², oder anders ausgedrückt, die Decke der exakten Quadratwurzel von n. Für positive n kann dies mit a = 1 + isqrt(n - 1) berechnet werden.

Hinzugefügt in Version 3.8.

math.lcm(*integers)

Gibt das kleinste gemeinsame Vielfache der angegebenen ganzzahligen Argumente zurück. Wenn alle Argumente ungleich Null sind, dann ist der zurückgegebene Wert die kleinste positive ganze Zahl, die ein Vielfaches aller Argumente ist. Wenn eines der Argumente Null ist, dann ist der zurückgegebene Wert 0. lcm() ohne Argumente gibt 1 zurück.

Hinzugefügt in Version 3.9.

math.perm(n, k=None)

Gibt die Anzahl der Möglichkeiten zurück, k Elemente aus n Elementen ohne Wiederholung und mit Reihenfolge auszuwählen.

Gleich n! / (n - k)! wenn k <= n und null wenn k > n.

Wenn k nicht angegeben oder None ist, dann ist k standardmäßig n und die Funktion gibt n! zurück.

Löst TypeError aus, wenn eines der Argumente keine Ganzzahl ist. Löst ValueError aus, wenn eines der Argumente negativ ist.

Hinzugefügt in Version 3.8.

Gleitkomma-Arithmetik

math.ceil(x)

Gibt die Decke von x zurück, die kleinste ganze Zahl, die größer oder gleich x ist. Wenn x kein Float ist, wird delegiert an x.__ceil__, das einen Integral-Wert zurückgeben sollte.

math.fabs(x)

Gibt den Absolutwert von x zurück.

math.floor(x)

Gibt den Boden von x zurück, die größte ganze Zahl, die kleiner oder gleich x ist. Wenn x kein Float ist, wird delegiert an x.__floor__, das einen Integral-Wert zurückgeben sollte.

math.fma(x, y, z)

Fused multiply-add-Operation. Gibt (x * y) + z zurück, berechnet so, als ob mit unendlicher Präzision und Reichweite, gefolgt von einer einzelnen Rundung auf das float-Format. Diese Operation bietet oft eine bessere Genauigkeit als der direkte Ausdruck (x * y) + z.

Diese Funktion folgt der Spezifikation der fusedMultiplyAdd-Operation, die im IEEE 754-Standard beschrieben ist. Der Standard überlässt einen Fall der Implementierungsdefinition, nämlich das Ergebnis von fma(0, inf, nan) und fma(inf, 0, nan). In diesen Fällen gibt math.fma ein NaN zurück und löst keine Ausnahme aus.

Hinzugefügt in Version 3.13.

math.fmod(x, y)

Gibt den Gleitkomma-Rest von x / y zurück, wie von der C-Bibliotheksfunktion fmod(x, y) definiert. Beachten Sie, dass der Python-Ausdruck x % y möglicherweise nicht dasselbe Ergebnis liefert. Die Absicht des C-Standards ist, dass fmod(x, y) exakt (mathematisch; mit unendlicher Präzision) gleich x - n*y für eine ganze Zahl n ist, sodass das Ergebnis dasselbe Vorzeichen wie x und einen Betrag kleiner als abs(y) hat. Pythons x % y liefert ein Ergebnis mit dem Vorzeichen von y und ist möglicherweise nicht exakt für Float-Argumente berechenbar. Zum Beispiel ist fmod(-1e-100, 1e100) -1e-100, aber das Ergebnis von Pythons -1e-100 % 1e100 ist 1e100-1e-100, was als Float nicht exakt dargestellt werden kann und zur überraschenden 1e100 rundet. Aus diesem Grund wird die Funktion fmod() im Allgemeinen bei der Arbeit mit Floats bevorzugt, während Pythons x % y bei der Arbeit mit ganzen Zahlen bevorzugt wird.

math.modf(x)

Gibt den Bruchteil- und Ganzzahlteil von x zurück. Beide Ergebnisse tragen das Vorzeichen von x und sind Floats.

Beachten Sie, dass modf() ein anderes Aufruf-/Rückgabemuster als seine C-Äquivalente hat: es nimmt ein einzelnes Argument und gibt ein Wertepaar zurück, anstatt seinen zweiten Rückgabewert über einen „Ausgabeparameter“ zurückzugeben (so etwas gibt es in Python nicht).

math.remainder(x, y)

Gibt den IEEE 754-Rest von x in Bezug auf y zurück. Für endliche x und endliche ungleiche y ist dies die Differenz x - n*y, wobei n die nächste ganze Zahl zum exakten Wert des Quotienten x / y ist. Wenn x / y genau auf halbem Weg zwischen zwei aufeinanderfolgenden ganzen Zahlen liegt, wird die nächstgelegene gerade ganze Zahl für n verwendet. Der Rest r = remainder(x, y) erfüllt somit immer abs(r) <= 0.5 * abs(y).

Spezialfälle folgen IEEE 754: Insbesondere ist remainder(x, math.inf) x für jedes endliche x, und remainder(x, 0) und remainder(math.inf, x) lösen für jedes nicht-NaN x ValueError aus. Wenn das Ergebnis der Restoperation Null ist, hat diese Null dasselbe Vorzeichen wie x.

Auf Plattformen, die IEEE 754 binäre Gleitkommazahlen verwenden, ist das Ergebnis dieser Operation immer exakt darstellbar: Es werden keine Rundungsfehler eingeführt.

Hinzugefügt in Version 3.7.

math.trunc(x)

Gibt x mit entferntem Bruchteil zurück, wobei der ganzzahlige Teil erhalten bleibt. Dies rundet gegen 0: trunc() ist für positive x äquivalent zu floor() und für negative x äquivalent zu ceil(). Wenn x kein Float ist, wird delegiert an x.__trunc__, das einen Integral-Wert zurückgeben sollte.

Für die Funktionen ceil(), floor() und modf() beachten Sie, dass alle Gleitkommazahlen mit ausreichend großem Betrag exakte ganze Zahlen sind. Python-Floats speichern typischerweise nicht mehr als 53 Bit Präzision (wie der plattformabhängige C double-Typ), so dass für jedes Float x mit abs(x) >= 2**52 zwangsläufig keine Bruchteile mehr vorhanden sind.

Gleitkomma-Manipulationsfunktionen

math.copysign(x, y)

Gibt einen Float mit dem Betrag (Absolutwert) von x, aber dem Vorzeichen von y zurück. Auf Plattformen, die mit signierten Nullen arbeiten, gibt copysign(1.0, -0.0) -1.0 zurück.

math.frexp(x)

Gibt die Mantisse und den Exponenten von x als Paar (m, e) zurück. m ist ein Float und e ist eine ganze Zahl, so dass x == m * 2**e exakt ist. Wenn x Null ist, wird (0.0, 0) zurückgegeben, ansonsten 0.5 <= abs(m) < 1. Dies wird verwendet, um die interne Darstellung eines Floats auf portable Weise zu „zerlegen“.

Beachten Sie, dass frexp() ein anderes Aufruf-/Rückgabemuster als seine C-Äquivalente hat: es nimmt ein einzelnes Argument und gibt ein Wertepaar zurück, anstatt seinen zweiten Rückgabewert über einen „Ausgabeparameter“ zurückzugeben (so etwas gibt es in Python nicht).

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Gibt True zurück, wenn die Werte a und b nahe beieinander liegen, und andernfalls False.

Ob zwei Werte als nahe beieinander betrachtet werden, wird anhand der angegebenen absoluten und relativen Toleranzen bestimmt. Wenn keine Fehler auftreten, ist das Ergebnis: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

rel_tol ist die relative Toleranz – sie ist der maximal zulässige Unterschied zwischen a und b, relativ zum größeren absoluten Wert von a oder b. Um beispielsweise eine Toleranz von 5 % festzulegen, übergeben Sie rel_tol=0.05. Die Standardtoleranz beträgt 1e-09, was sicherstellt, dass die beiden Werte innerhalb von etwa 9 Dezimalstellen übereinstimmen. rel_tol muss nicht-negativ und kleiner als 1.0 sein.

abs_tol ist die absolute Toleranz; sie beträgt standardmäßig 0.0 und muss nicht-negativ sein. Beim Vergleichen von x mit 0.0 wird isclose(x, 0) als abs(x) <= rel_tol  * abs(x) berechnet, was für jedes von Null verschiedene x und rel_tol kleiner als 1.0 False ist. Fügen Sie daher ein geeignetes positives abs_tol-Argument zum Aufruf hinzu.

Die IEEE 754 Spezialwerte NaN, inf und -inf werden gemäß den IEEE-Regeln behandelt. Insbesondere wird NaN nicht als nahe einem anderen Wert betrachtet, auch nicht als NaN. inf und -inf werden nur als nahe sich selbst betrachtet.

Hinzugefügt in Version 3.5.

Siehe auch

PEP 485 – Eine Funktion zum Testen auf annähernde Gleichheit

math.isfinite(x)

Gibt True zurück, wenn x weder eine Unendlichkeit noch ein NaN ist, andernfalls False. (Beachten Sie, dass 0.0 als endlich gilt.)

Hinzugefügt in Version 3.2.

math.isinf(x)

Gibt True zurück, wenn x eine positive oder negative Unendlichkeit ist, andernfalls False.

math.isnan(x)

Gibt True zurück, wenn x ein NaN (Not a Number) ist, andernfalls False.

math.ldexp(x, i)

Gibt x * (2**i) zurück. Dies ist im Wesentlichen die Umkehrfunktion von frexp().

math.nextafter(x, y, steps=1)

Gibt den Gleitkommawert zurück, der steps Schritte von x in Richtung y entfernt ist.

Wenn x gleich y ist, wird y zurückgegeben, es sei denn, steps ist null.

Beispiele

• math.nextafter(x, math.inf) geht nach oben: in Richtung positive Unendlichkeit.

• math.nextafter(x, -math.inf) geht nach unten: in Richtung negative Unendlichkeit.

• math.nextafter(x, 0.0) geht in Richtung Null.

• math.nextafter(x, math.copysign(math.inf, x)) geht von Null weg.

Siehe auch math.ulp().

Hinzugefügt in Version 3.9.

Geändert in Version 3.12: Das Argument steps wurde hinzugefügt.

math.ulp(x)

Gibt den Wert des am wenigsten signifikanten Bits des Gleitkommas x zurück.

• Wenn x ein NaN (Not a Number) ist, wird x zurückgegeben.

• Wenn x negativ ist, wird ulp(-x) zurückgegeben.

• Wenn x eine positive Unendlichkeit ist, wird x zurückgegeben.

• Wenn x gleich Null ist, wird der kleinste positive denormalisierte darstellbare Gleitkommawert zurückgegeben (kleiner als der kleinste positive normierte Gleitkommawert, sys.float_info.min).

• Wenn x gleich dem größten darstellbaren positiven Gleitkommawert ist, wird der Wert des am wenigsten signifikanten Bits von x zurückgegeben, sodass der erste Gleitkommawert, der kleiner als x ist, x - ulp(x) ist.

• Andernfalls (x ist eine positive endliche Zahl), wird der Wert des am wenigsten signifikanten Bits von x zurückgegeben, sodass der erste Gleitkommawert, der größer als x ist, x + ulp(x) ist.

ULP steht für „Unit in the Last Place“ (Einheit an letzter Stelle).

Siehe auch math.nextafter() und sys.float_info.epsilon.

Hinzugefügt in Version 3.9.

Potenz-, Exponential- und Logarithmusfunktionen

math.cbrt(x)

Gibt die Kubikwurzel von x zurück.

Hinzugefügt in Version 3.11.

math.exp(x)

Gibt e hoch x zurück, wobei e = 2.718281… die Basis der natürlichen Logarithmen ist. Dies ist in der Regel genauer als math.e ** x oder pow(math.e, x).

math.exp2(x)

Gibt 2 hoch x zurück.

Hinzugefügt in Version 3.11.

math.expm1(x)

Gibt e hoch x minus 1 zurück. Hier ist e die Basis der natürlichen Logarithmen. Für kleine Gleitkommazahlen x kann die Subtraktion in exp(x) - 1 zu einem signifikanten Genauigkeitsverlust führen; die Funktion expm1() bietet eine Möglichkeit, diese Größe mit voller Genauigkeit zu berechnen.

>>> from math import exp, expm1
>>> exp(1e-5) - 1  # gives result accurate to 11 places
1.0000050000069649e-05
>>> expm1(1e-5)    # result accurate to full precision
1.0000050000166668e-05

Hinzugefügt in Version 3.2.

math.log(x[, base])

Mit einem Argument gibt sie den natürlichen Logarithmus von x (zur Basis e) zurück.

Mit zwei Argumenten gibt sie den Logarithmus von x zur angegebenen base zurück, berechnet als log(x)/log(base).

math.log1p(x)

Gibt den natürlichen Logarithmus von 1+x (Basis e) zurück. Das Ergebnis wird so berechnet, dass es für x nahe Null genau ist.

math.log2(x)

Gibt den Basis-2-Logarithmus von x zurück. Dies ist in der Regel genauer als log(x, 2).

Hinzugefügt in Version 3.3.

Siehe auch

int.bit_length() gibt die Anzahl der Bits zurück, die zur Darstellung einer Ganzzahl in Binärform erforderlich sind, ausgenommen das Vorzeichen und führende Nullen.

math.log10(x)

Gibt den Basis-10-Logarithmus von x zurück. Dies ist in der Regel genauer als log(x, 10).

math.pow(x, y)

Gibt x hoch y zurück. Ausnahmefälle folgen dem IEEE 754-Standard, soweit möglich. Insbesondere geben pow(1.0, x) und pow(x, 0.0) immer 1.0 zurück, auch wenn x eine Null oder ein NaN ist. Wenn sowohl x als auch y endlich sind, x negativ ist und y keine ganze Zahl ist, ist pow(x, y) undefiniert und löst einen ValueError aus.

Im Gegensatz zum eingebauten Operator ** konvertiert math.pow() beide Argumente in den Typ float. Verwenden Sie ** oder die eingebaute Funktion pow() zur Berechnung exakter ganzzahliger Potenzen.

Geändert in Version 3.11: Die Sonderfälle pow(0.0, -inf) und pow(-0.0, -inf) wurden geändert, um inf zurückzugeben, anstatt ValueError auszulösen, um die Konsistenz mit IEEE 754 zu wahren.

math.sqrt(x)

Gibt die Quadratwurzel von x zurück.

Summen- und Produktfunktionen

math.dist(p, q)

Gibt den Euklidischen Abstand zwischen zwei Punkten p und q zurück, die jeweils als Sequenz (oder Iterable) von Koordinaten gegeben sind. Die beiden Punkte müssen die gleiche Dimension haben.

Etwa äquivalent zu

sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

Hinzugefügt in Version 3.8.

math.fsum(iterable)

Gibt eine genaue Gleitkommasumme der Werte im Iterable zurück. Vermeidet Genauigkeitsverlust durch Verfolgung mehrerer zwischenzeitlicher Teils summationen.

Die Genauigkeit des Algorithmus hängt von den IEEE-754-Garantien für die Arithmetik und dem typischen Fall ab, in dem der Rundungsmodus Half-even ist. Auf einigen Nicht-Windows-Builds verwendet die zugrunde liegende C-Bibliothek eine Gleitkomma-Addition mit erweiterter Genauigkeit und kann gelegentlich eine Zwischensumme doppelt runden, wodurch sie in ihrem am wenigsten signifikanten Bit abweicht.

Weitere Diskussionen und zwei alternative Ansätze finden Sie in den ASPN Cookbook-Rezepten für genaue Gleitkomma-Summationen.

math.hypot(*coordinates)

Gibt die Euklidische Norm zurück, sqrt(sum(x**2 for x in coordinates)). Dies ist die Länge des Vektors vom Ursprung zum Punkt, der durch die Koordinaten gegeben ist.

Für einen zweidimensionalen Punkt (x, y) ist dies äquivalent zur Berechnung der Hypotenuse eines rechtwinkligen Dreiecks unter Verwendung des Satzes des Pythagoras: sqrt(x*x + y*y).

Geändert in Version 3.8: Unterstützung für n-dimensionale Punkte hinzugefügt. Zuvor wurde nur der zweidimensionale Fall unterstützt.

Geändert in Version 3.10: Der Algorithmus wurde in Bezug auf die Genauigkeit verbessert, sodass der maximale Fehler unter 1 ulp (Unit in the Last Place) liegt. Typischerweise ist das Ergebnis fast immer auf 1/2 ulp genau gerundet.

math.prod(iterable, *, start=1)

Berechnet das Produkt aller Elemente im Eingabe-Iterable. Der Standard-start-Wert für das Produkt ist 1.

Wenn das Iterable leer ist, wird der Startwert zurückgegeben. Diese Funktion ist speziell für die Verwendung mit numerischen Werten vorgesehen und kann nicht-numerische Typen ablehnen.

Hinzugefügt in Version 3.8.

math.sumprod(p, q)

Gibt die Summe der Produkte von Werten aus zwei Iterables p und q zurück.

Löst ValueError aus, wenn die Eingaben nicht die gleiche Länge haben.

Etwa äquivalent zu

sum(map(operator.mul, p, q, strict=True))

Für Gleitkomma- und gemischte Ganzzahl-/Gleitkomma-Eingaben werden die Zwischenprodukte und Summen mit erweiterter Genauigkeit berechnet.

Hinzugefügt in Version 3.12.

Winkelkonvertierung

math.degrees(x)

Konvertiert den Winkel x von Radiant in Grad.

math.radians(x)

Konvertiert den Winkel x von Grad in Radiant.

Trigonometrische Funktionen

math.acos(x)

Gibt den Arkuskosinus von x in Radiant zurück. Das Ergebnis liegt zwischen 0 und pi.

math.asin(x)

Gibt den Arkussinus von x in Radiant zurück. Das Ergebnis liegt zwischen -pi/2 und pi/2.

math.atan(x)

Gibt den Arkustangens von x in Radiant zurück. Das Ergebnis liegt zwischen -pi/2 und pi/2.

math.atan2(y, x)

Gibt atan(y / x) in Radiant zurück. Das Ergebnis liegt zwischen -pi und pi. Der Vektor in der Ebene vom Ursprung zum Punkt (x, y) bildet diesen Winkel mit der positiven X-Achse. Der Sinn von atan2() ist, dass die Vorzeichen beider Eingaben bekannt sind, sodass der korrekte Quadrant für den Winkel berechnet werden kann. Zum Beispiel sind atan(1) und atan2(1, 1) beide pi/4, aber atan2(-1, -1) ist -3*pi/4.

math.cos(x)

Gibt den Kosinus von x Radiant zurück.

math.sin(x)

Gibt den Sinus von x Radiant zurück.

math.tan(x)

Gibt den Tangens von x Radiant zurück.

Hyperbolische Funktionen

Hyperbolische Funktionen sind Analoga trigonometrischer Funktionen, die auf Hyperbeln statt auf Kreisen basieren.

math.acosh(x)

Gibt den inversen hyperbolischen Kosinus von x zurück.

math.asinh(x)

Gibt den inversen hyperbolischen Sinus von x zurück.

math.atanh(x)

Gibt den inversen hyperbolischen Tangens von x zurück.

math.cosh(x)

Gibt den hyperbolischen Kosinus von x zurück.

math.sinh(x)

Gibt den hyperbolischen Sinus von x zurück.

math.tanh(x)

Gibt den hyperbolischen Tangens von x zurück.

Spezialfunktionen

math.erf(x)

Gibt die Fehlerfunktion bei x zurück.

Die Funktion erf() kann verwendet werden, um traditionelle statistische Funktionen wie die kumulative Standardnormalverteilung zu berechnen.

def phi(x):
    'Cumulative distribution function for the standard normal distribution'
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

Hinzugefügt in Version 3.2.

math.erfc(x)

Gibt die komplementäre Fehlerfunktion bei x zurück. Die komplementäre Fehlerfunktion ist definiert als 1.0 - erf(x). Sie wird für große Werte von x verwendet, bei denen eine Subtraktion von eins zu einem Genauigkeitsverlust führen würde.

Hinzugefügt in Version 3.2.

math.gamma(x)

Gibt die Gammafunktion bei x zurück.

Hinzugefügt in Version 3.2.

math.lgamma(x)

Gibt den natürlichen Logarithmus des Absolutbetrags der Gammafunktion bei x zurück.

Hinzugefügt in Version 3.2.

Konstanten

math.pi

Die mathematische Konstante π = 3.141592…, mit verfügbarer Genauigkeit.

math.e

Die mathematische Konstante e = 2.718281…, mit verfügbarer Genauigkeit.

math.tau

Die mathematische Konstante τ = 6.283185…, mit verfügbarer Genauigkeit. Tau ist eine Kreis konstant, die gleich 2π ist, dem Verhältnis des Umfangs eines Kreises zu seinem Radius. Um mehr über Tau zu erfahren, schauen Sie sich Vi Hearts Video Pi is (still) Wrong an und feiern Sie Tau-Tag, indem Sie doppelt so viel Kuchen essen!

Hinzugefügt in Version 3.6.

math.inf

Eine positive Gleitkomma-Unendlichkeit. (Für negative Unendlichkeit verwenden Sie -math.inf.) Entspricht der Ausgabe von float('inf').

Hinzugefügt in Version 3.5.

math.nan

Ein Gleitkommawert "nicht eine Zahl" (NaN). Entspricht der Ausgabe von float('nan'). Aufgrund der Anforderungen des IEEE 754-Standards werden math.nan und float('nan') nicht als gleich anderen numerischen Werten, einschließlich sich selbst, betrachtet. Um zu prüfen, ob eine Zahl ein NaN ist, verwenden Sie stattdessen die Funktion isnan(), um nach NaNs zu suchen, anstatt is oder ==. Beispiel

>>> import math
>>> math.nan == math.nan
False
>>> float('nan') == float('nan')
False
>>> math.isnan(math.nan)
True
>>> math.isnan(float('nan'))
True

Hinzugefügt in Version 3.5.

Geändert in Version 3.11: Es ist jetzt immer verfügbar.

CPython-Implementierungsdetail: Das math-Modul besteht hauptsächlich aus dünnen Wrappern um die plattformspezifischen C-Mathematikbibliotheksfunktionen. Das Verhalten in Ausnahmefällen folgt, wo zutreffend, Anhang F des C99-Standards. Die aktuelle Implementierung löst ValueError für ungültige Operationen wie sqrt(-1.0) oder log(0.0) aus (wo C99 Anhang F die Signalisierung von ungültigen Operationen oder Division durch Null empfiehlt) und OverflowError für Ergebnisse, die überlaufen (zum Beispiel exp(1000.0)). Ein NaN wird von keiner der oben genannten Funktionen zurückgegeben, es sei denn, mindestens ein Eingabeargument war ein NaN; in diesem Fall geben die meisten Funktionen ein NaN zurück, aber (wiederum gemäß C99 Anhang F) gibt es einige Ausnahmen von dieser Regel, zum Beispiel pow(float('nan'), 0.0) oder hypot(float('nan'), float('inf')).

Beachten Sie, dass Python keine Anstrengungen unternimmt, Signaling NaNs von Quiet NaNs zu unterscheiden, und das Verhalten für Signaling NaNs bleibt undefiniert. Typisches Verhalten ist, alle NaNs so zu behandeln, als wären sie quiet.

Siehe auch

Modul cmath

Versionen vieler dieser Funktionen für komplexe Zahlen.