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**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() 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