Trigonometrikus függvények számítása Pythonban (sin, cos, tan, arcsin, arccos, arctan)

Üzleti

A matematika, a Python matematikai függvények szabványos modulja segítségével trigonometrikus függvényeket (sin, cos, tan) és inverz trigonometrikus függvényeket (arcsin, arccos, arctan) számolhat.

A következő tartalmakat itt példakódokkal magyarázzuk el.

  • Pi (3.1415926..):math.pi
  • Szögátalakítás (radián, fok):math.degrees(),math.radians()
  • Szinusz, inverz szinusz:math.sin(),math.asin()
  • koszinusz, inverz koszinusz:math.cos(),math.acos()
  • Tangens, inverz érintő:math.tan(),math.atan(),math.atan2()
  • Az alábbi különbségek:math.atan(),math.atan2()

Pi (3.1415926..): math.pi

A matematikai modulban a pí konstansként van megadva. A következőképpen fejezhető ki.
math.pi

import math

print(math.pi)
# 3.141592653589793

Szögátalakítás (radián, fok): math.degrees(), math.radians()

A matematikai modul trigonometrikus és inverz trigonometrikus függvényei a radiánt használják a szög mértékegységeként.

A math.degrees() és a math.radians() segítségével a radiánok (ívfok módszer) és a fokok (fok módszer) közötti átváltáshoz.

A Math.degrees() a radiánokról fokokra, a math.radians() pedig fokokról radiánokra konvertál.

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

print(math.radians(180))
# 3.141592653589793

Szinusz, inverz szinusz: math.sin(), math.asin()

A szinusz (sin) kiszámítására szolgáló függvény a math.sin(), az inverz szinusz (arcsin) kiszámítására szolgáló függvény pedig a math.asin().

Íme egy példa 30 fok szinuszának meghatározására, a math.radians() segítségével a fokok radiánokká alakítására.

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

A 30 fok szinusza 0,5, de van egy hiba, mert a pi, egy irracionális szám, nem számítható ki pontosan.

Ha a megfelelő számjegyszámra szeretne kerekíteni, használja a round() függvényt vagy a format() módszert vagy a format() függvényt.

Vegyük észre, hogy a round() visszatérési értéke egy szám (int vagy float), de a format() visszatérési értéke egy karakterlánc. Ha ezt későbbi számításokhoz szeretné használni, használja a round()-t.

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 round() függvény második argumentumaként a tizedesjegyek számát adja meg. Vegyük észre, hogy ez nem szigorúan kerekítés. A részleteket lásd a következő cikkben.

A format() módszer és a format() függvény meghatározza a tizedesjegyek számát a formázási specifikációs karakterláncban. A részleteket lásd a következő cikkben.

Ha össze akarod hasonlítani, használhatod a math.isclose() függvényt is.

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

Hasonlóképpen, itt van egy példa a 0,5 inverz szinuszának megtalálására. A math.asin() radiánokat ad vissza, amelyeket a math.degrees() segítségével alakítunk át fokokká.

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

print(round(asin05, 3))
# 30.0

koszinusz, inverz koszinusz: math.cos(), math.acos()

A koszinusz (cos) kiszámítására szolgáló függvény a math.cos(), a fordított koszinusz (arc cosinus, arccos) kiszámítására szolgáló függvény pedig a math.acos().

Íme egy példa a 60 fok koszinuszának és a 0,5 fordított koszinuszának meghatározására.

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

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

Ha a megfelelő számjegyre szeretnénk kerekíteni, használhatjuk a round() vagy a format() funkciót, mint a szinusz esetében.

Tangens, inverz érintő: math.tan(), math.atan(), math.atan2()

Az érintő (tan) kiszámítására szolgáló függvény a math.tan(), a fordított érintő (arctan) kiszámítására szolgáló függvény pedig a math.atan() vagy a math.atan2().
A Math.atan2() funkciót később ismertetjük.

Az alábbiakban egy példa látható a 45 fok érintőjének és az 1 fok fordított érintőjének meghatározására.

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

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

A math.atan() és a math.atan2() közötti különbség

Mind a math.atan(), mind a math.atan2() olyan függvény, amely az inverz érintőjét adja vissza, de az argumentumok számában és a visszatérési értékek tartományában különböznek.

A math.atan(x) egy argumentummal rendelkezik, és arctan(x) értéket ad vissza radiánban. A visszatérési érték -pi \ 2 és pi \ 2 között lesz (-90 és 90 fok között).

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 fenti példában a math.inf a végtelent jelöli.

A math.atan2(y, x) két argumentummal rendelkezik, és arctan(y \ x) értéket ad vissza radiánban. Ez a szög az a szög (deklináció), amelyet az origótól az (x, y) koordinátákhoz tartozó vektor az x tengely pozitív irányával bezár a polárkoordináta-síkban, és a visszaadott érték -pi és pi között van (-180 és 180 fok között).

Mivel a második és harmadik kvadránsban lévő szögek is helyesen kaphatók, a math.atan2() megfelelőbb, mint a math.atan(), ha a poláris koordinátasíkot vesszük figyelembe.

Vegyük észre, hogy az argumentumok sorrendje y, x, nem pedig 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

A fenti példához hasonlóan az x-tengely negatív iránya (y nulla és x negatív) pi (180 fok), de ha y negatív nulla, akkor -pi (-180 fok). Legyen óvatos, ha szigorúan akarja kezelni az előjelet.

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

A negatív nullák a következő műveletek eredményei

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

print(-1.0 * 0.0)
# -0.0

Az egész számokat nem kezelik negatív nullaként.

print(-0.0)
# -0.0

print(-0)
# 0

Még akkor is, ha mind x, mind y nulla, az eredmény az előjeltől függ.

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

Vannak más példák is, ahol az eredmény előjele a negatív nullák függvényében változik, például a math.atan2(), valamint a math.sin(), math.asin(), math.tan() és 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

Vegye figyelembe, hogy az eddigi példák a program CPythonban történő futtatásának eredményei. Vegye figyelembe, hogy más implementációk vagy környezetek másképp kezelhetik a negatív nullákat.