Mit math, dem Standardmodul von Python für mathematische Funktionen, können Sie exponentielle und logarithmische Funktionen (natürlicher Logarithmus, gewöhnlicher Logarithmus und binärer Logarithmus) berechnen.
Das Folgende wird hier erklärt, zusammen mit einem Beispielcode.
- Basis des natürlichen Logarithmus (Napier-Zahl):
math.e - Macht::
**Betreiber,pow(),math.pow() - Quadratwurzel (Wurzel):
math.sqrt() - Exponentialfunktion (natürliche Exponentialfunktion):
math.exp() - eine logarithmische Funktion:
math.log(),math.log10(),math.log2()
Basis des natürlichen Logarithmus (Napier-Zahl): math.e
Die Basis des natürlichen Logarithmus (Napier-Zahl) wird im Mathematikmodul als Konstante angegeben, die mit math.e bezeichnet wird.
import math
print(math.e)
# 2.718281828459045
Potenz: **-Operator, pow(), math.pow(): **Betreiber, pow(), math.pow()
Um Potenzen zu berechnen, verwenden Sie entweder den Operator **, die eingebaute Funktion pow() oder math.pow().
Das y-Quadrat von x erhält man wie folgt
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() wandelt das Argument in einen Fließkomma-Typ um. Andererseits verwendet die in Python eingebaute Funktion pow() die für jeden Typ definierte Funktion __pow()__.
Zum Beispiel erlaubt pow() die Angabe komplexer Typen als Argumente, aber math.pow() kann komplexe Typen nicht in Float-Typen umwandeln, was zu einem Fehler führt.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
Die in Python eingebaute Funktion pow() erlaubt auch ein drittes Argument, pow(x, y, z), das den Rest von z in der y-Potenz von x zurückgibt. Es ist die gleiche Berechnung wie pow(x, y) % z, aber pow(x, y, z) ist effizienter.
print(pow(2, 4, 5))
# 1
Quadratwurzel (Wurzel): math.sqrt()
Die Quadratwurzel (root) kann mit ** oder math.sqrt() auf **0,5 gesetzt werden.
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Wie math.pow() konvertiert math.sqrt() Argumente für die Verarbeitung in Fließkommatypen, so dass die Angabe eines Typs, der nicht in einen Fließkommatyp konvertiert werden kann, zu einem TypeError führt.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
Außerdem kann math.sqrt() keine negativen Werte verarbeiten, was zu einem ValueError führt.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Beachten Sie, dass beim Umgang mit komplexen Zahlen das Beispiel mit dem Operator ** einen Fehler anzeigt, das Modul cmath jedoch einen genaueren Wert liefert. Negative Werte können ebenfalls behandelt werden.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Exponentialfunktion (natürliche Exponentialfunktion): math.exp()
Um die Potenz der Basis des natürlichen Logarithmus (Napier-Zahl) e zu berechnen, verwenden Sie math.exp().
math.exp(x) gibt x zum Quadrat von e zurück.
math.exp(x) ist nicht gleichbedeutend mit “math.e ** x” und math.exp(x) ist genauer.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
eine logarithmische Funktion: math.log(), math.log10(), math.log2()
Um die logarithmische Funktion zu berechnen, verwenden Sie math.log(),math.log10(),math.log2().
math.log(x, y) gibt den Logarithmus von x mit y als Basis zurück.
print(math.log(25, 5))
# 2.0
Wenn das zweite Argument weggelassen wird, wird der natürliche Logarithmus wie folgt dargestellt.
Logarithmus
In der Mathematik kann der natürliche Logarithmus (Logarithmus mit der Napier-Zahl e als Basis), dargestellt durch log oder ln, durch math.log(x) berechnet werden.
print(math.log(math.e))
# 1.0
Logarithmus (zur Basis 10)
Der gewöhnliche Logarithmus (Logarithmus zur Basis 10) kann mit math.log10(x) berechnet werden, was genauer ist als math.log(x, 10).
print(math.log10(100000))
# 5.0
binärer Logarithmus
Der binäre Logarithmus (Logarithmus zur Basis 2) kann mit math.log2(x) berechnet werden, was genauer ist als math.log(x, 2).
print(math.log2(1024))
# 10.0
