Duke përdorur matematikën, modulin standard të Python-it për funksionet matematikore, mund të llogaritni funksionet eksponenciale dhe logaritmike (logaritmi natyror, logaritmi i zakonshëm dhe logaritmi binar).
Më poshtë shpjegohet këtu, së bashku me kodin e mostrës.
- Baza e logaritmit natyror (numri Napier):
math.e - Fuqia::
**operatori,pow(),math.pow() - Rrënja katrore (rrënja):
math.sqrt() - Funksioni eksponencial (funksioni eksponencial natyror):
math.exp() - një funksion logaritmik:
math.log(),math.log10(),math.log2()
Baza e logaritmit natyror (numri Napier):math.e
Baza e logaritmit natyror (numri Napier) jepet si konstante në modulin e matematikës, e shënuar me matematikë.e.
import math
print(math.e)
# 2.718281828459045
Fuqia: ** operator, pow(), math.pow():**operatori,pow(),math.pow()
Për të llogaritur fuqitë, përdorni ose operatorin **, funksionin e integruar pow(), ose math.pow().
y-katrori i x-it fitohet si më poshtë
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() konverton argumentin në një tip me pikë lundruese. Nga ana tjetër, funksioni i integruar i Python pow() përdor __pow()__ të përcaktuar për çdo lloj.
Për shembull, pow() lejon që llojet komplekse të specifikohen si argumente, por math.pow() nuk mund të konvertojë llojet komplekse në lloje float, duke rezultuar në një gabim.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
Funksioni i integruar në Python pow() lejon gjithashtu një argument të tretë, pow(x, y, z), i cili kthen pjesën e mbetur (mbetjen) e z në fuqinë y të x. Është e njëjta llogaritje si pow(x, y) % z, por pow(x, y, z) është më efikas.
print(pow(2, 4, 5))
# 1
Rrënja katrore (rrënja):math.sqrt()
Rrënja katrore (rrënja) mund të vendoset në **0.5 duke përdorur ** ose math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Ashtu si math.pow(), math.sqrt() konverton argumentet në lloje me pikë lundruese për përpunim, kështu që specifikimi i një lloji që nuk mund të konvertohet në një lloj float do të rezultojë në një TypeError.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
Gjithashtu, math.sqrt() nuk mund të përpunojë vlera negative, duke rezultuar në një ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Vini re se kur kemi të bëjmë me numra komplekse, shembulli duke përdorur operatorin ** tregon një gabim, por moduli cmath ofron një vlerë më të saktë. Mund të trajtohen edhe vlerat negative.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Funksioni eksponencial (funksioni eksponencial natyror):math.exp()
Për të llogaritur fuqinë e bazës së logaritmit natyror (numri Napier) e, përdorni math.exp().
matematika.exp(x) kthen x në katrorin e e.
math.exp(x) nuk është ekuivalente me “math.e ** x” dhe math.exp(x) është më e saktë.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
një funksion logaritmik:math.log(),math.log10(),math.log2()
Për të llogaritur funksionin logaritmik, përdorni math.log(),math.log10(),math.log2().
math.log(x, y) kthen logaritmin e x me y si bazë.
print(math.log(25, 5))
# 2.0
Nëse argumenti i dytë hiqet, logaritmi natyror tregohet më poshtë.
logaritmi
Në matematikë, logaritmi natyror (logaritmi me numrin Napier e si bazë), i përfaqësuar me log ose ln, mund të llogaritet me math.log(x).
print(math.log(math.e))
# 1.0
logaritmi (baza 10)
Logaritmi i zakonshëm (logaritmi me bazën 10) mund të llogaritet me math.log10(x), i cili është më i saktë se math.log(x, 10).
print(math.log10(100000))
# 5.0
logaritmi binar
Logaritmi binar (logaritmi me bazë 2) mund të llogaritet me math.log2(x), i cili është më i saktë se math.log(x, 2).
print(math.log2(1024))
# 10.0
