Compute exponential at logarithmic function sa Python (exp, log, log10, log2)

Negosyo

Gamit ang math, ang standard na module ng Python para sa mathematical function, maaari mong kalkulahin ang exponential at logarithmic function (natural logarithm, ordinaryong logarithm, at binary logarithm).

Ang mga sumusunod ay ipinaliwanag dito, kasama ang sample code.

  • Base ng natural logarithm (Napier number):math.e
  • kapangyarihan::**operator,pow(),math.pow()
  • Square root (ugat):math.sqrt()
  • Exponential function (natural exponential function):math.exp()
  • isang logarithmic function:math.log(),math.log10(),math.log2()

Base ng natural logarithm (Napier number):math.e

Ang base ng natural logarithm (Napier number) ay ibinibigay bilang constant sa math module, na tinutukoy ng math.e.

import math

print(math.e)
# 2.718281828459045

Power: ** operator, pow(), math.pow():**operator,pow(),math.pow()

Upang makalkula ang mga kapangyarihan, gamitin ang alinman sa ** operator, ang built-in na function na pow(), o math.pow().

Ang y-square ng x ay nakuha bilang mga sumusunod

  • 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

Kino-convert ng math.pow() ang argument sa isang floating-point na uri. Sa kabilang banda, ang built-in na function na pow() ng Python ay gumagamit ng __pow()__ na tinukoy para sa bawat uri.

Halimbawa, pinapayagan ng pow() ang mga kumplikadong uri na tukuyin bilang mga argumento, ngunit hindi mako-convert ng math.pow() ang mga kumplikadong uri sa mga float na uri, na nagreresulta sa isang error.

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

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

Ang Python built-in na function na pow() ay nagbibigay-daan din sa ikatlong argumento, pow(x, y, z), na nagbabalik ng natitira (natitira) ng z sa y-power ng x. Ito ay kapareho ng pagkalkula ng pow(x, y) % z, ngunit ang pow(x, y, z) ay mas mahusay.

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

Square root (ugat):math.sqrt()

Ang square root (root) ay maaaring itakda sa **0.5 gamit ang ** o math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Tulad ng math.pow(), ang math.sqrt() ay nagko-convert ng mga argumento sa mga floating-point na uri para sa pagproseso, kaya ang pagtukoy ng isang uri na hindi mako-convert sa isang float type ay magreresulta sa isang TypeError.

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

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

Gayundin, hindi maproseso ng math.sqrt() ang mga negatibong halaga, na nagreresulta sa isang ValueError.

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

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

Tandaan na kapag nakikitungo sa mga kumplikadong numero, ang halimbawa gamit ang ** operator ay nagpapakita ng isang error, ngunit ang cmath module ay nagbibigay ng isang mas tumpak na halaga. Ang mga negatibong halaga ay maaari ding pangasiwaan.

import cmath

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

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

Exponential function (natural exponential function):math.exp()

Upang kalkulahin ang kapangyarihan ng base ng natural na logarithm (Napier number) e, gamitin ang math.exp().

Ang math.exp(x) ay nagbabalik ng x squared ng e.
Ang math.exp(x) ay hindi katumbas ng “math.e ** x” at ang math.exp(x) ay mas tumpak.

print(math.exp(2))
# 7.38905609893065

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

isang logarithmic function:math.log(),math.log10(),math.log2()

Upang kalkulahin ang logarithmic function, gamitin ang math.log(),math.log10(),math.log2().

ibinabalik ng math.log(x, y) ang logarithm ng x na may y bilang base.

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

Kung ang pangalawang argumento ay tinanggal, ang natural na logarithm ay ipinapakita sa ibaba.

logarithm

Sa matematika, ang natural na logarithm (logarithm na may Napier number e bilang base), na kinakatawan ng log o ln, ay maaaring kalkulahin ng math.log(x).

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

logarithm (base 10)

Ang ordinaryong logarithm (logarithm na may base 10) ay maaaring kalkulahin gamit ang math.log10(x), na mas tumpak kaysa sa math.log(x, 10).

print(math.log10(100000))
# 5.0

binary logarithm

Ang binary logarithm (logarithm na may base 2) ay maaaring kalkulahin gamit ang math.log2(x), na mas tumpak kaysa sa math.log(x, 2).

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