Obliczanie funkcji trygonometrycznych w Pythonie (sin, cos, tan, arcsin, arccos, arctan)

Biznes

Korzystając z math, standardowego modułu funkcji matematycznych Pythona, można obliczać funkcje trygonometryczne (sin, cos, tan) oraz odwrotne funkcje trygonometryczne (arcsin, arccos, arctan).

Poniższe treści zostały tu wyjaśnione wraz z przykładowymi kodami.

  • Pi (3,1415926…):math.pi
  • Konwersja kątów (radiany, stopnie):math.degrees(),math.radians()
  • Sinus, odwrotność sinusa:math.sin(),math.asin()
  • cosinus, odwrotność cosinusa:math.cos(),math.acos()
  • Tangens, Tangens odwrotny:math.tan(),math.atan(),math.atan2()
  • Różnice poniżej:math.atan(),math.atan2()

Pi (3,1415926…): math.pi

Liczba Pi jest podawana jako stała w module matematycznym. Wyraża się ją w następujący sposób.
math.pi

import math

print(math.pi)
# 3.141592653589793

Konwersja kątów (radiany, stopnie): math.degrees(), math.radians()

Funkcje trygonometryczne i odwrotne funkcje trygonometryczne w module matematycznym wykorzystują radian jako jednostkę kąta.

Użyj funkcji math.degrees() i math.radians() do konwersji między radianami (metoda stopni łuku) a stopniami (metoda stopni).

Math.degrees() konwertuje z radianów na stopnie, a math.radians() konwertuje ze stopni na radiany.

print(math.degrees(math.pi))
# 180.0

print(math.radians(180))
# 3.141592653589793

Sinus, odwrotność sinusa: math.sin(), math.asin()

Funkcją pozwalającą znaleźć sinus (sin) jest math.sin(), a funkcją pozwalającą znaleźć odwrotność sinusa (arcsin) jest math.asin().

Oto przykład znalezienia sinusa kąta 30 stopni przy użyciu funkcji math.radians() do zamiany stopni na radiany.

sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994

Sinus 30 stopni wynosi 0,5, ale wystąpił błąd, ponieważ nie można dokładnie obliczyć liczby irracjonalnej pi.

Jeśli chcesz zaokrąglić liczbę cyfr do odpowiedniej liczby, użyj funkcji round() lub metody format() albo funkcji format().

Zauważ, że wartością zwracaną przez round() jest liczba (int lub float), natomiast wartością zwracaną przez format() jest łańcuch znaków. Jeśli chcesz go użyć do kolejnych obliczeń, użyj funkcji 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'>

Funkcja round() jako drugi argument podaje liczbę miejsc po przecinku. Należy pamiętać, że nie jest to dokładne zaokrąglanie. Szczegółowe informacje na ten temat można znaleźć w poniższym artykule.

Metoda format() i funkcja format() określają liczbę miejsc po przecinku w łańcuchu specyfikacji formatowania. Szczegółowe informacje na ten temat można znaleźć w poniższym artykule.

Jeśli chcesz porównać, możesz także użyć funkcji math.isclose().

print(math.isclose(sin30, 0.5))
# True

Podobnie, oto przykład znalezienia odwrotności sinusa 0,5. Funkcja math.asin() zwraca radiany, które są zamieniane na stopnie za pomocą funkcji math.degrees().

asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996

print(round(asin05, 3))
# 30.0

cosinus, odwrotność cosinusa: math.cos(), math.acos()

Funkcją pozwalającą znaleźć cosinus (cos) jest math.cos(), a funkcją pozwalającą znaleźć odwrotność cosinusa (arc cosinus, arccos) jest math.acos().

Oto przykład wyznaczania cosinusa kąta 60 stopni i odwrotności cosinusa 0,5.

print(math.cos(math.radians(60)))
# 0.5000000000000001

print(math.degrees(math.acos(0.5)))
# 59.99999999999999

Jeśli chcesz zaokrąglić wynik do odpowiedniej cyfry, możesz użyć funkcji round() lub format(), tak jak w przypadku sinusa.

Tangens, Tangens odwrotny: math.tan(), math.atan(), math.atan2()

Funkcją pozwalającą znaleźć tangens (tan) jest math.tan(), a funkcją pozwalającą znaleźć odwrotność tangensa (arctan) jest math.atan() lub math.atan2().
Funkcja Math.atan2() jest opisana w dalszej części instrukcji.

Poniżej przedstawiono przykład wyznaczania tangensa kąta 45 stopni i odwrotności tangensa kąta 1 stopnia.

print(math.tan(math.radians(45)))
# 0.9999999999999999

print(math.degrees(math.atan(1)))
# 45.0

Różnica między funkcjami math.atan() i math.atan2()

Zarówno math.atan(), jak i math.atan2() są funkcjami zwracającymi odwrotność tangensa, ale różnią się liczbą argumentów i zakresem zwracanych wartości.

Funkcja math.atan(x) ma jeden argument i zwraca arctan(x) w radianach. Zwracana wartość będzie zawierać się w przedziale od -pi ≥ 2 do pi ≥ 2 (od -90 do 90 stopni).

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

W powyższym przykładzie plik math.inf reprezentuje nieskończoność.

Funkcja math.atan2(y, x) ma dwa argumenty i zwraca wartość arctan(y x) w radianach. Kąt ten to kąt (deklinacja), jaki wektor od początku do współrzędnych (x, y) tworzy z dodatnim kierunkiem osi x na biegunowej płaszczyźnie współrzędnych, a zwracana wartość zawiera się w przedziale od -pi do pi (od -180 do 180 stopni).

Ponieważ kąty w drugim i trzecim kwadrancie również można uzyskać poprawnie, funkcja math.atan2() jest bardziej odpowiednia niż math.atan(), gdy rozważamy biegunową płaszczyznę współrzędnych.

Zwróć uwagę, że kolejność argumentów to y, x, a nie 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

Tak jak w powyższym przykładzie, kierunek ujemny osi x (y jest równe zero, a x jest ujemne) to pi (180 stopni), ale gdy y jest ujemne zero, to jest to -pi (-180 stopni). Należy zachować ostrożność, jeśli chcemy ściśle przestrzegać znaku.

print(math.degrees(math.atan2(-0.0, -1)))
# -180.0

Ujemne zera są wynikiem następujących operacji

print(-1 / math.inf)
# -0.0

print(-1.0 * 0.0)
# -0.0

Liczby całkowite nie są traktowane jako zera ujemne.

print(-0.0)
# -0.0

print(-0)
# 0

Nawet jeśli zarówno x, jak i y są równe zero, wynik zależy od znaku.

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

Istnieją inne przykłady, w których znak wyniku zmienia się w zależności od ujemnych zer, takie jak math.atan2(), a także 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

Zwróć uwagę, że dotychczasowe przykłady są rezultatem uruchomienia programu w CPythonie. Należy pamiętać, że inne implementacje lub środowiska mogą inaczej obsługiwać ujemne zera.

Copied title and URL