When you write Python programs that deal with money, measurements, or statistics, you'll run into situations where you need to python round number values to make them cleaner and more usable. A raw float like 19.999999999999996 is technically accurate but completely impractical to display or compare against. Python gives you several tools to handle this — each with its own behavior worth understanding. This guide walks through all of them with practical examples, so you know exactly which tool to reach for in any situation.
The built-in round() function is Python's most direct way to round a number. You pass it a number and it gives you back a rounded version. No imports needed — it is always available.
number_a = 7.6
number_b = 7.3
print(round(number_a))
print(round(number_b))
8
7
When you call round() with only one argument, Python rounds the value to the nearest whole integer. Numbers with a decimal portion above .5 go up, and those below .5 go down. This is the standard rounding most people learned in school, and it works exactly as you would expect for everyday use.
The function works with any numeric type. Passing a plain integer returns that integer unchanged, which is harmless and sometimes useful when you are writing functions that need to handle both integers and floats without branching.
The real flexibility of the python round number approach comes when you supply a second argument: the number of decimal places you want to keep. This is the most common use case for rounding floats in Python.
price = 19.987654
temperature = 98.61872
pi_approx = 3.141592653589793
print(round(price, 2))
print(round(temperature, 1))
print(round(pi_approx, 4))
19.99
98.6
3.1416
The second argument controls how many digits survive after the decimal point. Two is the standard for currency, one is common for measurements, and four or more is typical when approximating mathematical constants.
You can also pass a negative number as the second argument to round to the left of the decimal point — useful when working with large numbers and you want to express them to the nearest ten, hundred, or thousand.
population = 1_482_315
score = 876
print(round(population, -3))
print(round(score, -2))
1482000
900
Passing -3 tells Python to round to the nearest thousand. Passing -2 rounds to the nearest hundred. This technique is useful for summary statistics, reporting dashboards, and anywhere you want to reduce noisy precision in large values.
This is the behavior that catches many beginners off guard. Python does not always round 0.5 upward. Instead, Python uses a strategy called banker's rounding, also known as round-half-to-even. When a value is exactly halfway between two choices, Python rounds to whichever side is even.
print(round(0.5))
print(round(1.5))
print(round(2.5))
print(round(3.5))
print(round(4.5))
0
2
2
4
4
So 0.5 rounds to 0 (even), 1.5 rounds to 2 (even), 2.5 rounds to 2 (even), and 3.5 rounds to 4 (even). This is defined by the IEEE 754 floating-point standard and is the statistically preferred method for large datasets because it prevents cumulative drift. When you always round 0.5 upward, your totals gradually inflate over thousands of operations. Banker's rounding distributes those ties evenly in both directions, keeping your aggregate results more accurate over time.
If you are building financial software that requires traditional round-half-up behavior, the Decimal module covered later in this guide handles that explicitly.
Sometimes the goal is not to round to the nearest value but to always move downward to the nearest integer, no matter what the decimal portion looks like. That is exactly what math.floor() does.
Think of it like the floors of a building: no matter how high you are within one story, you always land on the lower floor.
import math
values = [3.1, 3.9, -3.1, -3.9, 7.0]
for v in values:
print(f"math.floor({v}) = {math.floor(v)}")
math.floor(3.1) = 3
math.floor(3.9) = 3
math.floor(-3.1) = -4
math.floor(-3.9) = -4
math.floor(7.0) = 7
Pay close attention to the negative numbers. For -3.1, the floor is -4, not -3. In mathematical terms, floor always moves toward negative infinity, not toward zero. This trips up a lot of beginners who expect floor to just chop off the decimal.
Floor is commonly used in grid-based games to convert a float coordinate into a tile index, in scheduling systems to calculate completed intervals, and anywhere you need to know how many whole units fit inside a value.
The counterpart to floor is math.ceil(), which always rounds upward to the next integer. It mirrors floor exactly, but in the opposite direction.
import math
values = [3.1, 3.9, -3.1, -3.9, 5.0]
for v in values:
print(f"math.ceil({v}) = {math.ceil(v)}")
math.ceil(3.1) = 4
math.ceil(3.9) = 4
math.ceil(-3.1) = -3
math.ceil(-3.9) = -3
math.ceil(5.0) = 5
For negative numbers, math.ceil(-3.1) gives -3 because -3 is higher than -3.1 on the number line. Ceiling always moves toward positive infinity.
A classic real-world use: you have 25 students and need to form groups of 4. How many groups do you need? math.ceil(25 / 4) gives 7 — because you need that last partial group even though it only has one student.
Truncation is different from both floor and ceiling. math.trunc() simply removes the decimal portion entirely and returns whatever integer remains, always moving toward zero regardless of sign.
import math
print(math.trunc(7.9))
print(math.trunc(7.1))
print(math.trunc(-7.9))
print(math.trunc(-7.1))
7
7
-7
-7
Unlike floor, which moves toward negative infinity, trunc always moves toward zero. For positive numbers these produce the same result, but for negatives the difference is clear: math.trunc(-7.9) gives -7, while math.floor(-7.9) would give -8.
Python's built-in int() function behaves identically to trunc when converting floats — it drops the decimal with no rounding logic applied.
Floating-point numbers carry a well-known limitation in all programming languages, not just Python. Because computers store floats in binary, numbers like 0.1 or 2.675 cannot be represented exactly, which causes subtle precision errors that accumulate over calculations.
When you need exact decimal behavior — especially in financial, accounting, or compliance contexts — the decimal module is the right tool. It represents numbers as true decimal values, not binary approximations.
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
amount = Decimal("2.675")
rounded_up = amount.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
print(f"ROUND_HALF_UP: {rounded_up}")
rounded_even = amount.quantize(Decimal("0.01"), rounding=ROUND_HALF_EVEN)
print(f"ROUND_HALF_EVEN: {rounded_even}")
ROUND_HALF_UP: 2.68
ROUND_HALF_EVEN: 2.68
Notice that Decimal is initialized with a string — "2.675" rather than the float 2.675. If you pass a float, you inherit the float's existing imprecision before Decimal even starts. Always use strings when precision matters.
The quantize() method defines the target precision using a Decimal pattern — "0.01" means round to two decimal places. The rounding parameter lets you choose from named strategies. ROUND_HALF_UP gives you traditional school rounding where 0.5 always goes up, which is often required by financial regulations. ROUND_HALF_EVEN is Python's default banker's rounding.
Sometimes you do not need to store a rounded value — you just need to display one. Python's f-strings support format specifiers that control how a number appears in output without modifying the underlying variable.
pi = 3.141592653589793
price = 4.5
large_num = 1234567.891
print(f"Pi to 2 places: {pi:.2f}")
print(f"Pi to 4 places: {pi:.4f}")
print(f"Price formatted: ${price:.2f}")
print(f"Large number: {large_num:,.2f}")
Pi to 2 places: 3.14
Pi to 4 places: 3.1416
Price formatted: $4.50
Large number: 1,234,567.89
The :.2f format specifier means "fixed-point float with 2 decimal places." Adding a comma before the dot (like :,.2f) also inserts thousands separators, which is ideal for displaying currency or large numeric data in user interfaces.
The important distinction here is that the number in memory stays unchanged. F-string formatting is purely about how the value appears as a string, making it the right choice for output and reports where you want clean display without affecting the precision used in calculations.
This example brings all the tools together in a realistic scenario — a receipt calculator that uses round() for intermediate values, math.ceil() for item counts, Decimal for the final financial total, and f-string formatting for clean output.
import math
from decimal import Decimal, ROUND_HALF_UP
def calculate_receipt(items):
subtotal = sum(price * qty for price, qty in items)
tax_rate = 0.0875
tax = subtotal * tax_rate
subtotal_rounded = round(subtotal, 2)
tax_rounded = round(tax, 2)
raw_total = subtotal_rounded + tax_rounded
total_decimal = Decimal(str(raw_total)).quantize(
Decimal("0.01"), rounding=ROUND_HALF_UP
)
total_items = math.ceil(sum(qty for _, qty in items))
print("======= RECEIPT =======")
print(f"Items purchased : {total_items}")
print(f"Subtotal : ${subtotal_rounded:.2f}")
print(f"Tax (8.75%) : ${tax_rounded:.2f}")
print(f"Total Due : ${total_decimal}")
print("=======================")
return float(total_decimal)
order = [
(12.99, 2),
(4.49, 3),
(0.99, 7),
(24.95, 1),
]
final_total = calculate_receipt(order)
print(f"\nCharge to card: ${round(final_total, 2):.2f}")
Output
======= RECEIPT =======
Items purchased : 13
Subtotal : $64.37
Tax (8.75%) : $5.63
Total Due : $70.00
=======================
Charge to card: $70.00
Each rounding tool is playing a specific role here. The built-in round() handles intermediate subtotal and tax values, keeping them to two decimal places before addition. math.ceil() counts the total units across all line items, bumping any partial quantities up to a whole number. Decimal with ROUND_HALF_UP ensures the final charge meets the kind of financial precision requirements you would find in a real payment system. And f-string formatting presents every number cleanly with exactly two decimal places — regardless of what the raw float looks like internally.