Why Does 0.1 + 0.2 Not Equal 0.3 in Python?

Open Python and type this:

print(0.1 + 0.2) 

You'd expect 0.3. Python gives you this:

0.30000000000000004 

And it gets stranger:

print(0.1 + 0.2 == 0.3) 

False 

If you're learning to code, this is the moment you start wondering whether you broke something. You didn't. Python is doing exactly what it was designed to do, and so are JavaScript, Java, C# and almost every other language. Try 0.1 + 0.2 in your browser's console and you'll get the same 0.30000000000000004.

Let's look at why, and what to do about it.

Computers store numbers in binary

You count in base 10: every digit is a number of ones, tens, hundreds, and after the decimal point, tenths, hundredths and so on.

Computers count in base 2 (binary). After the "binary point" they only have halves, quarters, eighths, sixteenths…

Some numbers fit perfectly into that system:

• 0.5 is one half → exact
• 0.25 is one quarter → exact
• 0.75 is a half plus a quarter → exact

But 0.1 (one tenth) can't be built from halves, quarters and eighths. In binary it's an endless repeating pattern:

0.0001100110011001100110011... 

The same problem you already know: 1/3

You've seen this in base 10. Try writing one third as a decimal:

0.3333333333... 

The threes never stop. At some point you have to cut it off, and the number you wrote down is almost one third, but not exactly.

The computer has the same problem with 0.1, just in binary. It has a fixed amount of space for each number (64 bits), so it stores the closest value it can fit. You can see the number Python actually stored:

from decimal import Decimal print(Decimal(0.1)) 

0.1000000000000000055511151231257827021181583404541015625 

So 0.1 is really a tiny bit more than 0.1. The same goes for 0.2. Add two slightly-off numbers and the tiny errors add up. That's where the extra ...04 comes from.

It's not only 0.1 + 0.2:

print(0.1 + 0.7) 

0.7999999999999999 

Why print(0.1) still shows 0.1

If 0.1 is stored as 0.1000000000000000055..., why does print(0.1) show 0.1?

Python is being helpful. When it prints a float, it shows the shortest number that maps back to the same stored value. For 0.1, that's simply 0.1. But after the addition, the result lands on a slightly different stored value, and the shortest way to write that one is 0.30000000000000004.

How to fix it

1. Round when you display a result

If you only need to show the number, round it:

total = 0.1 + 0.2 print(round(total, 2)) print(f"{total:.2f}") 

0.3 0.30 

2. Never compare floats with ==

This is the real lesson. Instead of asking "are these exactly equal?", ask "are these close enough?":

import math print(math.isclose(0.1 + 0.2, 0.3)) 

True 

math.isclose() lets a tiny difference through, which is exactly what you want when working with decimals.

3. Use Decimal when every cent matters

For money and other places where you need exact decimal math, use the decimal module. Pass the numbers in as strings:

from decimal import Decimal print(Decimal("0.1") + Decimal("0.2")) 

0.3 

Strings matter here. Decimal(0.1) would copy the already-imprecise float, and you'd be back to 0.1000000000000000055....

One more surprise: round() isn't magic either

Now that you know the trick, this one makes sense:

print(round(2.675, 2)) 

2.67 

You'd expect 2.68. But 2.675 is stored as something like 2.67499999..., so it rounds down. Same cause, different symptom.

Quick summary

Try it yourself

Reading this is one thing. The rule really sticks after you hit the bug yourself. Open Python and try:

1. print(0.1 + 0.2 == 0.3). Predict the answer first.
2. Find another pair of decimals that doesn't add up cleanly.
3. Fix the comparison with math.isclose().

Next time Python shows you an error instead of a strange number, here's how to read it: How to Read an Error Message: A 3-Step Method for Python, Java, JavaScript and SQL

This article was first published on the Craftstack Academy blog. It was written with the help of AI, and every code example was run in Python 3.13 before publishing.