Python Math-Modul — Funktionen, Konstanten & Beispiele

Python enthält ein eingebautes math-Modul, das Zugriff auf die mathematischen Funktionen der C-Standardbibliothek bietet. Dieses Kapitel behandelt:

Grundlegende arithmetische Operatoren, die Python nativ bereitstellt
Alle wichtigen Konstanten (pi, e, tau, inf, nan)
Hilfsfunktionen für Rundung, Betrag, Potenzen und Quadratwurzel
Trigonometrische Funktionen und die Umrechnung zwischen Grad und Bogenmass
Logarithmische und exponentielle Funktionen
Zahlentheoretische Hilfsfunktionen: gcd, factorial, isqrt, comb, perm
Gleitkommazahl-Inspektion: isfinite, isinf, isnan, isclose

Eine Installation ist nicht nötig — import math genügt.

Grundlegende arithmetische Operatoren

Python verarbeitet alltägliche Arithmetik mit eingebauten Operatoren — kein Modul erforderlich.

# Integer and float arithmetic
print(2 + 3)    # 5    — addition
print(5 - 2)    # 3    — subtraction
print(3 * 4)    # 12   — multiplication
print(10 / 2)   # 5.0  — true division (always returns float)
print(10 // 3)  # 3    — floor division (rounds toward negative infinity)
print(10 % 3)   # 1    — modulo (remainder)
print(2 ** 8)   # 256  — exponentiation

Der **-Operator ist die idiomatische Python-Schreibweise zum Potenzieren. Verwenden Sie ihn anstelle von math.pow() bei ganzzahligen Eingaben — das Ergebnis bleibt ein Integer, während math.pow() immer ein float zurückgibt.

Das math-Modul importieren

Für alles, was über die obigen Operatoren hinausgeht, importieren Sie math:

import math

Sie können auch bestimmte Namen importieren, um das math.-Präfix zu vermeiden:

from math import sqrt, pi, factorial
print(sqrt(25))     # 5.0
print(pi)           # 3.141592653589793
print(factorial(5)) # 120

Im Produktionscode empfiehlt sich import math — so ist die Herkunft jeder Funktion eindeutig erkennbar.

Mathematische Konstanten

Das math-Modul definiert mehrere Konstanten:

import math

print(math.pi)   # 3.141592653589793  — ratio of circumference to diameter
print(math.e)    # 2.718281828459045  — base of the natural logarithm
print(math.tau)  # 6.283185307179586  — 2 * pi (full circle in radians)
print(math.inf)  # inf                — positive infinity
print(math.nan)  # nan                — "not a number" sentinel

math.inf eignet sich als Startwert, wenn Sie einen „größtmöglichen" Wächter benötigen:

import math

best = math.inf
for value in [5, 3, 8, 1]:
    if value < best:
        best = value
print(best)  # 1

Runden und Betrag

import math

print(math.floor(3.7))   # 3    — round toward negative infinity
print(math.ceil(3.2))    # 4    — round toward positive infinity
print(math.trunc(3.9))   # 3    — strip the decimal (toward zero)
print(math.trunc(-3.9))  # -3   — note: trunc(-3.9) != floor(-3.9)
print(math.fabs(-5.3))   # 5.3  — absolute value, always returns float
print(abs(-5))           # 5    — built-in abs() works for int and float

Der Unterschied zwischen trunc und floor ist bei negativen Zahlen relevant:

import math

print(math.floor(-3.2))   # -4  — floor always rounds down
print(math.trunc(-3.2))   # -3  — trunc always rounds toward zero

Quadratwurzel, Potenz und Hypotenuse

import math

print(math.sqrt(25))      # 5.0  — square root (returns float)
print(math.isqrt(17))     # 4    — integer square root (floor, returns int)
print(math.pow(2, 10))    # 1024.0  — power, always returns float
print(2 ** 10)            # 1024    — integer exponentiation, stays int
print(math.hypot(3, 4))   # 5.0  — Euclidean distance sqrt(3²+4²)

math.isqrt() (ab Python 3.8) ist die richtige Wahl, wenn Sie ein ganzzahliges Ergebnis ohne Konvertierung aus einem float benötigen — zum Beispiel beim Prüfen auf Quadratzahlen:

import math

n = 144
if math.isqrt(n) ** 2 == n:
    print(f"{n} is a perfect square")  # 144 is a perfect square

math.hypot() akzeptiert seit Python 3.8 mehr als zwei Argumente und berechnet die euklidische Norm in beliebig vielen Dimensionen:

import math

# 3-D distance from origin to (1, 2, 2)
print(math.hypot(1, 2, 2))  # 3.0

Fakultät und ganzzahlige Hilfsfunktionen

import math

print(math.factorial(5))   # 120  — 5! = 5*4*3*2*1
print(math.factorial(0))   # 1    — 0! is defined as 1
print(math.gcd(48, 18))    # 6    — greatest common divisor
print(math.lcm(4, 6))      # 12   — least common multiple (Python 3.9+)

math.factorial löst bei negativen Eingaben einen ValueError und bei Nicht-Ganzzahlen einen TypeError aus.

Kombinatorik

Python 3.8 fügte math.comb und math.perm hinzu, um manuelle Fakultätsformeln zu ersetzen:

import math

# Number of ways to choose 2 items from 5 (order does not matter)
print(math.comb(5, 2))   # 10

# Number of ways to arrange 2 items from 5 (order matters)
print(math.perm(5, 2))   # 20

# All permutations of 5 items
print(math.perm(5))      # 120  — same as factorial(5)

comb(n, k) entspricht n! / (k! * (n-k)!), ist aber schneller und vermeidet große Zwischenwerte.

Trigonometrische Funktionen

Das math-Modul arbeitet mit Bogenmass. Verwenden Sie math.radians(), um Grad zuerst umzurechnen.

import math

angle_deg = 30
angle_rad = math.radians(angle_deg)  # 0.5235987755982988

print(math.sin(angle_rad))           # 0.49999999999999994  (~0.5)
print(math.cos(angle_rad))           # 0.8660254037844387   (~√3/2)
print(math.tan(angle_rad))           # 0.5773502691896256   (~1/√3)

# Convert radians back to degrees
print(math.degrees(math.pi))         # 180.0

Häufige Winkelwerte im Bogenmass:

Grad	Bogenmaß-Ausdruck	`math`-Wert
0°	`0`	`0`
30°	`math.pi / 6`	`0.5236…`
45°	`math.pi / 4`	`0.7854…`
90°	`math.pi / 2`	`1.5708…`
180°	`math.pi`	`3.1416…`

Inverse trigonometrische Funktionen geben Bogenmass zurück:

import math

print(math.asin(0.5))                # 0.5235987755982988  (= pi/6 = 30°)
print(math.acos(0.5))                # 1.0471975511965976  (= pi/3 = 60°)
print(math.atan(1.0))                # 0.7853981633974483  (= pi/4 = 45°)

# atan2(y, x) handles all quadrants correctly
print(math.atan2(1, -1))             # 2.356…  (135° — second quadrant)
print(math.atan2(-1, -1))            # -2.356… (225° / -135°)

Verwenden Sie math.atan2(y, x) anstelle von math.atan(y/x), wenn Sie den korrekten Quadranten benötigen.

Logarithmische Funktionen

import math

print(math.log(math.e))    # 1.0    — natural log (base e)
print(math.log(100, 10))   # 2.0    — log with explicit base
print(math.log10(1000))    # 3.0    — base-10 log (more accurate than log(x, 10))
print(math.log2(8))        # 3.0    — base-2 log (more accurate than log(x, 2))

Bevorzugen Sie math.log10 und math.log2 gegenüber math.log(x, 10) und math.log(x, 2) — die dedizierten Funktionen bieten eine bessere numerische Genauigkeit.

math.log löst bei nicht-positiven Eingaben einen ValueError aus:

import math

try:
    math.log(0)
except ValueError as e:
    print(e)   # math domain error

Exponentielle Funktionen

import math

print(math.exp(1))    # 2.718281828459045  — e¹
print(math.exp(0))    # 1.0                — e⁰
print(math.exp(2))    # 7.38905609893065   — e²

# For small x, expm1(x) is more accurate than exp(x) - 1
print(math.expm1(1e-10))  # 1.00000000005e-10  (accurate)
print(math.exp(1e-10) - 1)  # 1.000000082740371e-10   (slightly less precise)

math.expm1(x) berechnet e**x - 1 mit höherer Genauigkeit, wenn x nahe null liegt — relevant für Finanz- und wissenschaftliche Berechnungen.

Gleitkommazahl-Inspektion

import math

print(math.isfinite(1.0))      # True
print(math.isfinite(math.inf)) # False
print(math.isfinite(math.nan)) # False

print(math.isinf(math.inf))    # True
print(math.isinf(-math.inf))   # True
print(math.isinf(1e308))       # False  — large but finite

print(math.isnan(math.nan))    # True
print(math.isnan(float('nan')))# True
print(math.isnan(0.0))         # False

Gleitkommazahlen mit isclose vergleichen

Aufgrund der Gleitkommadarstellung können direkte Gleichheitsvergleiche fehlschlagen:

print(0.1 + 0.2 == 0.3)           # False  — floating-point rounding

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True  — within default tolerance

math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0) gibt True zurück, wenn |a - b| innerhalb der relativen oder absoluten Toleranz liegt. Verwenden Sie beim Vergleich berechneter Gleitkommazahlen stets math.isclose statt ==.

