Beräkna exponentiella och logaritmiska funktioner i Python (exp, log, log10, log2)

Företag

Med hjälp av math, Pythons standardmodul för matematiska funktioner, kan du beräkna exponentiella och logaritmiska funktioner (naturlig logaritm, vanlig logaritm och binär logaritm).

Följande förklaras här, tillsammans med exempelkod.

  • Basen för den naturliga logaritmen (Napier-talet):math.e
  • Effekt::**operatör,pow(),math.pow()
  • Kvadratrot (rot):math.sqrt()
  • Exponentialfunktion (naturlig exponentialfunktion):math.exp()
  • en logaritmisk funktion:math.log(),math.log10(),math.log2()

Basen för den naturliga logaritmen (Napier-talet): math.e

Basen för den naturliga logaritmen (Napier-talet) finns som en konstant i matematikmodulen, betecknad med math.e.

import math

print(math.e)
# 2.718281828459045

Kraft: ** operator, pow(), math.pow(): **operatör, pow(), math.pow()

För att beräkna potenser använder du antingen **-operatorn, den inbyggda funktionen pow() eller math.pow().

Y-kvadratet till x erhålls på följande sätt

  • 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() omvandlar argumentet till en flyttalstyp. Pythons inbyggda funktion pow() använder däremot __pow()__ som definieras för varje typ.

Pow() tillåter till exempel att komplexa typer anges som argument, men math.pow() kan inte konvertera komplexa typer till floattyper, vilket resulterar i ett fel.

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

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

Pythons inbyggda funktion pow() har också ett tredje argument, pow(x, y, z), som returnerar återstoden av z till y-potensen av x. Det är samma beräkning som pow(x, y) % z, men pow(x, y, z) är effektivare.

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

Kvadratrot (rot): math.sqrt()

Kvadratroten (root) kan sättas till **0,5 med ** eller math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Liksom math.pow() omvandlar math.sqrt() argumenten till flyttalstyper för bearbetning, så om du anger en typ som inte kan omvandlas till en flyttalstyp kommer det att resultera i ett TypeError.

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

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

Dessutom kan math.sqrt() inte behandla negativa värden, vilket resulterar i ett ValueError.

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

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

Observera att när det gäller komplexa tal visar exemplet med **-operatorn ett fel, men cmath-modulen ger ett mer exakt värde. Negativa värden kan också hanteras.

import cmath

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

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

Exponentialfunktion (naturlig exponentialfunktion): math.exp()

För att beräkna potensen av basen för den naturliga logaritmen (Napier-talet) e, använd math.exp().

math.exp(x) ger x i kvadrat av e.
math.exp(x) är inte likvärdigt med ”math.e ** x” och math.exp(x) är mer exakt.

print(math.exp(2))
# 7.38905609893065

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

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

För att beräkna den logaritmiska funktionen använder du math.log(),math.log10(),math.log2().

math.log(x, y) returnerar logaritmen för x med y som bas.

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

Om det andra argumentet utelämnas visas den naturliga logaritmen nedan.

logaritm

Inom matematiken kan den naturliga logaritmen (logaritmen med Napier-talet e som bas), representerad av log eller ln, beräknas genom math.log(x).

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

logaritm (bas 10)

Den vanliga logaritmen (logaritm med bas 10) kan beräknas med math.log10(x), som är mer exakt än math.log(x, 10).

print(math.log10(100000))
# 5.0

binär logaritm

Den binära logaritmen (logaritm med bas 2) kan beräknas med math.log2(x), som är mer exakt än math.log(x, 2).

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