Python Language
Mathematik-Modul
Suche…
Rundung: rund, Boden, Decke, Rumpf
Zusätzlich zu den integrierten in round Funktion, die math - Modul bietet den floor , ceil und trunc Funktionen.
x = 1.55
y = -1.55
# round to the nearest integer
round(x) # 2
round(y) # -2
# the second argument gives how many decimal places to round to (defaults to 0)
round(x, 1) # 1.6
round(y, 1) # -1.6
# math is a module so import it first, then use it.
import math
# get the largest integer less than x
math.floor(x) # 1
math.floor(y) # -2
# get the smallest integer greater than x
math.ceil(x) # 2
math.ceil(y) # -1
# drop fractional part of x
math.trunc(x) # 1, equivalent to math.floor for positive numbers
math.trunc(y) # -1, equivalent to math.ceil for negative numbers
floor , ceil , trunc und round immer einen float .
round(1.3) # 1.0
round bricht immer Krawatten von Null.
round(0.5) # 1.0
round(1.5) # 2.0
floor , ceil und trunc immer einen Integral , während round einen Integral zurückgibt, wenn sie mit einem Argument aufgerufen werden.
round(1.3) # 1
round(1.33, 1) # 1.3
round bricht Gleichungen zur nächsten geraden Zahl. Dies korrigiert die Tendenz zu größeren Zahlen, wenn eine große Anzahl von Berechnungen ausgeführt wird.
round(0.5) # 0
round(1.5) # 2
Warnung!
Wie bei jeder Gleitkommadarstellung können einige Brüche nicht genau dargestellt werden . Dies kann zu unerwartetem Rundungsverhalten führen.
round(2.675, 2) # 2.67, not 2.68!
Warnung vor der Boden-, Abbruch- und Ganzzahlteilung negativer Zahlen
Python (und C ++ und Java) runden bei negativen Zahlen von Null ab. Erwägen:
>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3
Logarithmen
math.log(x) gibt den natürlichen Logarithmus (Basis e ) von x .
math.log(math.e) # 1.0
math.log(1) # 0.0
math.log(100) # 4.605170185988092
math.log kann aufgrund von Beschränkungen der Fließkommazahlen mit Zahlen nahe 1 Genauigkeit verlieren. Um Logs nahe 1 zu berechnen, verwenden Sie math.log1p , die den natürlichen Logarithmus von 1 plus das Argument auswertet:
math.log(1 + 1e-20) # 0.0
math.log1p(1e-20) # 1e-20
math.log10 kann für Logs Base 10 verwendet werden:
math.log10(10) # 1.0
Bei Verwendung mit zwei Argumenten gibt math.log(x, base) den Logarithmus von x in der angegebenen base (dh log(x) / log(base) .
math.log(100, 10) # 2.0
math.log(27, 3) # 3.0
math.log(1, 10) # 0.0
Zeichen kopieren
In Python 2.6 und höher gibt math.copysign(x, y) x mit dem Zeichen von y . Der zurückgegebene Wert ist immer ein float .
math.copysign(-2, 3) # 2.0
math.copysign(3, -3) # -3.0
math.copysign(4, 14.2) # 4.0
math.copysign(1, -0.0) # -1.0, on a platform which supports signed zero
Trigonometrie
Länge der Hypotenuse berechnen
math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958
Grad in Radiant umrechnen
Alle math Funktionen erwarten Radiant, daher müssen Sie Grad in Radiant konvertieren:
math.radians(45) # Convert 45 degrees to radians
# Out: 0.7853981633974483
Alle Ergebnisse der inversen trigonometischen Funktionen geben das Ergebnis im Bogenmaß zurück, daher müssen Sie es möglicherweise in Grad umrechnen.
math.degrees(math.asin(1)) # Convert the result of asin to degrees
# Out: 90.0
Sinus-, Cosinus-, Tangenten- und Umkehrfunktionen
# Sine and arc sine
math.sin(math.pi / 2)
# Out: 1.0
math.sin(math.radians(90)) # Sine of 90 degrees
# Out: 1.0
math.asin(1)
# Out: 1.5707963267948966 # "= pi / 2"
math.asin(1) / math.pi
# Out: 0.5
# Cosine and arc cosine:
math.cos(math.pi / 2)
# Out: 6.123233995736766e-17
# Almost zero but not exactly because "pi" is a float with limited precision!
math.acos(1)
# Out: 0.0
# Tangent and arc tangent:
math.tan(math.pi/2)
# Out: 1.633123935319537e+16
# Very large but not exactly "Inf" because "pi" is a float with limited precision
math.atan(math.inf)
# Out: 1.5707963267948966 # This is just "pi / 2"
math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"
Neben dem math.atan gibt es auch eine math.atan2 Funktion mit zwei Argumenten, die den korrekten Quadranten berechnet und Fallstricke der Division durch Null vermeidet:
math.atan2(1, 2) # Equivalent to "math.atan(1/2)"
# Out: 0.4636476090008061 # ≈ 26.57 degrees, 1st quadrant
math.atan2(-1, -2) # Not equal to "math.atan(-1/-2)" == "math.atan(1/2)"
# Out: -2.677945044588987 # ≈ -153.43 degrees (or 206.57 degrees), 3rd quadrant
math.atan2(1, 0) # math.atan(1/0) would raise ZeroDivisionError
# Out: 1.5707963267948966 # This is just "pi / 2"
Hyperbolischer Sinus, Cosinus und Tangens
# Hyperbolic sine function
math.sinh(math.pi) # = 11.548739357257746
math.asinh(1) # = 0.8813735870195429
# Hyperbolic cosine function
math.cosh(math.pi) # = 11.591953275521519
math.acosh(1) # = 0.0
# Hyperbolic tangent function
math.tanh(math.pi) # = 0.99627207622075
math.atanh(0.5) # = 0.5493061443340549
Konstanten
math enthalten zwei häufig verwendete mathematische Konstanten.
-
math.pi- Die mathematische Konstante pi -
math.e- Die mathematische Konstante e (Basis des natürlichen Logarithmus)
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>
Python 3.5 und höher haben Konstanten für unendlich und NaN ("keine Zahl"). Die ältere Syntax der Übergabe eines Strings an float() funktioniert immer noch.
math.inf == float('inf')
# Out: True
-math.inf == float('-inf')
# Out: True
# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False
Imaginäre Zahlen
Imaginäre Zahlen in Python werden durch ein "j" oder "J" hinter der Zielnummer dargestellt.
1j # Equivalent to the square root of -1.
1j * 1j # = (-1+0j)
Infinity und NaN ("keine Zahl")
In allen Versionen von Python können wir unendlich und NaN ("keine Zahl") wie folgt darstellen:
pos_inf = float('inf') # positive infinity
neg_inf = float('-inf') # negative infinity
not_a_num = float('nan') # NaN ("not a number")
In Python 3.5 und höher können wir auch die definierten Konstanten math.inf und math.nan :
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan
Die String-Darstellungen werden als inf und -inf und nan angezeigt:
pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)
Wir können mit der isinf Methode auf positive oder negative Unendlichkeit isinf :
math.isinf(pos_inf)
# Out: True
math.isinf(neg_inf)
# Out: True
Wir können durch direkten Vergleich gezielt auf positive Unendlichkeit oder auf negative Unendlichkeit testen:
pos_inf == float('inf') # or == math.inf in Python 3.5+
# Out: True
neg_inf == float('-inf') # or == -math.inf in Python 3.5+
# Out: True
neg_inf == pos_inf
# Out: False
Python 3.2 und höher ermöglicht auch die Überprüfung der Endlichkeit:
math.isfinite(pos_inf)
# Out: False
math.isfinite(0.0)
# Out: True
Vergleichsoperatoren arbeiten erwartungsgemäß für positive und negative Unendlichkeit:
import sys
sys.float_info.max
# Out: 1.7976931348623157e+308 (this is system-dependent)
pos_inf > sys.float_info.max
# Out: True
neg_inf < -sys.float_info.max
# Out: True
Wenn jedoch ein arithmetischer Ausdruck einen Wert erzeugt, der größer als das Maximum ist, das als float , wird er unendlich.
pos_inf == sys.float_info.max * 1.0000001
# Out: True
neg_inf == -sys.float_info.max * 1.0000001
# Out: True
Die Division durch Null führt jedoch nicht zu einem Ergebnis von unendlich (oder, wenn angemessen, mit negativem unendlich), sondern löst eine ZeroDivisionError Ausnahme aus.
try:
x = 1.0 / 0.0
print(x)
except ZeroDivisionError:
print("Division by zero")
# Out: Division by zero
Rechenoperationen im Unendlichen geben nur unendliche Ergebnisse oder manchmal NaN:
-5.0 * pos_inf == neg_inf
# Out: True
-5.0 * neg_inf == pos_inf
# Out: True
pos_inf * neg_inf == neg_inf
# Out: True
0.0 * pos_inf
# Out: nan
0.0 * neg_inf
# Out: nan
pos_inf / pos_inf
# Out: nan
NaN ist niemals irgendetwas gleich, nicht einmal sich selbst. Wir können es mit der isnan Methode isnan :
not_a_num == not_a_num
# Out: False
math.isnan(not_a_num)
Out: True
NaN wird immer als "nicht gleich" verglichen, aber niemals kleiner als oder größer als:
not_a_num != 5.0 # or any random value
# Out: True
not_a_num > 5.0 or not_a_num < 5.0 or not_a_num == 5.0
# Out: False
Rechenoperationen an NaN geben immer NaN. Dies beinhaltet die Multiplikation mit -1: Es gibt kein "negatives NaN".
5.0 * not_a_num
# Out: nan
float('-nan')
# Out: nan
-math.nan
# Out: nan
Es gibt einen geringfügigen Unterschied zwischen den alten float Versionen von NaN und Infinity und den math Bibliothekskonstanten Python 3.5+:
math.inf is math.inf, math.nan is math.nan
# Out: (True, True)
float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)
Pow für schnellere Potenzierung
Verwenden des Timeit-Moduls über die Befehlszeile:
> python -m timeit 'for x in xrange(50000): b = x**3'
10 loops, best of 3: 51.2 msec per loop
> python -m timeit 'from math import pow' 'for x in xrange(50000): b = pow(x,3)'
100 loops, best of 3: 9.15 msec per loop
Der eingebaute ** -Operator ist oft praktisch, wenn Leistung jedoch von entscheidender Bedeutung ist, verwenden Sie math.pow. Beachten Sie jedoch, dass pow Float zurückgibt, auch wenn die Argumente Ganzzahlen sind:
> from math import pow
> pow(5,5)
3125.0
Komplexe Zahlen und das cmath-Modul
Das cmath Modul ähnelt dem math Modul, definiert jedoch Funktionen, die für die komplexe Ebene geeignet sind.
Komplexe Zahlen sind vor allem ein numerischer Typ, der Teil der Python-Sprache selbst ist und nicht von einer Bibliotheksklasse bereitgestellt wird. Daher müssen wir import cmath für gewöhnliche arithmetische Ausdrücke nicht import cmath .
Beachten Sie, dass wir j (oder J ) und nicht i .
z = 1 + 3j
Wir müssen 1j da j der Name einer Variablen und nicht ein numerisches Literal ist.
1j * 1j
Out: (-1+0j)
1j ** 1j
# Out: (0.20787957635076193+0j) # "i to the i" == math.e ** -(math.pi/2)
Wir haben den real und den imag (Imaginärteil) sowie das komplexe conjugate :
# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)
z.conjugate()
# Out: (1-3j) # z.conjugate() == z.real - z.imag * 1j
Die integrierten Funktionen abs und complex sind ebenfalls Teil der Sprache selbst und erfordern keinen Import:
abs(1 + 1j)
# Out: 1.4142135623730951 # square root of 2
complex(1)
# Out: (1+0j)
complex(imag=1)
# Out: (1j)
complex(1, 1)
# Out: (1+1j)
Die complex Funktion kann eine Zeichenfolge enthalten, darf jedoch keine Leerzeichen enthalten:
complex('1+1j')
# Out: (1+1j)
complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string
Für die meisten Funktionen benötigen wir jedoch das Modul, zum Beispiel sqrt :
import cmath
cmath.sqrt(-1)
# Out: 1j
Natürlich ist das Verhalten von sqrt bei komplexen Zahlen und reellen Zahlen unterschiedlich. In der nicht komplexen math löst die Quadratwurzel einer negativen Zahl eine Ausnahme aus:
import math
math.sqrt(-1)
# Exception: ValueError: math domain error
Es werden Funktionen zum Konvertieren in und von Polarkoordinaten bereitgestellt:
cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # == (sqrt(1 + 1), atan2(1, 1))
abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # same as previous calculation
cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)
Das mathematische Feld der komplexen Analyse liegt außerhalb des Rahmens dieses Beispiels, aber viele Funktionen in der komplexen Ebene haben einen "Astschnitt", üblicherweise entlang der realen Achse oder der imaginären Achse. Die meisten modernen Plattformen unterstützen die "Vorzeichenlose Null", wie in IEEE 754 angegeben, wodurch die Funktionen dieser Funktionen auf beiden Seiten des Astschnittes erhalten bleiben. Das folgende Beispiel stammt aus der Python-Dokumentation:
cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793
cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793
Das cmath Modul bietet auch viele Funktionen mit direkten Gegenstücken aus dem math .
Neben sqrt gibt es komplexe Versionen von exp , log , log10 , den trigonometrischen Funktionen und ihren Inversen ( sin , cos , tan , asin , acos , atan ) und den hyperbolischen Funktionen und ihren Inversen ( sinh , cosh , tanh , asinh , acosh , atanh ). Es gibt jedoch kein komplexes Gegenstück zu math.atan2 , der Zwei-Argument-Form von arctangent.
cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)
cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j) # e to the i pi == -1, within rounding error
Die Konstanten pi und e sind angegeben. Beachten Sie, dass diese float und nicht complex .
type(cmath.pi)
# Out: <class 'float'>
Das cmath Modul bietet auch komplexe Versionen von isinf und (für Python 3.2+) ist isfinite . Siehe " Infinity und NaN ". Eine komplexe Zahl wird als unendlich betrachtet, wenn entweder der Realteil oder der Imaginärteil unendlich ist.
cmath.isinf(complex(float('inf'), 0.0))
# Out: True
Ebenso bietet das cmath Modul eine komplexe Version von isnan . Siehe " Infinity und NaN ". Eine komplexe Zahl wird als "keine Zahl" betrachtet, wenn entweder ihr Realteil oder ihr Imaginärteil "keine Zahl" ist.
cmath.isnan(0.0, float('nan'))
# Out: True
Beachten Sie, dass es kein cmath Gegenstück zu den Konstanten math.inf und math.nan (ab Python 3.5 und höher).
cmath.isinf(complex(0.0, math.inf))
# Out: True
cmath.isnan(complex(math.nan, 0.0))
# Out: True
cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'
In Python 3.5 und höher gibt es in den Modulen cmath und math eine isclose Methode.
z = cmath.rect(*cmath.polar(1+1j))
z
# Out: (1.0000000000000002+1.0000000000000002j)
cmath.isclose(z, 1+1j)
# True
