Zahlen in Python aufrunden: Methoden und Beispiele

Python bietet als besonders vielseitige Programmiersprache viele Möglichkeiten zum Aufrunden und zum Runden allgemein. Gerade in Finanzen oder Statistik gehört Aufrunden zum Pflichtprogramm. Die folgenden Methoden liefern in der Praxis oft ähnliche Ergebnisse, unterscheiden sich aber in wichtigen Details. In diesem Artikel zeige ich dir mehrere Wege, wie du Zahlen aufrundest, und gehe anschließend auf die Unterschiede ein. 

Wenn du angehende:r Data Analyst:in oder Data Scientist bist, empfehle ich dir den Kurs Introduction to Python von DataCamp, um beim Python-Programmieren schnell voranzukommen. Das Python Cheat Sheet for Beginners ist außerdem eine praktische Referenz.

Kurzantwort: So rundest du in Python auf

Die Funktion math.ceil() aus dem Modul math bietet eine einfache Methode, um eine Zahl in Python aufzurunden. Dabei wird immer auf die nächstgrößere ganze Zahl gerundet. Der folgende Code gibt 4 aus.

# Import the math module to access math.ceil() function
import math
number = 3.14
rounded_up = math.ceil(number)
print(rounded_up)Bereitgestellt von

Die Grundlagen des Aufrundens

Beim Runden werden Ziffern angepasst, um einen Näherungswert zu erhalten. Das vereinfacht Zahlen und macht sie leichter handhabbar. Häufige Anwendungsfälle fürs Aufrunden sind:

• Finanzberechnungen: Aufrunden wird oft genutzt, um konservative Schätzungen sicherzustellen. Beispielsweise kann beim Berechnen von Zinsen oder Steuern das Aufrunden auf den nächsten Cent verhindern, dass Werte unterschätzt werden.
• Datenanalyse und Statistik: Berichte folgen oft festen Konventionen, etwa beim Beschriften von Konfidenzintervallen und beim Melden von p‑Werten. Zu viel Präzision lenkt schnell ab. 
• Programmierung und Algorithmen: Rundungsfunktionen steuern die Genauigkeit von Berechnungen, was für Performance und zum Vermeiden von Gleitkommafehlern entscheidend sein kann.

Wichtig: Wenn du Zahlen vor einer Berechnung rundest, veränderst du das Ergebnis — oft stärker, als du erwartest. Weil Aufrunden Näherungswerte erzeugt, summieren sich Fehler, insbesondere bei großen Datensätzen. Rundest du alle Faktoren vor einer Multiplikation auf, fällt das Produkt tendenziell größer aus, da jede Zahl minimal steigt. 

Rundest du hingegen vor einer Division auf, hängt der Effekt davon ab, ob Dividend oder Divisor aufgerundet wird. In jedem Fall kann Aufrunden vor Rechenoperationen die Ergebnisse in überraschender Weise beeinflussen, wenn du nicht aufpasst. 

Methoden zum Aufrunden in Python

Python bietet über das Modul math sowie die Bibliotheken NumPy und pandas verschiedene Wege zum Aufrunden.

Aufrunden mit dem math-Modul

Die Funktion math.ceil() aus math rundet eine Zahl auf die nächstgrößere ganze Zahl. Die Syntax siehst du hier:

# Import the math module to access math.ceil() function
import math
math.ceil(number)Bereitgestellt von

Beim Aufrunden einer positiven Zahl mit math.ceil() erhältst du eine ganze Zahl, die größer ist als der Ausgangswert. Der folgende Code gibt 4 aus.

# Import the math module to access math.ceil() function
import math
number = 3.14
rounded_up = math.ceil(number)
print(rounded_up)Bereitgestellt von

Bei negativen Zahlen liefert math.ceil() entsprechend eine negative ganze Zahl, die größer (also näher an 0) ist als der ursprüngliche Wert. Der folgende Code gibt -3 aus.

# Import the math module to access math.ceil() function
import math
number = -3.14
rounded_up = math.ceil(number)
print(rounded_up)Bereitgestellt von

Aufrunden mit dem decimal-Modul für Präzision

Das Python-Modul decimal eignet sich, um Fließkommazahlen auf exakte Dezimalstellen zu runden. Es ist besonders in Finanzberechnungen wichtig, weil es präzise Dezimalarithmetik ermöglicht.

Du kannst mit dem decimal-Modul Decimal-Objekte aus Strings, Ganzzahlen und Fließkommazahlen erzeugen. Die Erstellung aus Floats ist jedoch wegen möglicher Genauigkeitsprobleme nicht zu empfehlen. Die Beispiele unten zeigen verschiedene Arten, Decimal-Objekte zu erzeugen.

# Import the decimal module to access Decimal function
from decimal import Decimal
d1 = Decimal("3.14159")
print(d1)Bereitgestellt von

# Import the decimal module to access Decimal function
from decimal import Decimal
d3 = Decimal(3.14159)
print(d3)Bereitgestellt von

Das decimal-Modul bietet unter anderem folgende Rundungsarten zum Aufrunden:

