À l'aide de math, le module standard de Python pour les fonctions mathématiques, vous pouvez calculer les fonctions trigonométriques (sin, cos, tan) et les fonctions trigonométriques inverses (arcsin, arccos, arctan).
Les contenus suivants sont expliqués ici avec des exemples de codes.
- Pi (3.1415926..):
math.pi - Conversion des angles (radians, degrés):
math.degrees(),math.radians() - Sinus, sinus inverse:
math.sin(),math.asin() - cosinus, cosinus inverse:
math.cos(),math.acos() - Tangente, tangente inverse:
math.tan(),math.atan(),math.atan2() - Différences ci-dessous:
math.atan(),math.atan2()
Pi (3.1415926..): math.pi
Pi est fourni comme une constante dans le module mathématique. Il s'exprime comme suit.math.pi
import math
print(math.pi)
# 3.141592653589793
Conversion des angles (radians, degrés): math.degrees(), math.radians()
Les fonctions trigonométriques et trigonométriques inverses du module mathématique utilisent le radian comme unité d'angle.
Utilisez math.degrees() et math.radians() pour convertir les radians (méthode des degrés d'arc) en degrés (méthode des degrés).
Math.degrees() convertit les radians en degrés, et math.radians() convertit les degrés en radians.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, sinus inverse: math.sin(), math.asin()
La fonction permettant de trouver le sinus (sin) est math.sin() et la fonction permettant de trouver le sinus inverse (arcsin) est math.asin().
Voici un exemple pour trouver le sinus de 30 degrés, en utilisant math.radians() pour convertir les degrés en radians.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
Le sinus de 30 degrés est de 0,5, mais il y a une erreur car pi, un nombre irrationnel, ne peut être calculé avec précision.
Si vous souhaitez arrondir au nombre approprié de chiffres, utilisez la fonction round() ou la méthode format() ou la fonction format().
Notez que la valeur de retour de round() est un nombre (int ou float), mais que la valeur de retour de format() est une chaîne de caractères. Si vous souhaitez l'utiliser pour des calculs ultérieurs, utilisez 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 fonction round() spécifie le nombre de décimales comme deuxième argument. Notez qu'il ne s'agit pas strictement d'un arrondi. Voir l'article suivant pour plus de détails.
La méthode format() et la fonction format() spécifient le nombre de décimales dans la chaîne de spécification de formatage. Voir l'article suivant pour plus de détails.
- RELATION :Conversion de format en Python, format (remplissage de 0, notation exponentielle, hexadécimal, etc.)
Si vous voulez comparer, vous pouvez également utiliser math.isclose().
print(math.isclose(sin30, 0.5))
# True
De même, voici un exemple pour trouver le sinus inverse de 0,5. math.asin() renvoie des radians, qui sont convertis en degrés avec math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosinus, cosinus inverse: math.cos(), math.acos()
La fonction permettant de trouver le cosinus (cos) est math.cos(), et la fonction permettant de trouver le cosinus inverse (arc cosinus, arccos) est math.acos().
Voici un exemple pour trouver le cosinus de 60 degrés et l'inverse du cosinus de 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Si vous souhaitez arrondir au chiffre approprié, vous pouvez utiliser round() ou format() comme pour le sinus.
Tangente, tangente inverse: math.tan(), math.atan(), math.atan2()
La fonction permettant de trouver la tangente (tan) est math.tan(), et la fonction permettant de trouver la tangente inverse (arctan) est math.atan() ou math.atan2().
Math.atan2() est décrit plus loin.
Voici un exemple pour trouver la tangente de 45 degrés et la tangente inverse de 1 degré.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Différence entre math.atan() et math.atan2()
math.atan() et math.atan2() sont toutes deux des fonctions qui renvoient la tangente inverse, mais elles diffèrent par le nombre d'arguments et la plage des valeurs de retour.
math.atan(x) a un argument et renvoie arctan(x) en radians. La valeur de retour sera comprise entre -pi \ 2 et pi \ 2 (-90 à 90 degrés).
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
Dans l'exemple ci-dessus, math.inf représente l'infini.
math.atan2(y, x) possède deux arguments et renvoie arctan(y \ x) en radians. Cet angle est l'angle (déclinaison) que fait le vecteur de l'origine aux coordonnées (x, y) avec la direction positive de l'axe des x dans le plan de coordonnées polaires, et la valeur renvoyée est comprise entre -pi et pi (-180 à 180 degrés).
Puisque les angles dans les deuxième et troisième quadrants peuvent également être obtenus correctement, math.atan2() est plus approprié que math.atan() lorsque l'on considère le plan de coordonnées polaires.
Notez que l'ordre des arguments est y, x, et 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
Comme dans l'exemple ci-dessus, la direction négative de l'axe des x (y est zéro et x est négatif) est pi (180 degrés), mais lorsque y est négatif zéro, elle est -pi (-180 degrés). Faites attention si vous voulez manipuler le signe de manière stricte.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Les zéros négatifs sont le résultat des opérations suivantes
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Les nombres entiers ne sont pas traités comme des zéros négatifs.
print(-0.0)
# -0.0
print(-0)
# 0
Même lorsque x et y sont tous deux nuls, le résultat dépend du signe.
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
Il existe d'autres exemples où le signe du résultat change en fonction des zéros négatifs, comme math.atan2() ainsi que math.sin(), math.asin(), math.tan() et 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
Notez que les exemples présentés jusqu'à présent sont les résultats de l'exécution du programme dans CPython. Notez que d'autres implémentations ou environnements peuvent gérer les zéros négatifs différemment.