Kurzübersicht

Funktion	Rückgabetyp	Beispiel
`math.sqrt(x)`	float	`sqrt(9)` → `3.0`
`math.isqrt(x)`	int	`isqrt(10)` → `3`
`math.pow(x, y)`	float	`pow(2, 8)` → `256.0`
`math.floor(x)`	int	`floor(3.9)` → `3`
`math.ceil(x)`	int	`ceil(3.1)` → `4`
`math.trunc(x)`	int	`trunc(-3.9)` → `-3`
`math.fabs(x)`	float	`fabs(-4)` → `4.0`
`math.factorial(n)`	int	`factorial(5)` → `120`
`math.gcd(a, b)`	int	`gcd(12, 8)` → `4`
`math.comb(n, k)`	int	`comb(5, 2)` → `10`
`math.perm(n, k)`	int	`perm(5, 2)` → `20`
`math.log(x)`	float	`log(e)` → `1.0`
`math.log10(x)`	float	`log10(100)` → `2.0`
`math.log2(x)`	float	`log2(8)` → `3.0`
`math.exp(x)`	float	`exp(1)` → `2.718…`
`math.sin(x)`	float	`sin(pi/2)` → `1.0`
`math.cos(x)`	float	`cos(0)` → `1.0`
`math.tan(x)`	float	`tan(pi/4)` → `1.0`
`math.degrees(x)`	float	`degrees(pi)` → `180.0`
`math.radians(x)`	float	`radians(180)` → `3.14…`
`math.hypot(*coords)`	float	`hypot(3, 4)` → `5.0`
`math.isclose(a, b)`	bool	`isclose(0.1+0.2, 0.3)` → `True`
`math.isfinite(x)`	bool	`isfinite(inf)` → `False`
`math.isinf(x)`	bool	`isinf(inf)` → `True`
`math.isnan(x)`	bool	`isnan(nan)` → `True`

Übungen

Übung

Which math module function returns the largest integer less than or equal to a given number?

math.ceil()math.floor()math.trunc()math.round()