Obliczanie funkcji wykładniczych i logarytmicznych w Pythonie (exp, log, log10, log2)

Biznes

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**y
  • pow(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