When working with money in Python, you might think using the float data type is the obvious choice. After all, money has decimal places, and floats handle decimals. Simple, right?
Actually, floats don't store true decimal values — they store approximations instead.
Python's float follows the IEEE 754 standard for binary floating-point numbers. This means many decimal values can't be stored exactly in binary format. While this works fine for scientific work, it's dangerous when handling financial data where every penny matters.
Here's a quick example:
print(0.1 + 0.2)
Output:
0.30000000000000004
That extra .00000000000000004 looks tiny, but in a financial application, these errors pile up quickly.
The Problems with Using Floats for Money
Let me explain why using float for financial calculations can cause serious issues:
Small Errors Get Bigger:
When you repeatedly add, subtract, or multiply float values, the tiny mistakes grow larger. Think about calculating interest across millions of accounts — you're literally losing money to math errors.
Comparing Values Becomes Unreliable:
Testing if two float amounts are equal often gives wrong results because of invisible precision problems. This leads to broken logic in payment systems or accounting software.
Accounting Reviews Turn into Disasters:
Financial regulators and accountants need exact numbers in your books. Float calculations won't pass their strict standards.
Problems Hide Until It's Too Late:
Here's the worst part: floats won't warn you about precision problems. Everything seems fine until an accountant finds your balance sheet doesn't add up.
Better Ways to Handle Money in Python
Let's look at the right tools for working with financial data.
1. Using the decimal Module
Python includes decimal.Decimal, which is designed for exact decimal math. It stores numbers as real decimal values, not binary estimates.
from decimal import Decimal
unit_cost = Decimal("1.25")
total_cost = unit_cost + Decimal("2.75")
print(total_cost)
Output:
4.00
No rounding errors. Just the exact answer you expect.
Best for:
-
Online stores, marketplaces, e-commerce applications
-
Bank and finance software
-
Any system where financial accuracy is legally required
2. Store Money as Integer Cents
Many financial systems use this trick: save money values as whole numbers representing the smallest currency unit (such as cents).
item_price_cents = 150 # $1.50
total_value_cents = item_price_cents * 4
print(total_value_cents) # 600 cents = $6.00
Benefits:
-
Zero rounding problems
-
Simple database storage
Best for:
- Applications using standard decimal places (like 2 digits for dollars)
3. Money-Specific Libraries
When dealing with complex financial features (multiple currencies, exchange rates, special rounding), these libraries can help:
moneyed– handles currency typesforex-python– manages currency conversionbabel– formats money for different countries
These tools go beyond basic numbers to handle real business needs.
A Practical Demonstration: Calculating Interest Accurately
Picture a bank app computing monthly interest with floats:
account_funds = 800.00
rate_of_growth = 0.05
for _ in range(12):
account_funds += account_funds * rate_of_growth
print(account_funds)
Because of float precision issues, your final account could be several cents off from the correct mathematical answer.
Here's the same calculation using Decimal:
from decimal import Decimal, getcontext
getcontext().prec = 28 # set high precision
account_funds = Decimal("800.00")
rate_of_growth = Decimal("0.05")
for _ in range(12):
account_funds += account_funds * rate_of_growth
print(account_funds)
This gives you the precise amount with no sneaky errors.
Demonstrating Precision with Floats vs. Decimals
This example perfectly illustrates why floats fail in financial calculations. We're adding 10 cents one hundred times — mathematically, this should equal exactly $10.00. It's the kind of operation that happens constantly in real financial systems: summing up transaction fees, calculating batch payments, or aggregating small charges.
With floats, the number 0.10 cannot be represented exactly in binary. Just like how 1/3 becomes 0.333... in decimal notation and never quite reaches the true value, 0.10 becomes an infinitely repeating binary fraction. Python's float stores the closest possible approximation, but it's not exactly 0.10 — it's actually something like 0.1000000000000000055511151231257827021181583404541015625.
Each time we add this slightly-off value, the error compounds. After 100 additions, instead of $10.00, we get $9.99999999999998. The missing two-hundred-thousandths of a cent might seem negligible, but imagine this happening across thousands of transactions daily. Worse yet, when we try to check if our total equals $10.00, Python tells us it doesn't — breaking any conditional logic that depends on exact values.
The Decimal type solves this by storing numbers exactly as we write them in base-10. When we create Decimal("0.10"), it stores precisely 0.10 with no approximation. Adding it 100 times gives us exactly 10.00, just like doing the math by hand. This is why Decimal is essential for financial work — it thinks about numbers the same way humans and accounting systems do.
from decimal import Decimal
float_total = 0.0
for _ in range(100):
float_total += 0.10
decimal_total = Decimal("0.0")
for _ in range(100):
decimal_total += Decimal("0.10")
print("Float:", float_total)
print("Decimal:", decimal_total)
print("Float ok? ", float_total == 10.00)
Output:
Float: 9.99999999999998
Decimal: 10.00
Float ok? False
Conclusion
Money represents trust, not just numbers. When someone deposits $250, they need to see exactly $250 — not $249.999999 or $250.000001. While Python's float works well for science or computer graphics, it will fail you in financial software. Use Decimal when you need accuracy, or integers when you need speed.