Berechnung von trigonometrischen Funktionen in Python (sin, cos, tan, arcsin, arccos, arctan)

Geschäft

Mit math, dem Standardmodul von Python für mathematische Funktionen, können Sie trigonometrische Funktionen (sin, cos, tan) und inverse trigonometrische Funktionen (arcsin, arccos, arctan) berechnen.

Die folgenden Inhalte werden hier mit Beispielcodes erläutert.

  • Pi (3.1415926..):math.pi
  • Umrechnung von Winkeln (Bogenmaß, Grad):math.degrees(),math.radians()
  • Sinus, inverser Sinus:math.sin(),math.asin()
  • Kosinus, inverser Kosinus:math.cos(),math.acos()
  • Tangens, inverser Tangens:math.tan(),math.atan(),math.atan2()
  • Unterschiede unten:math.atan(),math.atan2()

Pi (3.1415926..): math.pi

Pi ist als Konstante im Mathematikmodul enthalten. Sie wird wie folgt ausgedrückt.
math.pi

import math

print(math.pi)
# 3.141592653589793

Umrechnung von Winkeln (Bogenmaß, Grad): math.degrees(), math.radians()

Trigonometrische und inverse trigonometrische Funktionen im Mathematikmodul verwenden den Bogenmaß als Einheit des Winkels.

Verwenden Sie math.degrees() und math.radians(), um zwischen Bogenmaß (Bogengradmethode) und Grad (Gradmethode) umzurechnen.

Math.degrees() konvertiert von Bogenmaß in Grad, und math.radians() konvertiert von Grad in Bogenmaß.

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

print(math.radians(180))
# 3.141592653589793

Sinus, inverser Sinus: math.sin(), math.asin()

Die Funktion zur Ermittlung des Sinus (sin) ist math.sin() und die Funktion zur Ermittlung des inversen Sinus (arcsin) ist math.asin().

Hier ein Beispiel für die Ermittlung des Sinus von 30 Grad unter Verwendung von math.radians() zur Umwandlung von Grad in Bogenmaß.

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

Der Sinus von 30 Grad ist 0,5, aber es gibt einen Fehler, weil Pi, eine irrationale Zahl, nicht genau berechnet werden kann.

Wenn Sie auf die entsprechende Anzahl von Ziffern runden möchten, verwenden Sie die Funktion round() oder die Methode format() oder die Funktion format().

Beachten Sie, dass der Rückgabewert von round() eine Zahl (int oder float) ist, der Rückgabewert von format() aber eine Zeichenkette. Wenn Sie ihn für nachfolgende Berechnungen verwenden wollen, benutzen Sie 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'>

Die Funktion round() gibt die Anzahl der Dezimalstellen als zweites Argument an. Beachten Sie, dass es sich hierbei nicht um eine reine Rundung handelt. Siehe den folgenden Artikel für weitere Einzelheiten.

Die Methode format() und die Funktion format() geben die Anzahl der Dezimalstellen in der Zeichenkette für die Formatierung an. Siehe den folgenden Artikel für Details.

Wenn Sie vergleichen wollen, können Sie auch math.isclose() verwenden.

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

Ein ähnliches Beispiel ist die Ermittlung des inversen Sinus von 0,5. math.asin() liefert das Bogenmaß, das mit math.degrees() in Grad umgewandelt wird.

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

print(round(asin05, 3))
# 30.0

Kosinus, inverser Kosinus: math.cos(), math.acos()

Die Funktion zur Bestimmung des Kosinus (cos) ist math.cos(), und die Funktion zur Bestimmung des inversen Kosinus (Arcuskosinus, arccos) ist math.acos().

Hier ein Beispiel für die Ermittlung des Kosinus von 60 Grad und des inversen Kosinus von 0,5.

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

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

Wenn Sie auf die entsprechende Ziffer runden möchten, können Sie round() oder format() wie bei Sinus verwenden.

Tangens, inverser Tangens: math.tan(), math.atan(), math.atan2()

Die Funktion zur Ermittlung des Tangens (tan) ist math.tan(), und die Funktion zur Ermittlung des inversen Tangens (arctan) ist math.atan() oder math.atan2().
Math.atan2() wird später beschrieben.

Ein Beispiel für die Bestimmung des Tangens von 45 Grad und des inversen Tangens von 1 Grad ist unten dargestellt.

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

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

Unterschied zwischen math.atan() und math.atan2()

Sowohl math.atan() als auch math.atan2() sind Funktionen, die den inversen Tangens zurückgeben, aber sie unterscheiden sich durch die Anzahl der Argumente und den Bereich der Rückgabewerte.

math.atan(x) hat ein Argument und gibt arctan(x) im Bogenmaß zurück. Der Rückgabewert liegt zwischen -pi \ 2 und pi \ 2 (-90 bis 90 Grad).

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

Im obigen Beispiel steht math.inf für Unendlichkeit.

math.atan2(y, x) hat zwei Argumente und gibt arctan(y \ x) im Bogenmaß zurück. Dieser Winkel ist der Winkel (Deklination), den der Vektor vom Ursprung zu den Koordinaten (x, y) mit der positiven Richtung der x-Achse in der Polarkoordinatenebene bildet, und der zurückgegebene Wert liegt zwischen -pi und pi (-180 bis 180 Grad).

Da auch die Winkel im zweiten und dritten Quadranten korrekt ermittelt werden können, ist math.atan2() bei der Betrachtung der Polarkoordinatenebene besser geeignet als math.atan().

Beachten Sie, dass die Reihenfolge der Argumente y, x, nicht x, y ist.

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

Wie im obigen Beispiel ist die negative Richtung der x-Achse (y ist Null und x ist negativ) pi (180 Grad), aber wenn y negativ Null ist, ist sie -pi (-180 Grad). Seien Sie vorsichtig, wenn Sie das Vorzeichen streng behandeln wollen.

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

Negative Nullen sind das Ergebnis der folgenden Operationen

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

print(-1.0 * 0.0)
# -0.0

Ganzzahlen werden nicht als negative Nullen behandelt.

print(-0.0)
# -0.0

print(-0)
# 0

Selbst wenn sowohl x als auch y Null sind, hängt das Ergebnis vom Vorzeichen ab.

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

Es gibt weitere Beispiele, bei denen sich das Vorzeichen des Ergebnisses in Abhängigkeit von negativen Nullen ändert, z. B. math.atan2() sowie math.sin(), math.asin(), math.tan() und 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

Beachten Sie, dass die bisherigen Beispiele die Ergebnisse der Ausführung des Programms in CPython sind. Beachten Sie, dass andere Implementierungen oder Umgebungen mit negativen Nullen anders umgehen können.