Izračun eksponentnih in logaritemskih funkcij v Pythonu (exp, log, log10, log2)

Posel

Z math, Pythonovim standardnim modulom za matematične funkcije, lahko izračunate eksponentne in logaritemske funkcije (naravni logaritem, navadni logaritem in binarni logaritem).

V nadaljevanju je razloženo naslednje, skupaj z vzorčno kodo.

  • Osnova naravnega logaritma (Napierjevo število):math.e
  • Moč::**operater,pow(),math.pow()
  • Kvadratni koren (koren):math.sqrt()
  • Eksponentna funkcija (naravna eksponentna funkcija):math.exp()
  • logaritemska funkcija:math.log(),math.log10(),math.log2()

Osnova naravnega logaritma (Napierjevo število): math.e

Osnova naravnega logaritma (Napierjevo število) je v modulu math na voljo kot konstanta, označena z math.e.

import math

print(math.e)
# 2.718281828459045

Moč: **, pow(), math.pow(): **operater, pow(), math.pow()

Za izračun moči uporabite operator **, vgrajeno funkcijo pow() ali math.pow().

Y-kvadrat x dobimo na naslednji način

  • 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() pretvori argument v tip s plavajočo vejico. Po drugi strani pa Pythonova vgrajena funkcija pow() uporablja __pow()__, opredeljeno za vsak tip.

Funkcija pow() na primer omogoča, da kot argumente navedete kompleksne tipe, vendar math.pow() ne more pretvoriti kompleksnih tipov v tipe float, zaradi česar se pojavi napaka.

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

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

Pythonova vgrajena funkcija pow() omogoča tudi tretji argument, pow(x, y, z), ki vrne ostanek (preostanek) z na y-možnost x. Gre za enak izračun kot pow(x, y) % z, vendar je pow(x, y, z) učinkovitejši.

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

Kvadratni koren (koren): math.sqrt()

Kvadratni koren (koren) lahko nastavite na **0,5 z uporabo ** ali math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Tako kot math.pow() tudi math.sqrt() pretvori argumente v tipe s plavajočo vejico za obdelavo, zato navedba tipa, ki ga ni mogoče pretvoriti v tip float, povzroči TypeError.

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

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

Poleg tega funkcija math.sqrt() ne more obdelati negativnih vrednosti, kar povzroči napako ValueError.

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

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

Upoštevajte, da primer z uporabo operatorja ** pri kompleksnih številih pokaže napako, modul cmath pa zagotovi natančnejšo vrednost. Obravnavajo se lahko tudi negativne vrednosti.

import cmath

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

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

Eksponentna funkcija (naravna eksponentna funkcija): math.exp()

Če želite izračunati moč osnove naravnega logaritma (Napierjevo število) e, uporabite math.exp().

math.exp(x) vrne kvadrat x iz e.
math.exp(x) ni enakovredno “math.e ** x” in math.exp(x) je natančnejše.

print(math.exp(2))
# 7.38905609893065

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

logaritemska funkcija: math.log(), math.log10(), math.log2()

Za izračun logaritemske funkcije uporabite math.log(),math.log10(),math.log2().

math.log(x, y) vrne logaritem x z osnovo y.

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

Če drugi argument izpustite, je naravni logaritem prikazan spodaj.

logaritem

V matematiki lahko naravni logaritem (logaritem z Napierjevim številom e kot osnovo), predstavljen z log ali ln, izračunamo z math.log(x).

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

logaritem (osnova 10)

Navadni logaritem (logaritem z osnovo 10) lahko izračunate z math.log10(x), ki je natančnejši od math.log(x, 10).

print(math.log10(100000))
# 5.0

binarni logaritem

Binarni logaritem (logaritem z osnovo 2) lahko izračunate z math.log2(x), ki je natančnejši od math.log(x, 2).

print(math.log2(1024))
# 10.0