Med hjälp av math, Pythons standardmodul för matematiska funktioner, kan du beräkna trigonometriska funktioner (sin, cos, tan) och omvända trigonometriska funktioner (arcsin, arccos, arctan).
Följande innehåll förklaras här med exempelkoder.
- Pi (3.1415926..):
math.pi - Vinkelomvandling (radianer, grader):
math.degrees(),math.radians() - Sinus, omvänd sinus:
math.sin(),math.asin() - cosinus, omvänd cosinus:
math.cos(),math.acos() - Tangent, omvänd tangent:
math.tan(),math.atan(),math.atan2() - Skillnader nedan:
math.atan(),math.atan2()
Pi (3.1415926..): math.pi
Pi finns som en konstant i matematikmodulen. Den uttrycks på följande sätt.math.pi
import math
print(math.pi)
# 3.141592653589793
Vinkelomvandling (radianer, grader): math.degrees(), math.radians()
Trigonometriska och omvända trigonometriska funktioner i matematikmodulen använder radian som enhet för vinkeln.
Använd math.degrees() och math.radians() för att konvertera mellan radianer (båggradersmetoden) och grader (gradersmetoden).
Math.degrees() konverterar från radianer till grader och math.radians() konverterar från grader till radianer.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, omvänd sinus: math.sin(), math.asin()
Funktionen för att hitta sinus (sin) är math.sin() och funktionen för att hitta den omvända sinus (arcsin) är math.asin().
Här är ett exempel på att hitta sinus av 30 grader med hjälp av math.radians() för att konvertera grader till radianer.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
Sinus av 30 grader är 0,5, men det finns ett fel eftersom pi, ett irrationellt tal, inte kan beräknas exakt.
Om du vill avrunda till lämpligt antal siffror använder du funktionen round() eller metoden format() eller funktionen format().
Observera att returvärdet av round() är ett tal (int eller float), men att returvärdet av format() är en sträng. Om du vill använda det för efterföljande beräkningar använder du 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'>
Funktionen round() anger antalet decimaler som sitt andra argument. Observera att detta inte är en ren avrundning. Se följande artikel för mer information.
Metoden format() och funktionen format() anger antalet decimaler i strängen för formateringsspecifikationen. Se följande artikel för mer information.
- RELATERAT:Formatkonvertering i Python, format (0-fyllning, exponentiell notation, hexadecimal, etc.)
Om du vill jämföra kan du också använda math.isclose().
print(math.isclose(sin30, 0.5))
# True
Här är ett exempel på att hitta den omvända sinus av 0,5. math.asin() returnerar radianer, som omvandlas till grader med math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosinus, omvänd cosinus: math.cos(), math.acos()
Funktionen för att hitta cosinus (cos) är math.cos(), och funktionen för att hitta den omvända cosinus (arc cosinus, arccos) är math.acos().
Här är ett exempel på hur man hittar cosinus till 60 grader och den omvända cosinus till 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Om du vill avrunda till lämplig siffra kan du använda round() eller format() som för sinus.
Tangent, omvänd tangent: math.tan(), math.atan(), math.atan2()
Funktionen för att hitta tangenten (tan) är math.tan(), och funktionen för att hitta den omvända tangenten (arctan) är math.atan() eller math.atan2().
Math.atan2() beskrivs senare.
Nedan visas ett exempel på hur man hittar tangenten till 45 grader och den omvända tangenten till 1 grad.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Skillnaden mellan math.atan() och math.atan2()
Både math.atan() och math.atan2() är funktioner som returnerar den inversa tangenten, men de skiljer sig åt i antalet argument och intervallet av returnerade värden.
math.atan(x) har ett argument och returnerar arctan(x) i radianer. Returvärdet kommer att ligga mellan -pi \ 2 och pi \ 2 (-90 till 90 grader).
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
I exemplet ovan representerar math.inf oändligheten.
math.atan2(y, x) har två argument och returnerar arctan(y \ x) i radianer. Denna vinkel är den vinkel (deklination) som vektorn från ursprunget till koordinaterna (x, y) bildar med x-axelns positiva riktning i det polära koordinatplanet, och det returnerade värdet ligger mellan -pi och pi (-180 till 180 grader).
Eftersom vinklar i den andra och tredje kvadranten också kan erhållas korrekt är math.atan2() lämpligare än math.atan() när man betraktar det polära koordinatplanet.
Observera att argumentens ordning är y, x, inte 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
Precis som i exemplet ovan är x-axelns negativa riktning (y är noll och x är negativt) pi (180 grader), men när y är negativt noll är det -pi (-180 grader). Var försiktig om du vill hantera tecknet strikt.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Negativa nollor är resultatet av följande operationer
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Heltal behandlas inte som negativa nollor.
print(-0.0)
# -0.0
print(-0)
# 0
Även när både x och y är noll beror resultatet på tecknet.
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
Det finns andra exempel där resultatet ändrar tecken beroende på negativa nollor, t.ex. math.atan2() samt math.sin(), math.asin(), math.tan() och 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
Observera att exemplen hittills är resultatet av att köra programmet i CPython. Observera att andra implementationer eller miljöer kan hantera negativa nollor på olika sätt.