Floating-point surprises and how to handle them

Ask Python for 0.1 + 0.2 and it answers 0.30000000000000004. Nothing is broken: C, Java and almost every other language store such numbers the same way and get the same result. Once you know what a float really holds, the surprises become predictable, and a few habits keep them out of your results.

What a float really stores

On almost every computer, a Python float is an IEEE 754 “double precision” number: a binary fraction with 53 significant bits and an exponent. Binary digits after the point stand for halves, quarters, eighths and so on, so a fraction can be stored exactly only if it is a sum of such pieces, which means its denominator, in lowest terms, is a power of 2. 0.75 is ½ + ¼ and is exact. 0.1 is 1/10, and 10 has a factor of 5, so in binary it never ends: 0.000110011001100… The float keeps the first 53 significant bits and rounds the rest away.

from decimal import Decimal

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(0.5 + 0.25 == 0.75)  # halves and quarters are exact in binary

print(Decimal(0.1))  # the exact value stored for 0.1
print(Decimal(0.2))
print(Decimal(0.3))
print((0.1).as_integer_ratio())  # the same stored value as a fraction
print(2 ** 55)

0.30000000000000004
False
True
0.1000000000000000055511151231257827021181583404541015625
0.200000000000000011102230246251565404236316680908203125
0.299999999999999988897769753748434595763683319091796875
(3602879701896397, 36028797018963968)
36028797018963968

Converting a float to Decimal shows every digit of the value it holds. The float for 0.1 is a little more than 0.1, the one for 0.2 a little more than 0.2, and the one for 0.3 a little less than 0.3. As a fraction, as_integer_ratio() shows the stored 0.1 is 3602879701896397 divided by 2 to the power 55. When Python prints a float it chooses the shortest decimal that would be stored as the same float, which is why print(0.1) shows just 0.1 and the error stays hidden until a calculation pushes it into view.

A closer look: why the sum misses

Between two neighbouring floats there is no other float, so every result has to land on one of them. The sum of the stored 0.1 and 0.2 falls exactly halfway between the two floats nearest 0.3:

import math
from fractions import Fraction

exact_sum = Fraction(0.1) + Fraction(0.2)  # the sum of the two stored values, exactly
below = Fraction(0.3)  # the float that 0.3 is stored as
above = Fraction(math.nextafter(0.3, 1))  # the next float up

print(below < exact_sum < above)
print(exact_sum - below == above - exact_sum)  # exactly halfway
print((0.3).hex(), (0.1 + 0.2).hex())  # the last digits: 3 is odd, 4 is even

True
True
0x1.3333333333333p-2 0x1.3333333333334p-2

On a tie, the hardware rounds to the float whose last binary digit is even, IEEE 754’s default rule and the same “half to even” rule that round() uses. The hexadecimal forms printed above end in 3 and in 4, and the even one is the upper float. 0.3 written in your program is stored as the lower one, the float closest to 0.3. Two different floats, so == says False.

The limits of a float

import sys

print(sys.float_info.max)  # the largest float
print(sys.float_info.max * 10)  # past it: infinity, and no error
try:
    sys.float_info.max ** 2  # ** checks for overflow
except OverflowError:
    print("** raised OverflowError")
print(sys.float_info.epsilon)  # the gap between 1.0 and the next float up
print(2.0 ** 53 + 1 == 2.0 ** 53)  # above 2 ** 53 not every whole number fits
print(float(2 ** 53 + 1))

1.7976931348623157e+308
inf
** raised OverflowError
2.220446049250313e-16
True
9007199254740992.0

• The largest float is about 1.8 × 10³⁰⁸. Beyond it a multiplication gives inf (infinity) without an error, while ** raises OverflowError (the try and except lines catch it, as in the integers lesson): Python checks only some float operations for overflow.
• sys.float_info.epsilon, about 2.2 × 10⁻¹⁶, is the gap between 1.0 and the next float. Every operation can be off by about half that much relative to its result, which is why floats are good for roughly 16 significant digits.
• Whole numbers are exact only up to 2⁵³ (9,007,199,254,740,992). Above it the gaps between floats are wider than 1, so float(2 ** 53 + 1) comes back as 2⁵³. Python’s ints have no such limit, so keep counts and money in ints when you can.

Comparing floats: use math.isclose()

Because a computed float often carries a tiny rounding error, == is the wrong test for one. Ask instead whether two values are close enough:

import math

total = 0.1 + 0.2
print(total == 0.3)
print(math.isclose(total, 0.3))  # within a relative tolerance of 1e-09

balance = 100.0 - 99.9 - 0.1  # should be zero
print(balance)
print(math.isclose(balance, 0.0))  # relative tolerance alone never accepts 0
print(math.isclose(balance, 0.0, abs_tol=1e-9))  # add an absolute tolerance

False
True
-5.689893001203927e-15
False
True

