Beregne eksponentielle og logaritmiske funktioner i Python (exp, log, log10, log2)

Forretning

Ved hjælp af math, Pythons standardmodul for matematiske funktioner, kan du beregne eksponentielle og logaritmiske funktioner (naturlig logaritme, almindelig logaritme og binær logaritme).

Følgende forklares her sammen med en kodeeksempel.

  • Basis for den naturlige logaritme (Napier-tallet):math.e
  • Strøm::**operatør,pow(),math.pow()
  • Kvadratrod (rod):math.sqrt()
  • Eksponentialfunktion (naturlig eksponentialfunktion):math.exp()
  • en logaritmisk funktion:math.log(),math.log10(),math.log2()

Basis for den naturlige logaritme (Napier-tallet): math.e

Basen for den naturlige logaritme (Napier-tallet) er angivet som en konstant i matematikmodulet, angivet med math.e.

import math

print(math.e)
# 2.718281828459045

Strøm: Pow: ** operator, pow(), math.pow(): **operatør, pow(), math.pow()

For at beregne potenser skal du bruge enten operatoren **, den indbyggede funktion pow() eller math.pow().

Y-kvadratet af x fås på følgende måde

  • 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() konverterer argumentet til en flydepunktstype. På den anden side bruger Pythons indbyggede funktion pow() __pow()__ defineret for hver type.

F.eks. tillader pow(), at komplekse typer angives som argumenter, men math.pow() kan ikke konvertere komplekse typer til float-typer, hvilket resulterer i en fejl.

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

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

Den indbyggede Python-funktion pow() har også et tredje argument, pow(x, y, z), som returnerer resten (rest) af z til y-potens af x. Det er den samme beregning som pow(x, y) % z, men pow(x, y, z) er mere effektiv.

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

Kvadratrod (rod): math.sqrt()

Kvadratroden (root) kan indstilles til **0,5 ved hjælp af ** eller math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Ligesom math.pow() konverterer math.sqrt() argumenter til floating-point-typer med henblik på behandling, så hvis du angiver en type, der ikke kan konverteres til en float-type, vil det resultere i en TypeError.

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

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

Desuden kan math.sqrt() ikke behandle negative værdier, hvilket resulterer i en ValueError.

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

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

Bemærk, at når der er tale om komplekse tal, viser eksemplet med **-operatoren en fejl, men cmath-modulet giver en mere præcis værdi. Negative værdier kan også håndteres.

import cmath

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

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

Eksponentialfunktion (naturlig eksponentialfunktion): math.exp()

Hvis du vil beregne potensen af basen af den naturlige logaritme (Napier-tallet) e, skal du bruge math.exp().

math.exp(x) returnerer x kvadreret af e.
math.exp(x) svarer ikke til “math.e ** x”, og math.exp(x) er mere nøjagtigt.

print(math.exp(2))
# 7.38905609893065

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

en logaritmisk funktion: math.log(), math.log10(), math.log2()

For at beregne den logaritmiske funktion skal du bruge math.log(),math.log10(),math.log2().

math.log(x, y) returnerer logaritmen af x med y som base.

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

Hvis det andet argument udelades, vises den naturlige logaritme som vist nedenfor.

logaritme

I matematik kan den naturlige logaritme (logaritme med Napier-tallet e som base), repræsenteret ved log eller ln, beregnes ved math.log(x).

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

logaritme (base 10)

Den almindelige logaritme (logaritme med base 10) kan beregnes med math.log10(x), som er mere nøjagtig end math.log(x, 10).

print(math.log10(100000))
# 5.0

binær logaritme

Den binære logaritme (logaritme med base 2) kan beregnes med math.log2(x), som er mere nøjagtig end math.log(x, 2).

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