• ROUND_UP: Rundet immer von 0 weg.

• ROUND_CEILING: Rundet immer in Richtung positiver Unendlichkeit.

Mit .quantize() kannst du auf die gewünschte Präzision runden. Im Beispiel unten wird mit ROUND_UP auf die nächste ganze Zahl weg von 0 gerundet. Das erreichst du, indem du im Decimal-Aufruf 1 angibst, also auf eine Ganzzahl zielst.

# Import the Decimal class and the ROUND_UP rounding mode from the decimal module
from decimal import Decimal, ROUND_UP

# Create a Decimal object from a string representation of a floating-point number
d = Decimal("-3.14159")

# Round the Decimal object to nearest integer using the ROUND_UP rounding mode
rounded_d_int = d.quantize(Decimal("1"), rounding=ROUND_UP)
print(rounded_d_int) # prints -4Bereitgestellt von

Mit ROUND_CEILING aus dem Decimal-Modul kannst du ebenfalls auf die nächsthöhere ganze Zahl aufrunden.

# Import the Decimal class and the ROUND_CEILING rounding mode from the decimal module
from decimal import Decimal, ROUND_CEILING

# Create a Decimal object from a string representation of a floating-point number
d = Decimal("-3.14159")

# Round the Decimal object to nearest integer using ROUND_CEILING rounding mode
rounded_d_int = d.quantize(Decimal("1"), rounding=ROUND_CEILING)
print(rounded_d_int) # prints -3Bereitgestellt von

Arrays mit NumPy aufrunden

NumPy ist eine leistungsstarke Bibliothek für Operationen auf großen Arrays und Matrizen — unverzichtbar in der Data Science dank Effizienz und komfortabler Berechnungen. Eine der bereitgestellten Operationen ist das Aufrunden. Mit np.ceil() rundest du die Elemente eines Arrays auf die nächstgrößere ganze Zahl. Die Syntax ist unkompliziert:

np.ceil(array)Bereitgestellt von

Das folgende Beispiel zeigt, wie du np.ceil() auf ein Array anwendest.

# Import the numpy module and alias it as np for convenience
import numpy as np

# Create a numpy array with floating-point numbers
array = np.array([3.14, 2.72, 1.61])

# Apply the ceiling function to each element in the numpy array, rounding each number up to the nearest integer
rounded_up_array = np.ceil(array)
print(rounded_up_array) # 4, 3, 2Bereitgestellt von

Vergleich in Kürze

Unter Rundungsbias versteht man die Verzerrung numerischer Werte durch das Runden. Sie entsteht, weil beim Runden ein Wert auf einen größeren oder kleineren Näherungswert angepasst wird. Dadurch können Präzision und Genauigkeit sinken — besonders in Statistik und Finanzberechnungen.

Runden „half up“

Beim Half‑Up‑Runden wird eine Zahl aufgerundet, wenn sie genau in der Mitte zwischen zwei möglichen Werten liegt. Beispiel: 2,5 wird zu 3. Der Vorteil: leicht verständlich und deckt sich mit dem, was in der Schule meist gelehrt wird. Im folgenden Code erstellen wir eine Funktion, die prüft, ob der Dezimalteil genau 0,5 ist; dann runden wir auf, sonst ab.

# Create a function to check if a decimal is exactly 0.5 and round up if true
def round_half_up(n):
    if n - int(n) == 0.5:
        return int(n) + 1
    return round(n)
# Example usage
example_number = 2.5
rounded_number = round_half_up(example_number)
print(rounded_number)Bereitgestellt von

Runden „half to even“ (Banker’s Rounding)

Beim Half‑to‑Even‑Runden, auch Banker’s Rounding, wird ein Wert, der genau zwischen zwei ganzen Zahlen liegt, auf die nächstgelegene gerade Zahl gerundet. So werden systematische Auf‑ oder Abrundungen ausgeglichen.

Wenn du das zweite Argument weglässt, rundet die eingebaute Funktion round standardmäßig nach Half to Even.

# Python round() method to round half to even
print(round(2.5)) # 2
print(round(3.5)) # 4
print(round(-2.5)) # -2Bereitgestellt von

Fazit

Aufrunden ist eine wichtige Technik in der Programmierung, weil numerische Werte dadurch einfacher zu verarbeiten sind. Auch in Statistik und Finanzen ist es zentral, um Zahlen lesbarer zu machen und korrekt zu interpretieren. Lerne die verschiedenen Rundungsverfahren kennen und wähle je nach Aufgabe das passende. 

Als Data Analyst ermutige ich dich, die verschiedenen Aufrundungsmethoden praktisch auszuprobieren. Ich empfehle dir die Skill Tracks Python Fundamentals und Python Programming, um deine Programmierkompetenzen auszubauen. Im Python Developer Career Track lernst du fortgeschrittene Python-Skills, mit denen du dich von anderen Entwickler:innen abhebst. Wenn du dich außerdem für die inneren Abläufe von Ganzzahlen in Python interessierst, lies unser Tutorial zu Pythons maximalem Integer-Wert.