Eksponentsiaalsete ja logaritmiliste funktsioonide arvutamine Pythonis (exp, log, log10, log2)

Äri

Pythoni matemaatiliste funktsioonide standardmooduli math abil saab arvutada eksponentsiaal- ja logaritmifunktsioone (loomulik logaritm, tavalogaritm ja binaarne logaritm).

Siin selgitatakse järgmist koos näidiskoodiga.

  • Loomuliku logaritmi alus (Napier'i arv):math.e
  • Võimsus::**operaator,pow(),math.pow()
  • Ruutjuur (juur):math.sqrt()
  • Eksponentsiaalfunktsioon (loomulik eksponentsiaalfunktsioon):math.exp()
  • logaritmiline funktsioon:math.log(),math.log10(),math.log2()

Loomuliku logaritmi alus (Napier'i arv): math.e

Loomuliku logaritmi (Napier'i arv) alus on matemaatikamoodulis esitatud konstandina, mida tähistab math.e.

import math

print(math.e)
# 2.718281828459045

Võimsus: ** operaator, pow(), math.pow(): **operaator, pow(), math.pow()

Võimenduste arvutamiseks kasutage kas operaatorit **, sisseehitatud funktsiooni pow() või funktsiooni math.pow().

x-i y-ruut saadakse järgmiselt

  • 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() teisendab argumendi ujukoma-tüübiks. Teisalt kasutab Pythoni sisseehitatud funktsioon pow() iga tüübi jaoks määratletud __pow()__.

Näiteks pow() lubab argumentidena määrata kompleksseid tüüpe, kuid math.pow() ei saa kompleksseid tüüpe teisendada float-tüüpideks, mille tulemuseks on viga.

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

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

Pythoni sisseehitatud funktsioon pow() võimaldab ka kolmandat argumenti pow(x, y, z), mis tagastab z jäägi (jäägi) x-i y-powerisse. See on sama arvutus kui pow(x, y) % z, kuid pow(x, y, z) on tõhusam.

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

Ruutjuur (juur): math.sqrt()

Ruutjuure (juur) saab määrata **0,5, kasutades ** või math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Nagu math.pow(), konverteerib ka math.sqrt() argumendid töötlemiseks ujukoma tüüpi, nii et sellise tüübi määramine, mida ei saa teisendada ujukoma tüüpi, annab TypeError'i.

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

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

Samuti ei saa math.sqrt() töödelda negatiivseid väärtusi, mille tulemuseks on ValueError.

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

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

Pange tähele, et kompleksarvudega tegelemisel näitab näide operaatori ** kasutamisel viga, kuid cmath-moodul annab täpsema väärtuse. Negatiivseid väärtusi saab samuti käsitleda.

import cmath

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

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

Eksponentsiaalfunktsioon (loomulik eksponentsiaalfunktsioon): math.exp()

Loomuliku logaritmi (Napier'i arv) e aluse potentsi arvutamiseks kasutage funktsiooni math.exp().

math.exp(x) tagastab x ruutu e.
math.exp(x) ei ole samaväärne “math.e ** x” ja math.exp(x) on täpsem.

print(math.exp(2))
# 7.38905609893065

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

logaritmiline funktsioon: math.log(), math.log10(), math.log2()

Logaritmifunktsiooni arvutamiseks kasutage math.log(),math.log10(),math.log2().

math.log(x, y) tagastab x-i logaritmi, mille baasiks on y.

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

Kui teine argument jäetakse ära, on allpool esitatud naturaallogaritm.

logaritm

Matemaatikas saab loomulikku logaritmi (logaritm, mille baasiks on Napier'i arv e), mida kujutatakse log või ln, arvutada järgmiselt: math.log(x).

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

logaritm (baas 10)

Tavalist logaritmi (logaritm baasiga 10) saab arvutada programmiga math.log10(x), mis on täpsem kui math.log(x, 10).

print(math.log10(100000))
# 5.0

binaarne logaritm

Binaarset logaritmi (logaritm baasiga 2) saab arvutada math.log2(x) abil, mis on täpsem kui math.log(x, 2).

print(math.log2(1024))
# 10.0