Usando math, il modulo standard di Python per le funzioni matematiche, puoi calcolare funzioni trigonometriche (sin, cos, tan) e funzioni trigonometriche inverse (arcsin, arccos, arctan).
I seguenti contenuti sono spiegati qui con codici di esempio.
- Pi greco (3,1415926..):
math.pi - Conversione dell'angolo (radianti, gradi):
math.degrees(),math.radians() - Seno, seno inverso:
math.sin(),math.asin() - coseno, coseno inverso:
math.cos(),math.acos() - Tangente, tangente inversa:
math.tan(),math.atan(),math.atan2() - Differenze sotto:
math.atan(),math.atan2()
- Pi greco (3,1415926..): math.pi
- Conversione dell'angolo (radianti, gradi): math.degrees(), math.radians()
- Seno, seno inverso: math.sin(), math.asin()
- coseno, coseno inverso: math.cos(), math.acos()
- Tangente, tangente inversa: math.tan(), math.atan(), math.atan2()
- Differenza tra math.atan() e math.atan2()
Pi greco (3,1415926..): math.pi
Pi greco è fornito come costante nel modulo di matematica. È espresso come segue.math.pi
import math
print(math.pi)
# 3.141592653589793
Conversione dell'angolo (radianti, gradi): math.degrees(), math.radians()
Le funzioni trigonometriche e trigonometriche inverse nel modulo di matematica usano il radiante come unità di misura dell'angolo.
Usa math.degrees() e math.radians() per convertire tra radianti (metodo dei gradi d'arco) e gradi (metodo dei gradi).
Math.degrees() converte da radianti a gradi, e math.radians() converte da gradi a radianti.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Seno, seno inverso: math.sin(), math.asin()
La funzione per trovare il seno (sin) è math.sin() e la funzione per trovare il seno inverso (arcsin) è math.asin().
Ecco un esempio di come trovare il seno di 30 gradi, usando math.radians() per convertire i gradi in radianti.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
Il seno di 30 gradi è 0,5, ma c'è un errore perché pi greco, un numero irrazionale, non può essere calcolato con precisione.
Se volete arrotondare al numero appropriato di cifre, usate la funzione round() o il metodo format() o la funzione format().
Notate che il valore di ritorno di round() è un numero (int o float), ma il valore di ritorno di format() è una stringa. Se volete usarlo per i calcoli successivi, usate round().
print(round(sin30, 3))
print(type(round(sin30, 3)))
# 0.5
# <class 'float'>
print('{:.3}'.format(sin30))
print(type('{:.3}'.format(sin30)))
# 0.5
# <class 'str'>
print(format(sin30, '.3'))
print(type(format(sin30, '.3')))
# 0.5
# <class 'str'>
La funzione round() specifica il numero di cifre decimali come secondo argomento. Notate che questo non è strettamente un arrotondamento. Vedere il seguente articolo per i dettagli.
Il metodo format() e la funzione format() specificano il numero di posizioni decimali nella stringa di specificazione della formattazione. Vedere il seguente articolo per i dettagli.
- COLLEGATO:Conversione di formato in Python, formato (riempimento 0, notazione esponenziale, esadecimale, ecc.)
Se volete confrontare, potete anche usare math.isclose().
print(math.isclose(sin30, 0.5))
# True
Allo stesso modo, ecco un esempio per trovare il seno inverso di 0,5. math.asin() restituisce radianti, che vengono convertiti in gradi con math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
coseno, coseno inverso: math.cos(), math.acos()
La funzione per trovare il coseno (cos) è math.cos(), e la funzione per trovare il coseno inverso (arco coseno, arccos) è math.acos().
Ecco un esempio per trovare il coseno di 60 gradi e il coseno inverso di 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Se volete arrotondare alla cifra appropriata, potete usare round() o format() come per il seno.
Tangente, tangente inversa: math.tan(), math.atan(), math.atan2()
La funzione per trovare la tangente (tan) è math.tan(), e la funzione per trovare la tangente inversa (arctan) è math.atan() o math.atan2().
Math.atan2() è descritto più avanti.
Un esempio di trovare la tangente di 45 gradi e la tangente inversa di 1 grado è mostrato qui sotto.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Differenza tra math.atan() e math.atan2()
Sia math.atan() che math.atan2() sono funzioni che restituiscono la tangente inversa, ma differiscono nel numero di argomenti e nella gamma di valori di ritorno.
math.atan(x) ha un argomento e restituisce arctan(x) in radianti. Il valore restituito sarà compreso tra -pi \ 2 e pi \ 2 (da -90 a 90 gradi).
print(math.degrees(math.atan(0)))
# 0.0
print(math.degrees(math.atan(1)))
# 45.0
print(math.degrees(math.atan(-1)))
# -45.0
print(math.degrees(math.atan(math.inf)))
# 90.0
print(math.degrees(math.atan(-math.inf)))
# -90.0
Nell'esempio precedente, math.inf rappresenta l'infinito.
math.atan2(y, x) ha due argomenti e restituisce arctan(y \x) in radianti. Questo angolo è l'angolo (declinazione) che il vettore dall'origine alle coordinate (x, y) fa con la direzione positiva dell'asse x nel piano delle coordinate polari, e il valore restituito è compreso tra -pi e pi (da -180 a 180 gradi).
Poiché anche gli angoli nel secondo e terzo quadrante possono essere ottenuti correttamente, math.atan2() è più appropriato di math.atan() quando si considera il piano delle coordinate polari.
Si noti che l'ordine degli argomenti è y, x, non x, y.
print(math.degrees(math.atan2(0, 1)))
# 0.0
print(math.degrees(math.atan2(1, 1)))
# 45.0
print(math.degrees(math.atan2(1, 0)))
# 90.0
print(math.degrees(math.atan2(1, -1)))
# 135.0
print(math.degrees(math.atan2(0, -1)))
# 180.0
print(math.degrees(math.atan2(-1, -1)))
# -135.0
print(math.degrees(math.atan2(-1, 0)))
# -90.0
print(math.degrees(math.atan2(-1, 1)))
# -45.0
Come nell'esempio precedente, la direzione negativa dell'asse x (y è zero e x è negativo) è pi (180 gradi), ma quando y è zero negativo, è -pi (-180 gradi). Fate attenzione se volete gestire il segno in modo rigoroso.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Gli zeri negativi sono il risultato delle seguenti operazioni
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Gli interi non sono trattati come zeri negativi.
print(-0.0)
# -0.0
print(-0)
# 0
Anche quando sia x che y sono zero, il risultato dipende dal segno.
print(math.degrees(math.atan2(0.0, 0.0)))
# 0.0
print(math.degrees(math.atan2(-0.0, 0.0)))
# -0.0
print(math.degrees(math.atan2(-0.0, -0.0)))
# -180.0
print(math.degrees(math.atan2(0.0, -0.0)))
# 180.0
Ci sono altri esempi in cui il segno del risultato cambia a seconda degli zeri negativi, come math.atan2() così come math.sin(), math.asin(), math.tan() e math.atan().
print(math.sin(0.0))
# 0.0
print(math.sin(-0.0))
# -0.0
print(math.asin(0.0))
# 0.0
print(math.asin(-0.0))
# -0.0
print(math.tan(0.0))
# 0.0
print(math.tan(-0.0))
# -0.0
print(math.atan(0.0))
# 0.0
print(math.atan(-0.0))
# -0.0
print(math.atan2(0.0, 1.0))
# 0.0
print(math.atan2(-0.0, 1.0))
# -0.0
Notate che gli esempi finora sono i risultati dell'esecuzione del programma in CPython. Notate che altre implementazioni o ambienti possono gestire gli zeri negativi in modo diverso.
