Exponenciális és logaritmikus függvények számítása Pythonban (exp, log, log10, log2)

Üzleti

A matematika, a Python matematikai függvények szabványos modulja, a math segítségével exponenciális és logaritmikus függvényeket (természetes logaritmus, közönséges logaritmus és bináris logaritmus) számolhat.

A következőket itt magyarázzuk el, mintakóddal együtt.

  • A természetes logaritmus bázisa (Napier-szám):math.e
  • Teljesítmény::**üzemeltető,pow(),math.pow()
  • Négyzetgyök (gyök):math.sqrt()
  • Exponenciális függvény (természetes exponenciális függvény):math.exp()
  • logaritmikus függvény:math.log(),math.log10(),math.log2()

A természetes logaritmus bázisa (Napier-szám): math.e

A természetes logaritmus (Napier-szám) bázisát a matematikai modulban konstansként adjuk meg, amelyet math.e-vel jelölünk.

import math

print(math.e)
# 2.718281828459045

Teljesítmény: ** pow(), math.pow(): **üzemeltető, pow(), math.pow()

A hatványok kiszámításához használja a ** operátort, a pow() beépített függvényt vagy a math.pow() függvényt.

Az x y-négyzetét a következőképpen kapjuk meg

  • 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

A math.pow() az argumentumot lebegőpontos típussá alakítja. Másrészt a Python beépített pow() függvénye az egyes típusokhoz definiált __pow()__-t használja.

A pow() például lehetővé teszi, hogy komplex típusokat adjunk meg argumentumként, de a math.pow() nem tudja a komplex típusokat float típusokká konvertálni, ami hibát eredményez.

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

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

A Python beépített pow() függvénye egy harmadik argumentumot is megenged, pow(x, y, z), amely visszaadja z maradékát (maradékát) x y-hatványára. Ez ugyanaz a számítás, mint a pow(x, y) % z, de a pow(x, y, z) hatékonyabb.

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

Négyzetgyök (gyök): math.sqrt()

A négyzetgyök (gyök) **0.5-re állítható a ** vagy a math.sqrt() segítségével.

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

A math.pow() függvényhez hasonlóan a math.sqrt() is lebegőpontos típusba konvertálja az argumentumokat a feldolgozáshoz, így egy olyan típus megadása, amely nem konvertálható lebegőpontos típusba, TypeError-t eredményez.

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

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

A math.sqrt() nem tudja feldolgozni a negatív értékeket, ami ValueError-t eredményez.

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

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

Vegyük észre, hogy komplex számok esetén a ** operátort használó példa hibát mutat, de a cmath modul pontosabb értéket ad. A negatív értékek is kezelhetők.

import cmath

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

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

Exponenciális függvény (természetes exponenciális függvény): math.exp()

A természetes logaritmus (Napier-szám) e bázisának hatványának kiszámításához használja a math.exp() függvényt.

A math.exp(x) visszaadja x négyzetét e-nek.
A math.exp(x) nem egyenértékű a “math.e ** x”-el, és a math.exp(x) pontosabb.

print(math.exp(2))
# 7.38905609893065

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

logaritmikus függvény: math.log(), math.log10(), math.log2()

A logaritmikus függvény kiszámításához használja a math.log(),math.log10(),math.log2() függvényeket.

A math.log(x, y) az x logaritmusát adja vissza y bázissal.

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

Ha a második argumentumot elhagyjuk, a természetes logaritmus az alábbiakban látható.

logaritmus

A matematikában a természetes logaritmus (logaritmus Napier e számmal bázisként), amelyet log vagy ln jelképez, kiszámítható a math.log(x) paranccsal.

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

logaritmus (10-es bázis)

A közönséges logaritmus (logaritmus 10-es bázissal) kiszámítható a math.log10(x) paranccsal, amely pontosabb, mint a math.log(x, 10).

print(math.log10(100000))
# 5.0

bináris logaritmus

A bináris logaritmus (logaritmus 2 bázissal) kiszámítható a math.log2(x) segítségével, amely pontosabb, mint a math.log(x, 2).

print(math.log2(1024))
# 10.0