Výpočet exponenciálních a logaritmických funkcí v jazyce Python (exp, log, log10, log2)

Podnikání

Pomocí math, standardního modulu jazyka Python pro matematické funkce, můžete vypočítat exponenciální a logaritmické funkce (přirozený logaritmus, obyčejný logaritmus a binární logaritmus).

Zde je vysvětlen následující postup spolu s ukázkovým kódem.

  • Základ přirozeného logaritmu (Napierovo číslo):math.e
  • Výkon::**operátor,pow(),math.pow()
  • Druhá odmocnina (kořen):math.sqrt()
  • Exponenciální funkce (přirozená exponenciální funkce):math.exp()
  • logaritmická funkce:math.log(),math.log10(),math.log2()

Základ přirozeného logaritmu (Napierovo číslo): math.e

Základ přirozeného logaritmu (Napierova čísla) je v matematickém modulu uveden jako konstanta, označená math.e.

import math

print(math.e)
# 2.718281828459045

Výkon: operátor **, pow(), math.pow(): **operátor, pow(), math.pow()

Pro výpočet mocnin použijte operátor **, vestavěnou funkci pow() nebo math.pow().

Y-kvadrát x se získá takto

  • 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() převede argument na typ s plovoucí desetinnou čárkou. Naproti tomu vestavěná funkce pow() v jazyce Python používá __pow()__ definovanou pro každý typ.

Například funkce pow() umožňuje zadávat jako argumenty komplexní typy, ale funkce math.pow() nedokáže převést komplexní typy na typy float, což vede k chybě.

print(pow(1 + 1j, 2))
# 2j

# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float

Vestavěná funkce pow() jazyka Python umožňuje také třetí argument, pow(x, y, z), který vrací zbytek (zbytek) z na mocninu y x. Jedná se o stejný výpočet jako pow(x, y) % z, ale pow(x, y, z) je efektivnější.

print(pow(2, 4, 5))
# 1

Druhá odmocnina (kořen): math.sqrt()

Druhou odmocninu (root) lze nastavit na **0,5 pomocí ** nebo math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

print(2**0.5 == math.sqrt(2))
# True

Stejně jako funkce math.pow() i funkce math.sqrt() převádí argumenty na typy s plovoucí desetinnou čárkou, takže zadání typu, který nelze převést na typ float, vede k chybě TypeError.

print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)

# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float

Funkce math.sqrt() také nedokáže zpracovat záporné hodnoty, což vede k chybě ValueError.

print((-1)**0.5)
# (6.123233995736766e-17+1j)

# print(math.sqrt(-1))
# ValueError: math domain error

Všimněte si, že při práci s komplexními čísly ukazuje příklad s operátorem ** chybu, ale modul cmath poskytuje přesnější hodnotu. Lze pracovat i se zápornými hodnotami.

import cmath

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

Exponenciální funkce (přirozená exponenciální funkce): math.exp()

Chcete-li vypočítat mocninu základu přirozeného logaritmu (Napierova čísla) e, použijte math.exp().

math.exp(x) vrátí x na druhou z e.
math.exp(x) není ekvivalentní „math.e ** x“ a math.exp(x) je přesnější.

print(math.exp(2))
# 7.38905609893065

print(math.exp(2) == math.e**2)
# False

logaritmická funkce: math.log(), math.log10(), math.log2()

Pro výpočet logaritmické funkce použijte math.log(),math.log10(),math.log2().

math.log(x, y) vrátí logaritmus x se základem y.

print(math.log(25, 5))
# 2.0

Pokud je druhý argument vynechán, je přirozený logaritmus zobrazen níže.

logaritmus

V matematice lze přirozený logaritmus (logaritmus s Napierovým číslem e jako základem), reprezentovaný log nebo ln, vypočítat pomocí math.log(x).

print(math.log(math.e))
# 1.0

logaritmus (základ 10)

Obyčejný logaritmus (logaritmus se základem 10) lze vypočítat pomocí math.log10(x), což je přesnější než math.log(x, 10).

print(math.log10(100000))
# 5.0

binární logaritmus

Binární logaritmus (logaritmus se základem 2) lze vypočítat pomocí math.log2(x), což je přesnější než math.log(x, 2).

print(math.log2(1024))
# 10.0