Calcolare funzioni trigonometriche in Python (sin, cos, tan, arcsin, arccos, arctan)

Attività commerciale

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

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.

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.