Eksponentti- ja logaritmifunktioiden laskeminen Pythonissa (exp, log, log10, log2).

liiketoiminta

Pythonin matemaattisten funktioiden standardimoduulin math avulla voit laskea eksponentti- ja logaritmifunktioita (luonnollinen logaritmi, tavallinen logaritmi ja binäärilogaritmi).

Seuraavat asiat selitetään tässä yhdessä esimerkkikoodin kanssa.

  • Luonnollisen logaritmin perusta (Napierin luku):math.e
  • Teho::**operaattori,pow(),math.pow()
  • Neliöjuuri (root):math.sqrt()
  • Eksponenttifunktio (luonnollinen eksponenttifunktio):math.exp()
  • logaritminen funktio:math.log(),math.log10(),math.log2()

Luonnollisen logaritmin perusta (Napierin luku): math.e

Luonnollisen logaritmin (Napierin luku) perusta annetaan vakiona matematiikkamoduulissa, jota merkitään math.e.

import math

print(math.e)
# 2.718281828459045

Teho: pow(), math.pow(): **-operaattori, pow(), math.pow(): **operaattori, pow(), math.pow()

Käytä potenssien laskemiseen joko **-operaattoria, sisäänrakennettua funktiota pow() tai math.pow().

x:n y-neliö saadaan seuraavasti

  • 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() muuntaa argumentin liukulukutyypiksi. Toisaalta Pythonin sisäänrakennettu funktio pow() käyttää kullekin tyypille määriteltyä __pow()__.

Esimerkiksi pow() sallii kompleksityyppien antamisen argumentteina, mutta math.pow() ei pysty muuntamaan kompleksityyppejä liukulukutyypeiksi, mikä johtaa virheeseen.

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

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

Pythonin sisäänrakennettu funktio pow() sallii myös kolmannen argumentin, pow(x, y, z), joka palauttaa z:n jäännöksen (jäännös) x:n y-potenssiin. Se on sama laskutoimitus kuin pow(x, y) % z, mutta pow(x, y, z) on tehokkaampi.

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

Neliöjuuri (root): math.sqrt()

Neliöjuuri (root) voidaan asettaa arvoon **0.5 käyttämällä ** tai math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Kuten math.pow(), myös math.sqrt() muuntaa argumentit liukulukutyypeiksi käsittelyä varten, joten sellaisen tyypin määrittäminen, jota ei voida muuntaa liukulukutyypiksi, johtaa TypeErroriin.

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

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

Myöskään math.sqrt() ei voi käsitellä negatiivisia arvoja, mikä johtaa ValueError-virheeseen.

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

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

Huomaa, että kompleksilukuja käsiteltäessä esimerkki, jossa käytetään **-operaattoria, näyttää virheen, mutta cmath-moduuli antaa tarkemman arvon. Myös negatiivisia arvoja voidaan käsitellä.

import cmath

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

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

Eksponenttifunktio (luonnollinen eksponenttifunktio): math.exp()

Voit laskea luonnollisen logaritmin (Napierin luku) e:n perustan potenssin käyttämällä math.exp().

math.exp(x) palauttaa x:n neliön e.
math.exp(x) ei vastaa ”math.e ** x” ja math.exp(x) on tarkempi.

print(math.exp(2))
# 7.38905609893065

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

logaritminen funktio: math.log(), math.log10(), math.log2()

Voit laskea logaritmifunktion käyttämällä math.log(),math.log10(),math.log2().

math.log(x, y) palauttaa x:n logaritmin, kun y on perusta.

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

Jos toinen argumentti jätetään pois, luonnollinen logaritmi esitetään alla.

logaritmi

Matematiikassa luonnollinen logaritmi (logaritmi, jonka perustana on Napierin luku e), jota edustaa log tai ln, voidaan laskea kaavalla math.log(x).

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

logaritmi (pohja 10)

Tavallinen logaritmi (logaritmi emäksellä 10) voidaan laskea komennolla math.log10(x), joka on tarkempi kuin math.log(x, 10).

print(math.log10(100000))
# 5.0

binäärilogaritmi

Binäärilogaritmi (logaritmi emäksellä 2) voidaan laskea komennolla math.log2(x), joka on tarkempi kuin math.log(x, 2).

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