Amb math, el mòdul estàndard de Python per a funcions matemàtiques, podeu calcular funcions trigonomètriques (sin, cos, tan) i funcions trigonomètriques inverses (arcsin, arccos, arctan).
Els continguts següents s’expliquen aquí amb codis d’exemple.
- Pi (3.1415926..):
math.pi - Conversió d’angles (radians, graus):
math.degrees(),math.radians() - Sinus, sinus invers:
math.sin(),math.asin() - cosinus, cosinus invers:
math.cos(),math.acos() - Tangent, tangent inversa:
math.tan(),math.atan(),math.atan2() - Diferències a continuació:
math.atan(),math.atan2()
Pi (3.1415926..):math.pi
Pi es proporciona com a constant al mòdul de matemàtiques. S’expressa de la següent manera.math.pi
import math
print(math.pi)
# 3.141592653589793
Conversió d’angles (radians, graus):math.degrees(),math.radians()
Les funcions trigonomètriques i trigonomètriques inverses del mòdul de matemàtiques utilitzen el radian com a unitat d’angle.
Utilitzeu math.degrees() i math.radians() per convertir entre radians (mètode de graus d’arc) i graus (mètode de graus).
Math.degrees() converteix de radians a graus, i math.radians() converteix de graus a radians.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, sinus invers:math.sin(),math.asin()
La funció per trobar el sinus (sin) és math.sin() i la funció per trobar el sinus invers (arcsin) és math.asin().
Aquí teniu un exemple de trobar el sinus de 30 graus, utilitzant math.radians() per convertir graus en radians.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
El sinus de 30 graus és 0,5, però hi ha un error perquè pi, un nombre irracional, no es pot calcular amb precisió.
Si voleu arrodonir al nombre adequat de dígits, utilitzeu la funció round() o el mètode format() o la funció format().
Tingueu en compte que el valor de retorn de round() és un nombre (int o float), però el valor de retorn de format() és una cadena. Si el voleu utilitzar per a càlculs posteriors, feu servir 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 funció round() especifica el nombre de decimals com a segon argument. Tingueu en compte que això no és estrictament arrodonit. Consulteu l’article següent per obtenir més informació.
El mètode format() i la funció format() especifiquen el nombre de decimals a la cadena d’especificació de format. Consulteu l’article següent per obtenir més informació.
- RELACIONATS:Conversió de format en Python, format (emplenament 0, notació exponencial, hexadecimal, etc.)
Si voleu comparar, també podeu utilitzar math.isclose().
print(math.isclose(sin30, 0.5))
# True
De la mateixa manera, aquí teniu un exemple de trobar el sinus invers de 0,5. math.asin() retorna radians, que es converteixen en graus amb math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosinus, cosinus invers:math.cos(),math.acos()
La funció per trobar el cosinus (cos) és math.cos(), i la funció per trobar el cosinus invers (arc cosinus, arccos) és math.acos().
Aquí teniu un exemple de trobar el cosinus de 60 graus i el cosinus invers de 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Si voleu arrodonir al dígit adequat, podeu utilitzar round() o format() com amb sinus.
Tangent, tangent inversa:math.tan(),math.atan(),math.atan2()
La funció per trobar la tangent (tan) és math.tan(), i la funció per trobar la tangent inversa (arctan) és math.atan() o math.atan2().
Math.atan2() es descriu més endavant.
A continuació es mostra un exemple de trobar la tangent de 45 graus i la tangent inversa d’1 grau.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Diferència entre math.atan() i math.atan2()
Tant math.atan() com math.atan2() són funcions que retornen la tangent inversa, però es diferencien pel nombre d’arguments i l’interval de valors de retorn.
math.atan(x) té un argument i retorna arctan(x) en radians. El valor de retorn estarà entre -pi \ 2 i pi \ 2 (-90 a 90 graus).
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
A l’exemple anterior, math.inf representa infinit.
math.atan2(y, x) té dos arguments i retorna arctan(y \ x) en radians. Aquest angle és l’angle (declinació) que forma el vector des de l’origen fins a les coordenades (x, y) amb la direcció positiva de l’eix x en el pla de coordenades polars, i el valor retornat està entre -pi i pi (-180). fins a 180 graus).
Com que els angles del segon i tercer quadrants també es poden obtenir correctament, math.atan2() és més apropiat que math.atan() quan es considera el pla de coordenades polars.
Tingueu en compte que l’ordre dels arguments és y, x, no 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
Com a l’exemple anterior, la direcció negativa de l’eix x (y és zero i x és negativa) és pi (180 graus), però quan y és zero negatiu, és -pi (-180 graus). Aneu amb compte si voleu manipular el senyal de manera estricta.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Els zeros negatius són el resultat de les operacions següents
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Els nombres enters no es tracten com a zeros negatius.
print(-0.0)
# -0.0
print(-0)
# 0
Fins i tot quan tant x com y són zero, el resultat depèn del 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
Hi ha altres exemples on el signe del resultat canvia en funció dels zeros negatius, com ara math.atan2() així com math.sin(), math.asin(), math.tan() i 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
Tingueu en compte que els exemples fins ara són els resultats de l’execució del programa en CPython. Tingueu en compte que altres implementacions o entorns poden gestionar zeros negatius de manera diferent.