Pourquoi 0,1 + 0,2 ne fait pas 0,3
Dans presque tous les langages, 0,1 + 0,2 donne 0.30000000000000004. Ce n'est pas un bug : c'est une limite du binaire, comme 1/3 en décimal.
55s · 22 juillet 2026 · 2 min de lecture
En bref
Les ordinateurs stockent les nombres à virgule au format IEEE 754, en binaire. Or 0,1 et 0,2 n'ont pas d'écriture binaire exacte — comme 1/3 n'a pas d'écriture décimale finie. La machine arrondit, les erreurs minuscules s'additionnent, et 0,1 + 0,2 donne 0.30000000000000004. Conséquence : on ne compare jamais deux flottants avec une égalité stricte.
Le résultat qui surprend
Tape 0,1 + 0,2 dans Python, JavaScript, Java ou C : tu n'obtiens pas 0,3, mais 0.30000000000000004. Le même résultat partout, parce que ces langages suivent tous la même norme : IEEE 754, le format binaire des nombres à virgule. Ce n'est pas un bug — c'est le comportement attendu.
Le vrai coupable : le binaire
En décimal, un tiers s'écrit 0,333… à l'infini : impossible à noter exactement avec un nombre fini de chiffres. En binaire, c'est 0,1 qui pose ce problème — son écriture commence par 0,00011001100110011… et ne s'arrête jamais. Comme la machine n'a qu'un nombre fini de bits (64 en double précision), elle arrondit. 0,1 et 0,2 sont donc déjà légèrement faux avant même l'addition ; en les ajoutant, les écarts se combinent.
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False
>>> abs(0.1 + 0.2 - 0.3) < 1e-9 # comparaison avec une marge
TrueComment l'éviter
La parade dépend du besoin. Pour comparer, on teste si l'écart est plus petit qu'une petite marge (un « epsilon »), jamais avec un égal strict. Pour l'argent, on ne stocke pas des euros à virgule : on compte en centimes, en nombres entiers. Et pour des calculs décimaux exacts, on utilise un type dédié — le module decimal en Python, BigDecimal en Java.
Le réflexe faux
- a == b sur des flottants
- Stocker l'argent en virgule
Le bon
- Comparer avec une marge (epsilon)
- Compter en centimes ou en décimal exact
→ Le flottant est rapide et approché : on l'utilise en connaissance de cause.
À retenir
- →Dans presque tous les langages, 0,1 + 0,2 vaut 0.30000000000000004 (norme IEEE 754).
- →0,1 n'a pas d'écriture binaire finie — comme 1/3 en décimal — donc la machine arrondit.
- →Les arrondis de 0,1 et 0,2 se combinent à l'addition : le résultat tombe à côté de 0,3.
- →Règle : jamais d'égalité stricte sur des flottants ; utiliser une marge, des centimes, ou un type décimal.
Sources · la preuve
- [01] Floating Point Arithmetic: Issues and Limitations Python · docs.python.org Doc officielle : 0,1 inexprimable en binaire, arrondi et comportement IEEE 754.
- [02] The IEEE 754 Format Emory University (CS170) · mathcenter.oxford.emory.edu Structure signe / exposant / mantisse ; arrondi à un nombre fini de bits.
- [03] Why 0.1 + 0.2 != 0.3: A Deep Dive into IEEE 754 larrylu.dev · larrylu.dev Ce n'est pas un bug ; double précision (52 bits de fraction) ; epsilon et module decimal.
- [04] Why 0.1 + 0.2 Doesn't Equal 0.3 in Programming Built In · builtin.com Résultat 0.30000000000000004 ; stockage en double précision sur 64 bits.
