Met math, de standaardmodule van Python voor wiskundige functies, kunt u exponentiële en logaritmische functies berekenen (natuurlijke logaritme, gewone logaritme, en binaire logaritme).
Het volgende wordt hier uitgelegd, samen met voorbeeldcode.
- Basis van natuurlijke logaritme (getal van Napier):
math.e - Macht::
**operator,pow(),math.pow() - Vierkantswortel (wortel):
math.sqrt() - Exponentiële functie (natuurlijke exponentiële functie):
math.exp() - een logaritmische functie:
math.log(),math.log10(),math.log2()
Basis van natuurlijke logaritme (getal van Napier): math.e
De basis van de natuurlijke logaritme (getal van Napier) wordt gegeven als een constante in de wiskunde module, aangeduid met math.e.
import math
print(math.e)
# 2.718281828459045
Macht: ** operator, pow(), math.pow(): **operator, pow(), math.pow()
Om machten te berekenen, gebruik je ofwel de ** operator, ofwel de ingebouwde functie pow(), ofwel math.pow().
De y-kwadraat van x wordt als volgt verkregen
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() converteert het argument naar een floating-point type. Anderzijds gebruikt Python's ingebouwde functie pow() __pow()__ gedefinieerd voor elk type.
Bijvoorbeeld, pow() staat toe dat complexe types gespecificeerd worden als argumenten, maar math.pow() kan geen complexe types omzetten naar float types, wat resulteert in een fout.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
De Python ingebouwde functie pow() laat ook een derde argument toe, pow(x, y, z), dat de rest (rest) van z teruggeeft tot de y-macht van x. Het is dezelfde berekening als pow(x, y) % z, maar pow(x, y, z) is efficiënter.
print(pow(2, 4, 5))
# 1
Vierkantswortel (wortel): math.sqrt()
De vierkantswortel (wortel) kan worden ingesteld op **0,5 met ** of math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Net als math.pow() converteert math.sqrt() argumenten naar floating-point types voor verwerking, dus het specificeren van een type dat niet geconverteerd kan worden naar een float type zal resulteren in een TypeError.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
Ook kan math.sqrt() geen negatieve waarden verwerken, wat resulteert in een ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Merk op dat bij complexe getallen het voorbeeld met de ** operator een fout geeft, maar de cmath module geeft een nauwkeurigere waarde. Negatieve waarden kunnen ook behandeld worden.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Exponentiële functie (natuurlijke exponentiële functie): math.exp()
Om de macht van de basis van de natuurlijke logaritme (getal van Napier) e te berekenen, gebruik je math.exp().
math.exp(x) geeft x in het kwadraat van e.
math.exp(x) is niet equivalent met “math.e ** x” en math.exp(x) is nauwkeuriger.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
een logaritmische functie: math.log(), math.log10(), math.log2()
Om de logaritmische functie te berekenen, gebruik je math.log(),math.log10(),math.log2().
math.log(x, y) geeft de logaritme van x met y als basis.
print(math.log(25, 5))
# 2.0
Indien het tweede argument wordt weggelaten, wordt de natuurlijke logaritme hieronder weergegeven.
logaritme
In de wiskunde kan de natuurlijke logaritme (logaritme met het getal e van Napier als basis), weergegeven door log of ln, worden berekend door math.log(x).
print(math.log(math.e))
# 1.0
logaritme (basis 10)
De gewone logaritme (logaritme met basis 10) kan worden berekend met math.log10(x), wat nauwkeuriger is dan math.log(x, 10).
print(math.log10(100000))
# 5.0
binair logaritme
De binaire logaritme (logaritme met basis 2) kan worden berekend met math.log2(x), wat nauwkeuriger is dan math.log(x, 2).
print(math.log2(1024))
# 10.0