Float precision and rounding

Imagine a café till that adds a 0.10 SAR sugar sachet to a 0.20 SAR paper cup and prints the total. You expect 0.3. Python prints 0.30000000000000004. Nothing is broken: this is how computers store decimal numbers, and every language that uses floats (JavaScript, Java, C, Excel internally) does the same.

As soon as your programs handle prices, measurements or averages, you need to know where these tiny errors come from and how to keep them out of what people see.

Why it happens

A float is stored in binary (base 2) using a fixed number of bits. Some fractions fit neatly in binary: 0.5 is one half, 0.25 is one quarter, so they are stored exactly. But 0.1 is one tenth, and one tenth has no exact binary form — in the same way that one third has no exact decimal form (0.3333… goes on forever).

So Python stores the closest float it can to 0.1. That value is off by about 0.00000000000000000555. Usually Python hides this when printing, but when you add two slightly-off values the error can become big enough to show.

Key ideas:

• The error is tiny (around the 16th or 17th significant digit) — fine for physics, averages and percentages.
• It is not random: the same calculation always gives the same result.
• It matters most when you display values or need exact money totals.

Rounding with round()

round(number, ndigits) returns the number rounded to ndigits decimal places. With no second argument it rounds to a whole number and returns an int.

round(22.9885, 2)   # 22.99
round(7.6)          # 8   (an int)
round(1234.5678, 1) # 1234.6

Two behaviours surprise people:

1. Halfway values go to the even neighbour. round(2.5) is 2 and round(3.5) is 4. This is called banker's rounding; it avoids always pushing totals upwards when many halves are rounded.
2. Some "halfway" values aren't really halfway. round(2.675, 2) gives 2.67, because the float stored for 2.675 is actually a hair below 2.675.

Showing money: round for calculations, format for display

round(11.5, 2) is still 11.5 — a float has no idea you wanted two decimals. To display exactly two decimal places, use a format specification inside an f-string:

price = 11.5
print(f"{price:.2f} SAR")   # 11.50 SAR

:.2f means "fixed-point, 2 digits after the point". It also rounds for display, so f"{0.1 + 0.2:.2f}" shows 0.30. You'll learn many more format codes in f-strings and formatting; for now :.2f is the one you need.

A good habit: round() the values you store (so later calculations use clean amounts) and format with :.2f when you print.

Counting in whole halalas

One SAR is 100 halalas. Many payment systems store money as a whole number of the smallest unit, because integers are always exact. Converting looks like "multiply by 100", but there's a trap:

int(19.99 * 100)    # 1998  — a halala has gone missing!
round(19.99 * 100)  # 1999

19.99 * 100 is 1998.9999999999998, and int() chops off everything after the point instead of rounding. Use round() whenever you turn a float amount into whole units.

When to reach for Decimal

The decimal module stores numbers in base 10, so 0.1 really is 0.1. Create a Decimal from a string, not from a float (a float already carries the error):

Use Decimal for accounting software, invoices that must balance to the halala, and anything audited. For everyday calculations — averages, measurements, percentages — floats with round() and :.2f are perfectly fine, and that's what the rest of this track uses.