round()

Einleitung

round() macht zwei Dinge je nach Eingabe:

• Mit int: round(7) → 7 (no-op, Identität).
• Mit float: rundet auf die angegebene Stelle, liefert float.
• Mit Custom-Klasse: ruft __round__() auf der Klasse.

Die wichtigste Eigenheit: Python rundet bei 0.5-Hälften zur nächsten geraden Zahl (Banker's Rounding):

• round(0.5) → 0 (nicht 1)
• round(1.5) → 2
• round(2.5) → 2 (nicht 3)

Das ist statistisch fairer als immer aufzurunden — vermeidet Bias bei vielen Rundungen. Wer kaufmännisches Runden will, nutzt decimal.Decimal mit explizitem Rounding-Mode oder int(x + 0.5).

Mit negativem ndigits rundet round() auf Zehner-, Hunderter-, Tausender-Stellen.

Syntax

round(number)              # auf Ganzzahl
round(number, ndigits)     # auf ndigits Nachkommastellen

Rückgabewert

• Ohne ndigits (oder None): int.
• Mit ndigits: derselbe Typ wie das Input (float bleibt float, Decimal bleibt Decimal).

Beispiele

Standard-Verwendung

Mit positivem ndigits wird hinter dem Komma gerundet — so wie meistens erwartet:

print(round(3.14159))
print(round(3.14159, 2))
print(round(3.14159, 4))
print(round(0.123456, 3))

3
3.14
3.1416
0.123

Banker's Rounding bei .5

Hier kommt die Überraschung — Python rundet 0.5 zur nächsten geraden Zahl:

for n in [0.5, 1.5, 2.5, 3.5, 4.5]:
    print(n, "→", round(n))

0.5 → 0
1.5 → 2
2.5 → 2
3.5 → 4
4.5 → 4

Negative Stellen — vor dem Komma

Mit negativem ndigits rundet round() zu Zehnern, Hundertern usw.:

print(round(1234.567, -1))   # auf Zehner
print(round(1234.567, -2))   # auf Hunderter
print(round(1234.567, -3))   # auf Tausender

1230.0
1200.0
1000.0

Praktische Beispiele

Float-Ungenauigkeit beim Runden

round() rundet auf das nächste darstellbare Float — manche Werte zeigen Float-Artefakte:

# 2.675 ist intern 2.6749999... — wird daher zu 2.67 abgerundet
print(round(2.675, 2))

2.67

Kaufmännisches Runden mit Decimal

Wer „immer aufrunden bei 0.5" braucht, nutzt decimal.Decimal mit explizitem Modus:

from decimal import Decimal, ROUND_HALF_UP

for n in [Decimal("0.5"), Decimal("1.5"), Decimal("2.5")]:
    print(n, "→", n.quantize(Decimal("1"), rounding=ROUND_HALF_UP))

0.5 → 1
1.5 → 2
2.5 → 3

Custom-Klasse mit round

Eigene Klassen können __round__ implementieren — dann funktioniert round() direkt:

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __round__(self, ndigits=2):
        return Money(round(self.amount, ndigits))

    def __repr__(self):
        return f"Money({self.amount})"

m = Money(12.3456)
print(round(m))
print(round(m, 1))

Money(12.35)
Money(12.3)

Praktische Hinweise

• Banker's Rounding ist Default — sorgt statistisch für faire Verteilung, kann aber überraschen.
• Float-Ungenauigkeit: round(2.675, 2) liefert 2.67, nicht 2.68. Für exakte Beträge Decimal nutzen.
• Negatives ndigits rundet vor dem Komma — round(1234, -2) → 1200.
• int(x) schneidet Richtung 0 ab, math.floor()/math.ceil() runden in eine Richtung — round() ist nur eine von mehreren Optionen.
• Verwandte Funktionen: math.floor(), math.ceil(), math.trunc(), decimal.Decimal.quantize().