Usando matemática, o módulo padrão de Python para funções matemáticas, pode calcular funções trigonométricas (sin, cos, tan) e funções trigonométricas inversas (arcsin, arccos, arctan).
O conteúdo seguinte é explicado aqui com os códigos das amostras.
- Pi (3.1415926…):
math.pi - Conversão angular (radianos, graus):
math.degrees(),math.radians() - Seno, Seno Inverso:
math.sin(),math.asin() - cosseno, cosseno inverso:
math.cos(),math.acos() - Tangente, Tangente Inversa:
math.tan(),math.atan(),math.atan2() - Diferenças abaixo:
math.atan(),math.atan2()
Pi (3.1415926…): math.pi
Pi é fornecido como uma constante no módulo de matemática. É expresso da seguinte forma.math.pi
import math
print(math.pi)
# 3.141592653589793
Conversão angular (radianos, graus): math.degrees(), math.radians()
As funções trigonométricas e trigonométricas inversas no módulo de matemática utilizam o radiano como unidade de ângulo.
Utilizar o método matemático() e matemático.radians() para converter entre radians (método de graus de arco) e graus (método de graus).
Math.degrees() converte de radianos para graus, e math.radians() converte de graus para radianos.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Seno, Seno Inverso: math.sin(), math.asin()
A função para encontrar o seno (pecado) é math.sin() e a função para encontrar o seno inverso (arcsina) é math.asin().
Aqui está um exemplo de encontrar o seno de 30 graus, usando matemática.radians() para converter graus em radians.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
O seno de 30 graus é 0,5, mas há um erro porque pi, um número irracional, não pode ser calculado com precisão.
Se desejar arredondar para o número apropriado de dígitos, utilize a função round() ou o método format() ou a função format().
Note-se que o valor de retorno de round() é um número (int ou float), mas o valor de retorno de format() é uma string. Se quiser utilizá-lo para cálculos subsequentes, utilize 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'>
A função round() especifica o número de casas decimais como o seu segundo argumento. Note-se que isto não é estritamente um arredondamento. Ver o artigo seguinte para detalhes.
A função format() e format() especifica o número de casas decimais na cadeia de especificações de formatação. Ver o artigo seguinte para detalhes.
- RELACIONADO:Conversão de formato em Python, formato (preenchimento 0, notação exponencial, hexadecimal, etc.)
Se quiser comparar, também pode utilizar o ficheiro matemático().
print(math.isclose(sin30, 0.5))
# True
Do mesmo modo, aqui está um exemplo de encontrar o seno inverso de 0,5. math.asin() devolve os radianos, que são convertidos em graus com math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosseno, cosseno inverso: math.cos(), math.acos()
A função para encontrar o cosseno (cos) é math.cos(), e a função para encontrar o cosseno inverso (arco cosseno, arccos) é math.acos().
Aqui está um exemplo de encontrar o cosseno de 60 graus e o cosseno inverso de 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Se desejar arredondar para o dígito apropriado, pode usar round() ou format() como no seno.
Tangente, Tangente Inversa: math.tan(), math.atan(), math.atan2()
A função de encontrar a tangente (tan) é math.tan(), e a função de encontrar a tangente inversa (arctan) é math.atan() ou math.atan2().
Math.atan2() é descrito mais tarde.
Um exemplo de encontrar a tangente de 45 graus e a tangente inversa de 1 grau é mostrado abaixo.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Diferença entre math.atan() e math.atan2()
Tanto o math.atan() como o math.atan2() são funções que devolvem a tangente inversa, mas diferem no número de argumentos e na gama de valores de retorno.
math.atan(x) tem um argumento e retorna arctan(x) em radianos. O valor de retorno será entre -pi 2 e 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
No exemplo acima, a matemática.inf representa o infinito.
math.atan2(y, x) tem dois argumentos e retorna arctan(y x) em radianos. Este ângulo é o ângulo (declinação) que o vector da origem para as coordenadas (x, y) faz com a direcção positiva do eixo x no plano de coordenadas polares, e o valor retornado está entre -pi e pi (-180 a 180 graus).
Dado que os ângulos no segundo e terceiro quadrantes também podem ser obtidos correctamente, math.atan2() é mais apropriado do que math.atan() quando se considera o plano de coordenadas polares.
Note-se que a ordem dos argumentos é y, x, e não 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
Como no exemplo acima, a direcção negativa do eixo x (y é zero e x é negativo) é pi (180 graus), mas quando y é zero negativo, é -pi (-180 graus). Tenha cuidado se quiser manusear o sinal estritamente.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Os zeros negativos são o resultado das seguintes operações
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Os inteiros não são tratados como zeros negativos.
print(-0.0)
# -0.0
print(-0)
# 0
Mesmo quando ambos x e y são zero, o resultado depende do sinal.
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
Há outros exemplos em que o sinal do resultado muda dependendo de zeros negativos, tais como math.atan2() bem como 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
Note-se que os exemplos até agora são os resultados da execução do programa em CPython. Note-se que outras implementações ou ambientes podem lidar com zeros negativos de forma diferente.
