Programmiergrundlagen3Lerneinheiten32minStand18.06.2026

Math-Bibliothek.

Die Math-Bibliothek liefert Standard-Funktionen für Berechnungen, die nicht in den Sprachkern eingebaut sind: Wurzel, Potenz, Trigonometrie, Logarithmus, Min/Max, Runden. In Java die statische Math-Klasse, in Python das math-Modul. Du lernst hier, welche Funktionen in Java und Python wichtig sind, welche Rückgabetypen sie haben (z. B. Math.pow liefert immer double), wie Rundung bei positiven und negativen Zahlen unterschiedlich funktioniert, warum trigonometrische Funktionen Radiant erwarten (nicht Grad), wie Zufallsbereiche richtig konstruiert werden, warum 0.1 + 0.2 == 0.3 false ist (Floating-Point) und welche Java-vs-Python-Unterschiede in Klausuren oft geprüft werden.

Die wichtigsten Funktionen für die Klausur:

Math.sqrt(x): Quadratwurzel
Math.pow(base, exp): Potenz, z. B. Math.pow(2, 10) = 1024.0 (Rückgabe in Java immer double)
Math.abs(x): Betrag, liefert normalerweise einen nicht-negativen Wert. Ausnahme: bei Integer.MIN_VALUE und Long.MIN_VALUE in Java bleibt der Wert negativ wegen Zwei-Komplement-Overflow (der positive Gegenwert passt nicht in den int/long-Wertebereich).
Math.min(a, b) / Math.max(a, b): kleinerer / größerer Wert
Math.round(x) / Math.floor(x) / Math.ceil(x): Runden, Abrunden, Aufrunden
Math.PI / Math.E: die Konstanten Pi und e
Math.random(): Zufallszahl im Bereich $[0, 1)$ , also 0 inklusive, 1 exklusiv

In Klausuren oft gefragt: schreibe Code der mit Math-Funktionen [Aufgabe] löst. Achte auf den Rückgabetyp: Math.sqrt und Math.pow geben double zurück, auch wenn das Ergebnis ganzzahlig wäre. Du musst dann zu int casten falls gefordert.

Du brauchst:

die Quadratwurzel von 144 → 12
den Betrag von -7 → 7
$2^{10}$ → 1024
den kleineren von zwei Werten
die nächst-ganze Zahl zu 3,7
eine Zufallszahl

