Korzystając z math, standardowego modułu Pythona służącego do obsługi funkcji matematycznych, można obliczać funkcje wykładnicze i logarytmiczne (logarytm naturalny, logarytm zwykły i logarytm binarny).
Objaśniono tu następujące zagadnienia wraz z przykładowym kodem.
- Podstawa logarytmu naturalnego (liczba Napiera):
math.e - Moc::
**operator,pow(),math.pow() - Pierwiastek kwadratowy (root):
math.sqrt() - Funkcja wykładnicza (naturalna funkcja wykładnicza):
math.exp() - funkcja logarytmiczna:
math.log(),math.log10(),math.log2()
Podstawa logarytmu naturalnego (liczba Napiera): math.e
Podstawa logarytmu naturalnego (liczby Napiera) jest podana jako stała w module math, oznaczana jako math.e.
import math
print(math.e)
# 2.718281828459045
Potęga: ** operator, pow(), math.pow(): **operator, pow(), math.pow()
Aby obliczyć potęgi, należy użyć operatora **, wbudowanej funkcji pow() lub math.pow().
Kwadrat y z x otrzymuje się w następujący sposób
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() konwertuje argument na typ zmiennoprzecinkowy. Z drugiej strony, wbudowana funkcja pow() Pythona używa funkcji __pow()__ zdefiniowanej dla każdego typu.
Na przykład funkcja pow() dopuszcza podawanie typów złożonych jako argumentów, ale funkcja math.pow() nie potrafi konwertować typów złożonych na typy float, co skutkuje błędem.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
Wbudowana funkcja Pythona pow() dopuszcza również trzeci argument, pow(x, y, z), który zwraca resztę (resztę) z do potęgi y potęgi x. Jest to takie samo obliczenie jak pow(x, y) % z, ale pow(x, y, z) jest bardziej wydajne.
print(pow(2, 4, 5))
# 1
Pierwiastek kwadratowy (root): math.sqrt()
Pierwiastek kwadratowy (root) można ustawić na wartość **0,5 za pomocą ** lub funkcji math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Podobnie jak funkcja math.pow(), funkcja math.sqrt() konwertuje argumenty na typy zmiennoprzecinkowe do przetwarzania, więc podanie typu, który nie może zostać przekonwertowany na typ float, spowoduje błąd typu.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
Ponadto funkcja math.sqrt() nie może przetwarzać wartości ujemnych, co powoduje wystąpienie błędu ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Zwróć uwagę, że w przypadku liczb zespolonych przykład z użyciem operatora ** pokazuje błąd, ale moduł cmath podaje dokładniejszą wartość. Można również obsługiwać wartości ujemne.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Funkcja wykładnicza (naturalna funkcja wykładnicza): math.exp()
Aby obliczyć potęgę podstawy logarytmu naturalnego (liczby Napiera) e, należy użyć funkcji math.exp().
math.exp(x) zwraca wartość x podniesioną do kwadratu z e.
math.exp(x) nie jest równoznaczne z „math.e ** x”, a math.exp(x) jest dokładniejsze.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
funkcja logarytmiczna: math.log(), math.log10(), math.log2()
Aby obliczyć funkcję logarytmiczną, użyj funkcji math.log(),math.log10(),math.log2().
math.log(x, y) zwraca logarytm z x, którego podstawą jest y.
print(math.log(25, 5))
# 2.0
Jeśli drugi argument zostanie pominięty, logarytm naturalny zostanie przedstawiony poniżej.
logarytm
W matematyce logarytm naturalny (logarytm z liczbą Napiera o podstawie e), oznaczany jako log lub ln, można obliczyć za pomocą wzoru math.log(x).
print(math.log(math.e))
# 1.0
logarytm (podstawa 10)
Zwykły logarytm (logarytm o podstawie 10) można obliczyć za pomocą polecenia math.log10(x), które jest dokładniejsze niż math.log(x, 10).
print(math.log10(100000))
# 5.0
logarytm binarny
Logarytm binarny (logarytm o podstawie 2) można obliczyć za pomocą polecenia math.log2(x), które jest dokładniejsze niż math.log(x, 2).
print(math.log2(1024))
# 10.0