Folosind math, modulul standard Python pentru funcții matematice, puteți calcula funcții trigonometrice (sin, cos, tan) și funcții trigonometrice inverse (arcsin, arccos, arctan).
Următoarele conținuturi sunt explicate aici cu exemple de coduri.
- Pi (3.1415926..):
math.pi - Conversia unghiurilor (radiani, grade):
math.degrees(),math.radians() - Sinus, Sinus invers:
math.sin(),math.asin() - cosinus, cosinus invers:
math.cos(),math.acos() - Tangentă, tangentă inversă:
math.tan(),math.atan(),math.atan2() - Diferențele de mai jos:
math.atan(),math.atan2()
Pi (3.1415926..): math.pi
Pi este furnizat ca o constantă în modulul de matematică. Ea se exprimă după cum urmează.math.pi
import math
print(math.pi)
# 3.141592653589793
Conversia unghiurilor (radiani, grade): math.degrees(), math.radians()
Funcțiile trigonometrice și trigonometrice inverse din modulul de matematică utilizează radianul ca unitate de măsură a unghiului.
Utilizați math.degrees() și math.radians() pentru a converti între radiani (metoda gradelor de arc) și grade (metoda gradelor).
Math.degrees() convertește din radiani în grade, iar math.radians() convertește din grade în radiani.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, Sinus invers: math.sin(), math.asin()
Funcția pentru a găsi sinusul (sin) este math.sin(), iar funcția pentru a găsi sinusul invers (arcsin) este math.asin().
Iată un exemplu de găsire a sinusului a 30 de grade, folosind math.radians() pentru a converti gradele în radiani.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
Sinusul a 30 de grade este 0,5, dar există o eroare deoarece pi, un număr irațional, nu poate fi calculat cu exactitate.
Dacă doriți să rotunjiți la numărul corespunzător de cifre, utilizați funcția round() sau metoda format() sau funcția format().
Rețineți că valoarea de retur a funcției round() este un număr (int sau float), dar valoarea de retur a funcției format() este un șir de caractere. Dacă doriți să o utilizați pentru calcule ulterioare, utilizați 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'>
Funcția round() specifică numărul de zecimale ca al doilea argument. Rețineți că nu este vorba strict de o rotunjire. Pentru detalii, consultați următorul articol.
Metoda format() și funcția format() specifică numărul de zecimale din șirul de specificații de formatare. Pentru detalii, consultați următorul articol.
- RELAȚIE:Conversia formatului în Python, format (umplere cu 0, notație exponențială, hexazecimal, etc.)
Dacă doriți să comparați, puteți utiliza și math.isclose().
print(math.isclose(sin30, 0.5))
# True
În mod similar, iată un exemplu de găsire a sinusului invers al lui 0,5. math.asin() returnează radiani, care sunt convertiți în grade cu 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()
Funcția pentru a găsi cosinusul (cos) este math.cos(), iar funcția pentru a găsi cosinusul invers (arc cosinus, arccos) este math.acos().
Iată un exemplu de găsire a cosinusului a 60 de grade și a cosinusului invers al lui 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Dacă doriți să rotunjiți la cifra corespunzătoare, puteți utiliza round() sau format(), ca și în cazul sinusului.
Tangentă, tangentă inversă: math.tan(), math.atan(), math.atan2()
Funcția pentru a găsi tangenta (tan) este math.tan(), iar funcția pentru a găsi tangenta inversă (arctan) este math.atan() sau math.atan2().
Math.atan2() este descrisă mai târziu.
Un exemplu de găsire a tangentei la 45 de grade și a tangentei inverse la 1 grad este prezentat mai jos.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Diferența dintre math.atan() și math.atan2()
Atât math.atan(), cât și math.atan2() sunt funcții care returnează tangenta inversă, dar diferă în ceea ce privește numărul de argumente și intervalul de valori de retur.
math.atan(x) are un singur argument și returnează arctan(x) în radiani. Valoarea returnată va fi cuprinsă între -pi \ 2 și pi \ 2 (-90 la 90 de grade).
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
În exemplul de mai sus, math.inf reprezintă infinitul.
math.atan2(y, x) are două argumente și returnează arctan(y \ x) în radiani. Acest unghi este unghiul (declinația) pe care vectorul de la origine la coordonatele (x, y) îl face cu direcția pozitivă a axei x în planul de coordonate polare, iar valoarea returnată este cuprinsă între -pi și pi (-180 și 180 de grade).
Deoarece unghiurile din al doilea și al treilea cadran pot fi, de asemenea, obținute corect, math.atan2() este mai adecvat decât math.atan() atunci când se ia în considerare planul de coordonate polare.
Rețineți că ordinea argumentelor este y, x, nu 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
Ca în exemplul de mai sus, direcția negativă a axei x (y este zero și x este negativ) este pi (180 de grade), dar când y este zero negativ, este -pi (-180 de grade). Fiți atenți dacă doriți să gestionați strict semnul.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Zerourile negative sunt rezultatul următoarelor operații
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Numerele întregi nu sunt tratate ca zerouri negative.
print(-0.0)
# -0.0
print(-0)
# 0
Chiar și atunci când atât x, cât și y sunt zero, rezultatul depinde de semn.
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
Există și alte exemple în care semnul rezultatului se schimbă în funcție de zerourile negative, cum ar fi math.atan2(), precum și 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
Rețineți că exemplele de până acum sunt rezultatele rulării programului în CPython. Rețineți că alte implementări sau medii pot gestiona diferit zerourile negative.
