Les nombres flottants (float, double) sont très utilisés en programmation pour représenter les nombres décimaux et les fractions. Mais ils ont des limites de précision qui peuvent provoquer des résultats inattendus si on ne les connaît pas. Comprendre ces limites est essentiel pour éviter les erreurs et écrire un code fiable.

1. Pourquoi les nombres flottants ne sont pas exacts

Les nombres flottants sont stockés en binaire selon la norme IEEE 754. Certaines fractions décimales simples, comme 0.1 ou 0.2, ne peuvent pas être représentées exactement en binaire.

Exemple en Python :

print(0.1 + 0.2) 
# Affiche : 0.30000000000000004

C’est normal et cela ne signifie pas que le langage est défectueux.

2. Les limites des nombres flottants

Float 32 bits : précision ~7 chiffres significatifs

Double 64 bits : précision ~16 chiffres significatifs

Au-delà de cette précision, les nombres sont arrondis automatiquement par l’ordinateur.

💡 Exemple :

x = 1.1234567890123456
y = float(x)
print(y)  # 1.1234567890123457 (perte de précision)

Les grands nombres ou très petits nombres peuvent aussi dépasser la plage autorisée, entraînant inf ou 0.

3. Problèmes courants liés à la précision

Comparaisons directes :

0.1 + 0.2 == 0.3  # False

Accumulation d’erreurs dans des boucles ou des calculs répétés.

Arrondis inattendus lors de l’affichage ou des calculs financiers.

4. Comment gérer ces limites
4.1 Utiliser des types précis si nécessaire

Python : decimal.Decimal

Java : BigDecimal

C# : decimal

Exemple :

from decimal import Decimal

a = Decimal('0.1')
b = Decimal('0.2')
print(a + b)  # Affiche exactement 0.3

4.2 Arrondir ou comparer avec tolérance

Pour éviter les problèmes de comparaison :

import math
math.isclose(0.1 + 0.2, 0.3)  # True

Utiliser round() pour limiter le nombre de décimales :

x = round(0.1 + 0.2, 2)
print(x)  # 0.3

4.3 Éviter les floats pour les valeurs exactes

Pour compter des objets ou manipuler de l’argent, préférez int ou decimal.

5. Bonnes pratiques

Connaître la précision de votre type (float ou double).

Ne jamais comparer directement deux floats pour l’égalité.

Utiliser des types précis pour l’argent ou les calculs critiques.

Arrondir ou utiliser une tolérance lors de calculs répétitifs.