Calcolare funzioni esponenziali e logaritmiche in Python (exp, log, log10, log2)

Attività commerciale

Usando math, il modulo standard di Python per le funzioni matematiche, puoi calcolare funzioni esponenziali e logaritmiche (logaritmo naturale, logaritmo ordinario e logaritmo binario).

Ciò che segue è spiegato qui, insieme al codice di esempio.

  • Base del logaritmo naturale (numero di Napier):math.e
  • Potenza::**operatore,pow(),math.pow()
  • Radice quadrata (radice):math.sqrt()
  • Funzione esponenziale (funzione esponenziale naturale):math.exp()
  • una funzione logaritmica:math.log(),math.log10(),math.log2()

Base del logaritmo naturale (numero di Napier): math.e

La base del logaritmo naturale (numero di Napier) è fornita come una costante nel modulo math, indicata da math.e.

import math

print(math.e)
# 2.718281828459045

Potenza: operatore **, pow(), math.pow(): **operatore, pow(), math.pow()

Per calcolare le potenze, usate l'operatore **, la funzione built-in pow() o math.pow().

Il quadrato y di x si ottiene come segue

  • 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() converte l'argomento in un tipo a virgola mobile. D'altra parte, la funzione built-in di Python pow() usa __pow()__ definita per ogni tipo.

Per esempio, pow() permette di specificare tipi complessi come argomenti, ma math.pow() non può convertire tipi complessi in tipi float, causando un errore.

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

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

La funzione built-in di Python pow() permette anche un terzo argomento, pow(x, y, z), che restituisce il resto (remainder) di z alla potenza y di x. È lo stesso calcolo di pow(x, y) % z, ma pow(x, y, z) è più efficiente.

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

Radice quadrata (radice): math.sqrt()

La radice quadrata (root) può essere impostata a **0,5 usando ** o math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Come math.pow(), math.sqrt() converte gli argomenti in tipi a virgola mobile per l'elaborazione, quindi specificare un tipo che non può essere convertito in un tipo float risulterà in un TypeError.

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

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

Inoltre, math.sqrt() non può elaborare valori negativi, risultando in un ValueError.

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

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

Notate che quando si tratta di numeri complessi, l'esempio che usa l'operatore ** mostra un errore, ma il modulo cmath fornisce un valore più accurato. Anche i valori negativi possono essere gestiti.

import cmath

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

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

Funzione esponenziale (funzione esponenziale naturale): math.exp()

Per calcolare la potenza della base del logaritmo naturale (numero di Napier) e, usate math.exp().

math.exp(x) restituisce x al quadrato di e.
math.exp(x) non è equivalente a “math.e ** x” e math.exp(x) è più preciso.

print(math.exp(2))
# 7.38905609893065

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

una funzione logaritmica: math.log(), math.log10(), math.log2()

Per calcolare la funzione logaritmica, usa math.log(),math.log10(),math.log2().

math.log(x, y) restituisce il logaritmo di x con y come base.

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

Se il secondo argomento viene omesso, il logaritmo naturale è mostrato qui sotto.

logaritmo

In matematica, il logaritmo naturale (logaritmo con il numero Napier e come base), rappresentato da log o ln, può essere calcolato da math.log(x).

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

logaritmo (base 10)

Il logaritmo ordinario (logaritmo con base 10) può essere calcolato con math.log10(x), che è più preciso di math.log(x, 10).

print(math.log10(100000))
# 5.0

logaritmo binario

Il logaritmo binario (logaritmo con base 2) può essere calcolato con math.log2(x), che è più preciso di math.log(x, 2).

print(math.log2(1024))
# 10.0