Výpočet exponenciálnych a logaritmických funkcií v jazyku Python (exp, log, log10, log2)

obchodné

Pomocou math, štandardného modulu jazyka Python pre matematické funkcie, môžete vypočítať exponenciálne a logaritmické funkcie (prirodzený logaritmus, obyčajný logaritmus a binárny logaritmus).

Nasledujúci postup je vysvetlený spolu so vzorovým kódom.

  • Základ prirodzeného logaritmu (Napierovo číslo):math.e
  • Výkon::**operátor,pow(),math.pow()
  • Námestná odmocnina (koreň):math.sqrt()
  • Exponenciálna funkcia (prirodzená exponenciálna funkcia):math.exp()
  • logaritmická funkcia:math.log(),math.log10(),math.log2()

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

Základ prirodzeného logaritmu (Napierovo číslo) je v module math uvedený ako konštanta, označená math.e.

import math

print(math.e)
# 2.718281828459045

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

Na výpočet mocnín použite operátor **, vstavanú funkciu pow() alebo math.pow().

Y-kvadrát x sa získa 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() prevedie argument na typ s pohyblivou desatinnou čiarkou. Na druhej strane, vstavaná funkcia pow() v jazyku Python používa __pow()__ definovanú pre každý typ.

Napríklad funkcia pow() umožňuje zadávať ako argumenty komplexné typy, ale math.pow() nedokáže konvertovať komplexné typy na typy float, čo vedie k chybe.

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

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

Vstavaná funkcia pow() jazyka Python umožňuje aj tretí argument, pow(x, y, z), ktorý vracia zvyšok (zvyšok) z na mocninu y x. Je to rovnaký výpočet ako pow(x, y) % z, ale pow(x, y, z) je efektívnejší.

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

Námestná odmocnina (koreň): math.sqrt()

Druhú odmocninu (koreň) možno nastaviť na **0,5 pomocou ** alebo math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Podobne ako math.pow(), aj math.sqrt() konvertuje argumenty na typy s pohyblivou desatinnou čiarkou, takže zadanie typu, ktorý sa nedá konvertovať na typ float, bude mať za následok chybu TypeError.

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

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

Funkcia math.sqrt() tiež nedokáže spracovať záporné hodnoty, čo vedie k chybe ValueError.

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

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

Všimnite si, že pri práci s komplexnými číslami príklad s použitím operátora ** ukazuje chybu, ale modul cmath poskytuje presnejšiu hodnotu. Možno pracovať aj so zápornými hodnotami.

import cmath

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

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

Exponenciálna funkcia (prirodzená exponenciálna funkcia): math.exp()

Ak chcete vypočítať mocninu základu prirodzeného logaritmu (Napierovho čísla) e, použite math.exp().

math.exp(x) vráti x na druhú stranu e.
math.exp(x) nie je ekvivalentné s „math.e ** x“ a math.exp(x) je presnejšie.

print(math.exp(2))
# 7.38905609893065

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

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

Na výpočet logaritmickej funkcie použite math.log(),math.log10(),math.log2().

math.log(x, y) vráti logaritmus x so základom y.

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

Ak druhý argument vynecháte, prirodzený logaritmus sa zobrazí nižšie.

logaritmus

V matematike možno prirodzený logaritmus (logaritmus s Napierovým číslom e ako základom), reprezentovaný log alebo ln, vypočítať pomocou math.log(x).

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

logaritmus (základ 10)

Obyčajný logaritmus (logaritmus so základom 10) možno vypočítať pomocou math.log10(x), čo je presnejšie ako math.log(x, 10).

print(math.log10(100000))
# 5.0

binárny logaritmus

Binárny logaritmus (logaritmus so základom 2) možno vypočítať pomocou math.log2(x), čo je presnejšie ako math.log(x, 2).

print(math.log2(1024))
# 10.0
Copied title and URL