Met math, de standaardmodule van Python voor wiskundige functies, kunt u goniometrische functies (sin, cos, tan) en inverse goniometrische functies (arcsin, arccos, arctan) berekenen.
De volgende inhoud wordt hier uitgelegd met voorbeeldcodes.
- Pi (3,1415926..):
math.pi - Omrekenen van hoeken (radialen, graden):
math.degrees(),math.radians() - Sinus, Inverse sinus:
math.sin(),math.asin() - cosinus, inverse cosinus:
math.cos(),math.acos() - Raaklijn, Inverse raaklijn:
math.tan(),math.atan(),math.atan2() - Verschillen hieronder:
math.atan(),math.atan2()
Pi (3,1415926..): math.pi
Pi wordt in de wiskunde module als een constante gegeven. Hij wordt als volgt uitgedrukt.math.pi
import math
print(math.pi)
# 3.141592653589793
Omrekenen van hoeken (radialen, graden): math.degrees(), math.radians()
Trigonometrische en inverse trigonometrische functies in de module wiskunde gebruiken de radiaal als eenheid van hoek.
Gebruik math.degrees() en math.radians() om om te rekenen tussen radialen (booggradenmethode) en graden (gradenmethode).
Math.degrees() converteert van radialen naar graden, en math.radians() converteert van graden naar radialen.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
Sinus, Inverse sinus: math.sin(), math.asin()
De functie om de sinus (sin) te vinden is math.sin() en de functie om de inverse sinus (arcsin) te vinden is math.asin().
Hier is een voorbeeld van het vinden van de sinus van 30 graden, met behulp van math.radians() om graden om te zetten in radialen.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
De sinus van 30 graden is 0,5, maar er is een fout omdat pi, een irrationaal getal, niet nauwkeurig kan worden berekend.
Indien u wenst af te ronden naar het gepaste aantal cijfers, gebruikt u de functie round() of de methode format() of de functie format().
Merk op dat de terugkeerwaarde van round() een getal is (int of float), maar de terugkeerwaarde van format() is een string. Als je die wilt gebruiken voor volgende berekeningen, gebruik dan 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'>
De functie round() specificeert het aantal decimalen als tweede argument. Merk op dat dit niet strikt afronden is. Zie het volgende artikel voor details.
De format() methode en format() functie specificeren het aantal decimalen in de formatteringsspecificatie string. Zie het volgende artikel voor details.
- GERELATEERD:Formaat conversie in Python, formaat (0-vulling, exponentiële notatie, hexadecimaal, etc.)
Als je wilt vergelijken, kun je ook math.isclose() gebruiken.
print(math.isclose(sin30, 0.5))
# True
Op dezelfde manier is hier een voorbeeld van het vinden van de inverse sinus van 0,5. math.asin() geeft radialen terug, die worden omgezet in graden met math.degrees().
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
cosinus, inverse cosinus: math.cos(), math.acos()
De functie om de cosinus (cos) te vinden is math.cos(), en de functie om de inverse cosinus (arc cosinus, arccos) te vinden is math.acos().
Hier is een voorbeeld van het vinden van de cosinus van 60 graden en de inverse cosinus van 0,5.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
Indien u wenst af te ronden naar het juiste cijfer, kunt u round() of format() gebruiken zoals bij sinus.
Raaklijn, Inverse raaklijn: math.tan(), math.atan(), math.atan2()
De functie om de tangens (tan) te vinden is math.tan(), en de functie om de inverse tangens (arctan) te vinden is math.atan() of math.atan2().
Math.atan2() wordt later beschreven.
Een voorbeeld van het vinden van de tangens van 45 graden en de inverse tangens van 1 graad staat hieronder.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
Verschil tussen math.atan() en math.atan2()
Zowel math.atan() als math.atan2() zijn functies die de inverse tangens teruggeven, maar ze verschillen in het aantal argumenten en het bereik van de teruggegeven waarden.
math.atan(x) heeft één argument en geeft arctan(x) terug in radialen. De teruggegeven waarde zal liggen tussen -pi \ 2 en pi \ 2 (-90 tot 90 graden).
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
In het bovenstaande voorbeeld staat math.inf voor oneindig.
math.atan2(y, x) heeft twee argumenten en geeft arctan(y \ x) terug in radialen. Deze hoek is de hoek (declinatie) die de vector van de oorsprong naar de coördinaten (x, y) maakt met de positieve richting van de x-as in het poolcoordinatenvlak, en de teruggegeven waarde ligt tussen -pi en pi (-180 tot 180 graden).
Aangezien hoeken in het tweede en derde kwadrant ook correct kunnen worden verkregen, is math.atan2() geschikter dan math.atan() wanneer men het polaire coördinatenvlak beschouwt.
Merk op dat de volgorde van de argumenten y, x is, niet 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
Zoals in het voorbeeld hierboven is de negatieve richting van de x-as (y is nul en x is negatief) pi (180 graden), maar wanneer y negatief nul is, is het -pi (-180 graden). Wees voorzichtig als je het teken strikt wil hanteren.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
Negatieve nullen zijn het resultaat van de volgende bewerkingen
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
Gehele getallen worden niet behandeld als negatieve nullen.
print(-0.0)
# -0.0
print(-0)
# 0
Zelfs wanneer zowel x als y nul zijn, hangt het resultaat af van het teken.
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
Er zijn andere voorbeelden waarbij het teken van het resultaat verandert afhankelijk van negatieve nullen, zoals math.atan2() en math.sin(), math.asin(), math.tan(), en 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
Merk op dat de voorbeelden tot nu toe de resultaten zijn van het draaien van het programma in CPython. Merk op dat andere implementaties of omgevingen anders kunnen omgaan met negatieve nullen.