Alles, was über +/-/*/% hinausgeht, kommt aus der Math-Bibliothek. Du musst es nicht selbst implementieren.

Funktion	Was es tut	Beispiel
abs(x)	Betrag (Vorzeichen weg)	abs(-7) = 7
sqrt(x)	Quadratwurzel	sqrt(144) = 12
pow(x, y)	x hoch y	pow(2, 10) = 1024
max(x, y)	Größere von beiden	max(3, 7) = 7
min(x, y)	Kleinere von beiden	min(3, 7) = 3
round(x)	Runden	Java: `Math.round(3.5)` = 4. Python: `round(2.5)` = 2, `round(3.5)` = 4 (Banker's Rounding)
floor(x)	Abrunden	floor(3.9) = 3
ceil(x)	Aufrunden	ceil(3.1) = 4
log(x)	natürlicher Log (Basis e)	log(e) = 1
log10(x)	Log Basis 10	log10(1000) = 3
sin/cos/tan(x)	Trigonometrie (Radiant!)	sin(0) = 0
random()	Zufallszahl in [0, 1)	random() = z.B. 0,742
PI	Kreiszahl π	3,14159…
E	Eulersche Zahl e	2,71828…

// Java, alle Funktionen sind statische Methoden in java.lang.Math
double a = Math.abs(-7);            // 7.0
double b = Math.sqrt(144);          // 12.0
double c = Math.pow(2, 10);         // 1024.0
int d = Math.max(3, 7);             // 7
double pi = Math.PI;                // 3.141592653589793

// Edge Case Math.abs:
int weird = Math.abs(Integer.MIN_VALUE);  // = Integer.MIN_VALUE (negativ!)
                                          // Overflow: |-2^31| passt nicht in int

// Math ist immer importiert (java.lang), kein import nötig

import math      # erst importieren
import random    # für random Funktionen separates Modul

a = abs(-7)              # 7         abs ist BUILT-IN, kein math. nötig!
b = math.sqrt(144)       # 12.0
c = 2 ** 10              # 1024      Operator ** statt pow()
d = max(3, 7)            # 7         max/min BUILT-IN
pi = math.pi             # 3.14159...
r = random.random()      # 0.742...  Zufallszahl

Klausur-Trick Python: abs, max, min, round, pow sind Built-ins, kein math. Prefix nötig. sqrt, floor, ceil, log, sin sind im math-Modul.

Drei verschiedene Konzepte:

Funktion	Bedeutung	Beispiel
round(x)	Zur nächsten ganzen Zahl	round(3.5) = 4
floor(x)	Zur nächst-kleineren ganzen Zahl	floor(3.9) = 3
ceil(x)	Zur nächst-größeren ganzen Zahl	ceil(3.1) = 4
(int) x (Cast)	Truncation Richtung 0	(int) 3.9 = 3

Bei negativen Zahlen wird's interessant

Math.round(-3.5)    // -3   bei .5: Java rundet Richtung +∞, also floor(x + 0.5)
Math.round(3.5)     //  4

Math.floor(-3.5)    // -4   (Richtung minus unendlich)
Math.floor(3.5)     //  3

Math.ceil(-3.5)     // -3   (Richtung plus unendlich)
Math.ceil(3.5)      //  4

(int) -3.5          // -3   (Truncation Richtung 0)

Java Math.round ist also nicht "rundet immer auf", bei negativen Halbwerten wie -3.5 gibt es -3, nicht -4. Konsistent ist die Formel floor(x + 0.5).

Klausur-Falle: floor(-3.5) = -4, aber (int) -3.5 = -3. Bei negativen Zahlen sind Floor und Truncation ungleich!

Banker's Rounding in Python

round(0.5)     # 0  (NICHT 1!)
round(1.5)     # 2
round(2.5)     # 2  (NICHT 3!)
round(3.5)     # 4

Python's round rundet bei .5 zur nächsten geraden Zahl ("Banker's Rounding"). Vermeidet Bias bei vielen Rundungen. Java Math.round verhält sich bei .5 wie floor(x + 0.5), also $3.5 \to 4$ , aber $-3.5 \to -3$ .

// Java
double a = Math.pow(2, 10);      // 1024.0  (immer double Rückgabe)
int b = 2 * 2 * 2;               // schnell für kleine Potenzen

# Python
a = 2 ** 10                      # 1024  (Operator)
b = pow(2, 10)                   # 1024  (Built-in)
c = math.pow(2, 10)              # 1024.0  (immer float)
d = pow(2, 10, 7)                # 2  (modulares Pow: 2^10 mod 7)

Tipp Python: pow(x, y, mod) ist der modulare Pow, wichtig in Kryptografie (z.B. RSA).

// Java, Math.random()
double r1 = Math.random();           // 0.0 ≤ r < 1.0

// Zahl zwischen 0 und 99 (inklusive)
int r2 = (int) (Math.random() * 100);

// Zahl zwischen 1 und 6 (Würfel)
int dice = (int) (Math.random() * 6) + 1;

import random

random.random()              # 0.0 ≤ r < 1.0
random.randint(1, 6)         # 1, 2, 3, 4, 5 oder 6 (BEIDE Grenzen inklusive)
random.uniform(1, 10)        # float zwischen 1.0 und 10.0
random.choice([1, 2, 3])     # eines davon zufällig

Reproduzierbar: random.seed(42) (Python) bzw. new Random(42) (Java) gibt jedes Mal die selbe Folge, wichtig für Tests.

Würfel-Pattern (Klausur-Klassiker)

// Java, Wurf 1-6
int dice = (int) (Math.random() * 6) + 1;
//                  └── 0 bis 5.999... ──┘ + 1 = 1 bis 6

# Python einfacher
dice = random.randint(1, 6)

Wichtig: Math.sin, Math.cos, Math.tan erwarten Radiant, nicht Grad!

Grad	Radiant
0°	0
90°	π/2
180°	π
360°	2π

// Falsch: erwartet Grad? NEIN
double bad = Math.sin(90);          // 0.8939... (90 Radiant!)

// Richtig: Grad → Radiant
double right = Math.sin(Math.toRadians(90));  // 1.0

import math
math.sin(math.radians(90))   # 1.0 (Grad zuerst umrechnen!)
math.sin(math.pi / 2)        # 1.0 (direkt in Radiant)

double pi = Math.PI;        // 3.141592653589793
double e = Math.E;          // 2.718281828459045

import math
math.pi    # 3.141592653589793
math.e     # 2.718281828459045
math.inf   # Infinity
math.nan   # Not a Number

Trick 1, Vier Rundungs-Verhalten unterscheiden:

round zur nächsten Zahl
floor immer abrunden (Richtung minus unendlich)
ceil immer aufrunden
(int) Cast Truncation (Richtung 0)

Trick 2, sqrt von negativen Zahlen:

Java: Math.sqrt(-1) = NaN (Not a Number)
Python: math.sqrt(-1) wirft ValueError

Vorher prüfen; Math.abs nur verwenden, wenn fachlich wirklich die Wurzel aus dem Betrag gemeint ist (sonst verschleiert es einen Eingabefehler).

Trick 3, pow gibt double zurück (Java):

int a = Math.pow(2, 10);            // FEHLER (double → int braucht Cast)
int b = (int) Math.pow(2, 10);      // OK: 1024

Trick 4, Random-Bereich umrechnen:

Math.random() * (max - min) + min   // double in [min, max)
(int) (Math.random() * n)           // int in [0, n-1]
(int) (Math.random() * (max-min+1)) + min   // int in [min, max]

Trick 5, Trigonometrie immer in Radiant: Math.sin(90) ist NICHT sin(90°). Erst Math.toRadians.

Trick 6, Banker's Rounding nur in Python:

Python: round(0.5) = 0, round(2.5) = 2 (zur geraden Zahl)
Java: Math.round(0.5) = 1, Math.round(2.5) = 3 (immer aufrunden)

Trick 7, log ohne Basis-Argument ist ln:

log(x) ist natürlicher Logarithmus (Basis e)
log10(x) ist Logarithmus zur Basis 10
Bel. Basis: log(x) / log(basis)

double log2_8 = Math.log(8) / Math.log(2);   // 3

Trick 8, Math.abs hat ein Problem:

Math.abs(Integer.MIN_VALUE)    // BUG: liefert Integer.MIN_VALUE!

Weil int-Overflow: -2147483648 hat keine positive Entsprechung im int-Bereich.

Trick 9, Math.PI und Math.E sind double: kein int möglich, da irrational.

Trick 10, Python f-string mit Math:

print(f"π = {math.pi:.4f}")    # π = 3.1416

Geometrie: Pythagoras, Kreisflächen, Rotationen
Statistik: Mittelwerte, Standardabweichung (sqrt drin)
Spiele: Distanz-Berechnung, Würfel, Zufalls-Spawn
Animation: sin/cos für sanfte Bewegungen, Schwingungen
Finance: Zinses-Zins (pow), Logarithmen für Wachstumsraten
Physik-Simulation: jedes Bewegungs-Modell
Cryptography: pow mit Modulo, Random-Generierung

Faustregel: Wenn du in einer Klausur eine mathematische Operation siehst, prüfe ob die Math-Bibliothek die schon hat. Selbst implementieren ist meistens unnötig und fehleranfällig.

13 Funktionen aus der Standard-Math-Bibliothek. Wähle eine und setze die Argumente, sieh sofort den Java-Aufruf und den Python-Aufruf parallel, plus das Ergebnis.

Probier folgendes:

pow(2, 10) = 1024 (Klausur-Klassiker, $2^{10}$ )
sqrt(144) = 12; sqrt(-1): Java Math.sqrt(-1) = NaN, Python math.sqrt(-1) wirft ValueError
floor(-1.5) = -2 (Richtung minus unendlich)
ceil(3.1) = 4
round(2.5), Java: 3, Python: 2 (Banker's Rounding!)
random(), Klick "Neu generieren" für neue Werte
sin(0) = 0, sin(π/2) = 1 (Argument in Radiant!)

Lade Visualisierung...

Faustregel zum Mitnehmen: Math.pow gibt double zurück, sin/cos/tan erwarten Radiant, floor und Cast unterscheiden sich bei negativen Zahlen. Klausur-Klassiker auswendig kennen.

Drei interaktive Demos zu den häufigsten Klausur-Stolperern: Math.round Halfway-Regel (Java rundet bei .5 anders als Banker's Rounding), floor() vs (int)-Cast bei negativen Zahlen, und Floating-Point-Vergleich mit 0.1 + 0.2 == 0.3 (false, weil IEEE-754). Klicke auf Step oder Auto.

1. Math.round bei .5: Java nutzt `floor(x + 0.5)`

Lade Visualisierung...

2. floor() vs (int)-Cast bei negativen Zahlen

Math.floor(x) rundet IMMER zur nächsten kleineren ganzen Zahl (Richtung -Unendlich). (int) x schneidet zur 0 hin ab (Truncation). Bei positiven Zahlen identisch, bei negativen unterschiedlich.

Lade Visualisierung...

3. Floating-Point-Vergleich: warum `0.1 + 0.2 == 0.3` false ist

Double-Werte können viele Dezimalzahlen (wie 0.1) nicht exakt darstellen. Das führt zu winzigen Rundungsfehlern, die bei ==-Vergleich sichtbar werden. In Klausuren oft als Bug-Frage: warum schlägt diese if-Bedingung fehl?

Lade Visualisierung...

Anmelden, um den Fortschritt zu speichern.

Nächster Schritt

Wenn du fertig bist: jetzt üben.

Aktives Abrufen festigt Wissen schneller als nochmal lesen.

Fachliche Qualität

S-Tier · GoldstandardZuletzt geprüft am 18.05.2026

Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.

Klausur-ÜbersichtKomplette Übersicht: alle Tabs als linearer Text zum Lernen

Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).

Teil 1·Erklärung

Erklärung

Die Math-Bibliothek liefert Standard-Funktionen für Berechnungen, die nicht in den Sprachkern eingebaut sind: Wurzel, Potenz, Trigonometrie, , Min/Max, Runden. In Java die statische -, in Python das -Modul. Du lernst hier, welche Funktionen in Java und Python wichtig sind, welche sie haben (z. B. liefert immer double), wie unterschiedlich funktioniert, warum trigonometrische Funktionen erwarten (nicht Grad), wie richtig konstruiert werden, warum ist (Floating-Point) und welche in Klausuren oft geprüft werden.

Zur KategorieProgrammiergrundlagen.Mehr Themen entdeckenZum Themen-Hub.

Funktion

Was es tut

Beispiel

abs(x)

Betrag (Vorzeichen weg)

abs(-7) = 7

sqrt(x)

Quadratwurzel

sqrt(144) = 12

pow(x, y)

x hoch y

pow(2, 10) = 1024

max(x, y)

Größere von beiden

max(3, 7) = 7

min(x, y)

Kleinere von beiden

min(3, 7) = 3

round(x)

Runden

Java: Math.round(3.5) = 4. Python: round(2.5) = 2, round(3.5) = 4 (Banker's Rounding)

floor(x)

Abrunden

floor(3.9) = 3

ceil(x)

Aufrunden

ceil(3.1) = 4

log(x)

natürlicher Log (Basis e)

log(e) = 1

log10(x)

Log Basis 10

log10(1000) = 3

sin/cos/tan(x)

Trigonometrie (Radiant!)

sin(0) = 0

random()

Zufallszahl in [0, 1)

random() = z.B. 0,742

Kreiszahl π

3,14159…

Eulersche Zahl e

2,71828…

// Java, alle Funktionen sind statische Methoden in java.lang.Math double a = Math.abs(-7); // 7.0 double b = Math.sqrt(144); // 12.0 double c = Math.pow(2, 10); // 1024.0 int d = Math.max(3, 7); // 7 double pi = Math.PI; // 3.141592653589793 // Edge Case Math.abs: int weird = Math.abs(Integer.MIN_VALUE); // = Integer.MIN_VALUE (negativ!) // Overflow: |-2^31| passt nicht in int // Math ist immer importiert (java.lang), kein import nötig

import math # erst importieren import random # für random Funktionen separates Modul a = abs(-7) # 7 abs ist BUILT-IN, kein math. nötig! b = math.sqrt(144) # 12.0 c = 2 ** 10 # 1024 Operator ** statt pow() d = max(3, 7) # 7 max/min BUILT-IN pi = math.pi # 3.14159... r = random.random() # 0.742... Zufallszahl

Funktion

Bedeutung

Beispiel

round(x)

Zur nächsten ganzen Zahl

round(3.5) = 4

floor(x)

Zur nächst-kleineren ganzen Zahl

floor(3.9) = 3

ceil(x)

Zur nächst-größeren ganzen Zahl

ceil(3.1) = 4

(int) x (Cast)

Truncation Richtung 0

(int) 3.9 = 3

Math.round(-3.5) // -3 bei .5: Java rundet Richtung +∞, also floor(x + 0.5) Math.round(3.5) // 4 Math.floor(-3.5) // -4 (Richtung minus unendlich) Math.floor(3.5) // 3 Math.ceil(-3.5) // -3 (Richtung plus unendlich) Math.ceil(3.5) // 4 (int) -3.5 // -3 (Truncation Richtung 0)

# Python a = 2 ** 10 # 1024 (Operator) b = pow(2, 10) # 1024 (Built-in) c = math.pow(2, 10) # 1024.0 (immer float) d = pow(2, 10, 7) # 2 (modulares Pow: 2^10 mod 7)

// Java, Math.random() double r1 = Math.random(); // 0.0 ≤ r < 1.0 // Zahl zwischen 0 und 99 (inklusive) int r2 = (int) (Math.random() * 100); // Zahl zwischen 1 und 6 (Würfel) int dice = (int) (Math.random() * 6) + 1;

import random random.random() # 0.0 ≤ r < 1.0 random.randint(1, 6) # 1, 2, 3, 4, 5 oder 6 (BEIDE Grenzen inklusive) random.uniform(1, 10) # float zwischen 1.0 und 10.0 random.choice([1, 2, 3]) # eines davon zufällig

Grad

Radiant

0°

90°

π/2

180°

360°

2π

Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).

Teil 1·Erklärung

Das Problem

Die wichtigsten Funktionen

Java vs. Python

Runden: round, floor, ceil

Bei negativen Zahlen wird's interessant

Banker's Rounding in Python

pow vs ** vs *

Zufallszahlen

Würfel-Pattern (Klausur-Klassiker)

Trigonometrie: Radiant vs. Grad

Konstanten

Klausur-Tricks

Wo brauchst du Math?

Math-Lab

Code-Stepper: Klausur-Klassiker durchspielen

1. Math.round bei .5: Java nutzt floor(x + 0.5)

2. floor() vs (int)-Cast bei negativen Zahlen

3. Floating-Point-Vergleich: warum 0.1 + 0.2 == 0.3 false ist

Wenn du fertig bist: jetzt üben.

Erklärung

Das Problem

Die wichtigsten Funktionen

Java vs. Python

Runden: round, floor, ceil

Bei negativen Zahlen wird's interessant

Banker's Rounding in Python

pow vs ** vs *

Zufallszahlen

Würfel-Pattern (Klausur-Klassiker)

Trigonometrie: Radiant vs. Grad

Konstanten

Klausur-Tricks

Wo brauchst du Math?

Math-Lab

Code-Stepper: Klausur-Klassiker durchspielen

1. Math.round bei .5: Java nutzt floor(x + 0.5)

2. floor() vs (int)-Cast bei negativen Zahlen

3. Floating-Point-Vergleich: warum 0.1 + 0.2 == 0.3 false ist

Wenn du fertig bist: jetzt üben.

Erklärung

Das Problem

Die wichtigsten Funktionen

Java vs. Python

Runden: round, floor, ceil

Bei negativen Zahlen wird's interessant

Banker's Rounding in Python

pow vs ** vs *

Zufallszahlen

Würfel-Pattern (Klausur-Klassiker)

Trigonometrie: Radiant vs. Grad

Konstanten

Klausur-Tricks

Wo brauchst du Math?

Interaktiv

Math-Lab

Code-Stepper: Klausur-Klassiker durchspielen

1. Math.round bei .5: Java nutzt floor(x + 0.5)

2. floor() vs (int)-Cast bei negativen Zahlen

3. Floating-Point-Vergleich: warum 0.1 + 0.2 == 0.3 false ist

Quiz

1. Math.round bei .5: Java nutzt `floor(x + 0.5)`

3. Floating-Point-Vergleich: warum `0.1 + 0.2 == 0.3` false ist

1. Math.round bei .5: Java nutzt `floor(x + 0.5)`

3. Floating-Point-Vergleich: warum `0.1 + 0.2 == 0.3` false ist

1. Math.round bei .5: Java nutzt `floor(x + 0.5)`

3. Floating-Point-Vergleich: warum `0.1 + 0.2 == 0.3` false ist