math.isclose(a, b) accepts the two values when their difference is at most rel_tol times the larger of the two in size; the default rel_tol=1e-09 means about nine matching digits, whatever the size of the numbers. Near zero that rule fails: no number except 0 is close to 0 relative to its own size, so the balance, which should be zero but is -5.7 × 10⁻¹⁵, is rejected. Add an absolute tolerance, abs_tol, whenever a value may be zero or nearly so, and choose it from the problem: for an amount in rupees or dollars, such as this balance, 1e-9 is a ten-millionth of a paisa or a cent, far below anything a bill can contain.

math.isclose() follows the IEEE 754 rules for special values: infinity is close only to itself, and NaN (below) is close to nothing, not even to another NaN.

Adding up many floats

Each addition rounds its result, and the small errors can pile up:

import math

total = 0.0
for _ in range(10):
    total += 0.1  # ten additions, each one rounded
print(total)

print(sum([0.1] * 10))  # sum() keeps track of the rounding errors
print(math.fsum([0.1] * 10))

values = [1e16, 1e-16, 1.0]
print(sum(values), math.fsum(values))  # here only fsum() gets it right

0.9999999999999999
1.0
1.0
1e+16 1.0000000000000002e+16

The loop rounds after every step and ends just short of 1.0. sum() keeps track of the rounding errors as it goes (an algorithm called Neumaier summation) and gets exactly 1.0. math.fsum() goes further and tracks several partial sums, so no precision is lost along the way. The last line shows a case where only fsum() is right: the true total is just over 10000000000000001, and the nearest float to that is 1.0000000000000002e+16.

Rounding surprises

from decimal import Decimal

print(round(2.675, 2))  # 2.67, not 2.68
print(Decimal(2.675))  # the value really stored is a little below 2.675
print(f"{2.675:.2f}")  # formatting rounds the stored value too
print(round(0.125, 2))  # 0.125 is exact: a true tie, so half to even

percent = 0.57 * 100
print(percent)
print(int(percent))  # int() drops the fraction: 56
print(round(percent))  # round first: 57

2.67
2.67499999999999982236431605997495353221893310546875
2.67
0.12
56.99999999999999
56
57

round(2.675, 2) gives 2.67, not 2.68, because the float written as 2.675 is really a little below it, so there is no tie to round up. Formatting with :.2f rounds the same stored value and agrees. 0.125, on the other hand, is exactly ⅛, a real tie, and round() sends it to the even neighbour, 0.12.

A common mistake: int() after float arithmetic

0.57 * 100 is 56.99999999999999, and int() drops the fraction, so the result is 56 instead of 57. Percentages, prices in paise or cents and other “convert to a whole number” steps go wrong this way. Use round() instead, which also returns an int.

Infinity, NaN and minus zero

import math

inf = float("inf")
nan = float("nan")  # "not a number"
print(inf > 10 ** 300, -inf < 0)
print(inf - inf, inf * 0)  # no sensible answer: nan
print(nan == nan, nan != nan)  # nan is not equal even to itself
print(math.isnan(nan), math.isinf(inf), math.isfinite(1e308))
print(0.0 == -0.0, math.copysign(1, -0.0))  # equal, but the sign is kept

True True
nan nan
False True
True True True
True -1.0

• float("inf") and -float("inf") are larger and smaller than every finite number.
• nan (“not a number”) is the result of operations with no sensible answer, such as infinity minus infinity. Every comparison with it is False, even nan == nan; only != is True. Test for it with math.isnan(), and for infinity with math.isinf(), or for “an ordinary number” with math.isfinite().
• -0.0 equals 0.0, but it keeps its sign, which math.copysign() can read.

When a float is the wrong type

The standard library has two other number types for work where binary rounding is not acceptable. A later lesson covers both in depth; this is when to reach for each:

from decimal import Decimal
from fractions import Fraction

print(Decimal("0.1") + Decimal("0.2"))  # decimal arithmetic, from strings
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))
print(Decimal(0.1))  # from a float: the float's error comes along

print(Fraction(1, 3) + Fraction(1, 6))  # exact ratios
print(Fraction(1, 3) * 3 == 1)

print(float.from_number(Fraction(1, 4)))  # new in 3.14: numbers only
try:
    float.from_number("3.5")  # float("3.5") would parse the text
except TypeError as error:
    print("TypeError:", error)

0.3
True
0.1000000000000000055511151231257827021181583404541015625
1/2
True
0.25
TypeError: must be real number, not str

Build a Decimal from a string, Decimal("0.1"), or from an int. Decimal(0.1) copies the float exactly, error and all, as the third line of output shows.

Key takeaways

• Floats are binary fractions with 53 significant bits; most decimal fractions, including 0.1, are stored as the nearest such value, so small errors are normal.
• Never compare computed floats with ==. Use math.isclose(), with an abs_tol whenever values can be near zero.
• sum() adds floats accurately since Python 3.12; math.fsum() is the most accurate.
• round(2.675, 2) is 2.67 because of the stored value; use round(), not int(), when you turn a float result into a whole number.
• NaN is not equal to itself: test it with math.isnan().
• Use Decimal, built from strings, for money, and Fraction for exact ratios; keep floats for measurements and science.