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**ypow(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