Floating-point arithmetic in Python, like in most programming languages, is inherently imprecise due to the way numbers are represented in binary. The IEEE 754 standard, which Python follows, encodes decimal numbers as binary fractions, but many decimal fractions don’t have exact binary equivalents.
Take the classic example:
>>> 0.1 + 0.2 == 0.3 False
At first glance, this looks like a bug, but it’s actually a consequence of how floating-point numbers work under the hood. 0.1 and 0.2 are stored as approximations, so when you add them, the result is something like 0.30000000000000004.
If you print it out with the repr() function or just the interactive shell, you’ll see:
>>> 0.1 + 0.2 0.30000000000000004
This subtle discrepancy can cause havoc in programs that depend on exact decimal values, such as financial calculations or measurements.
Python’s float is a double-precision 64-bit binary format, which gives around 15-17 digits of precision. That’s usually enough, but when your numbers require exact decimal representation, you need to be aware of these pitfalls.
One way to think about it’s that floating-point numbers are stored as:
(-1)^sign × mantissa × 2^exponent
Since 10-based decimals don’t always map cleanly to base-2, they get rounded to the nearest representable binary fraction.
If you want to see the internal representation, you can use the decimal module’s Decimal.from_float() method:
>>> from decimal import Decimal
>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
This shows exactly how 0.1 is stored internally.
So, what do you do when you need to compare floats or perform precise arithmetic? The first step is to avoid direct equality checks:
import math
def almost_equal(a, b, tol=1e-9):
return abs(a - b) < tol
print(almost_equal(0.1 + 0.2, 0.3)) # True
By setting a tolerance, you treat numbers as equal if they’re close enough, which is often enough for many applications.
But when you’re adding a long list of floats, these tiny errors accumulate and can become significant. That’s where Python’s built-in tools come into play.
For now, keep in mind that floating-point numbers are a tradeoff between range and precision. They give you the ability to represent very large and very small numbers efficiently, but exact decimal arithmetic is not one of their strengths.
Anker Cable [2 Pack 3ft], USB A to USB C Cable for iPhone 17 Series,Samsung Galaxy S10 S10+, LG V30, Beats Fit Pro and More (Black).
$8.99 (as of July 17, 2026 15:16 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)Using math.fsum for precise calculations
For precise calculations involving floating-point numbers, Python provides the math.fsum() function, which is specifically designed to mitigate the issues of floating-point arithmetic. Unlike the standard sum function, math.fsum() maintains a higher level of precision by using a more sophisticated algorithm to perform the addition.
Here’s a quick comparison. If you sum a large list of floats using the built-in sum() function, you might encounter inaccuracies due to the way floating-point addition works:
numbers = [0.1] * 10**6 print(sum(numbers)) # This may not equal 1000000.0
However, if you use math.fsum(), you can achieve a more accurate result:
import math numbers = [0.1] * 10**6 print(math.fsum(numbers)) # This should equal 1000000.0
The reason math.fsum() is more reliable is that it employs a technique called Kahan summation, which compensates for floating-point errors that occur during addition. This helps to reduce the cumulative error that can arise when adding many small numbers together.
For practical applications, this means that if you’re dealing with financial data, scientific measurements, or any scenario where precision is critical, you should opt for math.fsum() over the regular sum().
Additionally, when handling mixed types, such as a combination of integers and floats, math.fsum() still provides accurate results:
mixed_numbers = [0.1, 1, 2.5, 3.75] print(math.fsum(mixed_numbers)) # This will yield a precise result
In summary, when working with floating-point numbers in Python, especially in scenarios involving extensive calculations, using math.fsum() can significantly enhance the precision of your results and help avoid the pitfalls associated with floating-point arithmetic.
