Ved hjælp af math, Pythons standardmodul for matematiske funktioner, kan du beregne trigonometriske funktioner (sin, cos, tan) og omvendte trigonometriske funktioner (arcsin, arccos, arctan).
Følgende indhold er forklaret her med eksempler på koder.
- Pi (3.1415926..):
math.pi - Vinkelkonvertering (radianer, grader):
math.degrees(),math.radians() - Sinus, invers sinus:
math.sin(),math.asin() - cosinus, omvendt cosinus:
math.cos(),math.acos() - Tangent, invers tangent:
math.tan(),math.atan(),math.atan2() - Forskelle nedenfor:
math.atan(),math.atan2()
Pi (3.1415926..): math.pi
Pi er angivet som en konstant i matematikmodulet. Den udtrykkes på følgende måde.math.pi
import math
print(math.pi)
# 3.141592653589793
Vinkelkonvertering (radianer, grader): math.degrees(), math.radians()
Trigonometriske og omvendt trigonometriske funktioner i matematikmodulet bruger radian som enhed for vinkel.
Brug math.degrees() og math.radians() til at konvertere mellem radianer (arc degree-metoden) og grader (degree-metoden).
Math.degrees() konverterer fra radianer til grader, og math.radians() konverterer fra grader til radianer.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, invers sinus: math.sin(), math.asin()
Funktionen til at finde sinus (sin) er math.sin(), og funktionen til at finde den omvendte sinus (arcsin) er math.asin().
Her er et eksempel på at finde sinus af 30 grader ved hjælp af math.radians() til at konvertere grader til radianer.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
Sinus af 30 grader er 0,5, men der er en fejl, fordi pi, som er et irrationelt tal, ikke kan beregnes nøjagtigt.
Hvis du ønsker at afrunde til det passende antal cifre, skal du bruge funktionen round() eller format()-metoden eller format()-funktionen.
Bemærk, at returværdien af round() er et tal (int eller float), men at returværdien af format() er en streng. Hvis du ønsker at bruge den til efterfølgende beregninger, skal du bruge 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() angiver antallet af decimaler som sit andet argument. Bemærk, at der ikke er tale om afrunding i snæver forstand. Se følgende artikel for nærmere oplysninger.
Format()-metoden og format()-funktionen angiver antallet af decimaler i formateringsspecifikationsstrengen. Se følgende artikel for nærmere oplysninger.
- RELATERET:Formatkonvertering i Python, format (0-fyldning, eksponentiel notation, hexadecimal, osv.)
Hvis du ønsker at sammenligne, kan du også bruge math.isclose().
print(math.isclose(sin30, 0.5))
# True
På samme måde er her et eksempel på at finde den omvendte sinus af 0,5. math.asin() returnerer radianer, som konverteres til grader med math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosinus, omvendt cosinus: math.cos(), math.acos()
Funktionen til at finde cosinus (cos) er math.cos(), og funktionen til at finde den omvendte cosinus (arc cosinus, arccos) er math.acos().
Her er et eksempel på at finde cosinus af 60 grader og den omvendte cosinus af 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Hvis du ønsker at afrunde til det rigtige tal, kan du bruge round() eller format() som med sinus.
Tangent, invers tangent: math.tan(), math.atan(), math.atan2()
Funktionen til at finde tangenten (tan) er math.tan(), og funktionen til at finde den omvendte tangent (arctan) er math.atan() eller math.atan2().
Math.atan2() beskrives senere.
Et eksempel på at finde tangenten til 45 grader og den omvendte tangent til 1 grad er vist nedenfor.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Forskellen mellem math.atan() og math.atan2()
Både math.atan() og math.atan2() er funktioner, der returnerer den omvendte tangent, men de adskiller sig fra hinanden ved antallet af argumenter og rækkevidden af returværdier.
math.atan(x) har ét argument og returnerer arctan(x) i radianer. Den returnerede værdi vil ligge mellem -pi \ 2 og pi \ 2 (-90 til 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 eksemplet ovenfor repræsenterer math.inf uendelighed.
math.atan2(y, x) har to argumenter og returnerer arctan(y \ x) i radianer. Denne vinkel er den vinkel (deklination), som vektoren fra oprindelsen til koordinaterne (x, y) danner med den positive retning af x-aksen i det polære koordinatplan, og den returnerede værdi ligger mellem -pi og pi (-180 til 180 grader).
Da vinkler i anden og tredje kvadrant også kan beregnes korrekt, er math.atan2() mere velegnet end math.atan(), når man betragter det polære koordinatplan.
Bemærk, at rækkefølgen af argumenterne er y, x, og ikke 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
Som i eksemplet ovenfor er den negative retning af x-aksen (y er nul og x er negativ) pi (180 grader), men når y er negativ nul, er den -pi (-180 grader). Vær forsigtig, hvis du ønsker at håndtere fortegnet strengt.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Negative nuller er resultatet af følgende operationer
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Hele tal behandles ikke som negative nuller.
print(-0.0)
# -0.0
print(-0)
# 0
Selv når både x og y er nul, afhænger resultatet af fortegnet.
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
Der er andre eksempler, hvor resultatet ændrer fortegn afhængigt af negative nuller, f.eks. math.atan2() samt math.sin(), math.asin(), math.tan() og 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
Bemærk, at de hidtidige eksempler er resultaterne af at køre programmet i CPython. Bemærk, at andre implementeringer eller miljøer kan håndtere negative nuller anderledes.
