Python, de zéro

La précision des nombres décimaux est un souci lié non pas au langage Python, mais à l’informatique dans son ensemble.

Ce souci est directement issu de la méthode employée par un processeur pour convertir un nombre décimal en binaire.

En effet, tout nombre décimal est découpé en sommes de fractions de 1/2ⁿ (n montant de façon naturelle). Ainsi 0.8125 est en fait converti en 1/2¹ + 1/2² + 1/2⁴, ce qui donne 0.1101 en binaire.

Mais cette méthode ne fonctionne en réalité avec exactitude que sur très peu de nombres décimaux et donc pour beaucoup d’autres, leur fait perdre de la précision. Par exemple, 0.6 sera un tout petit peu plus grand que 1/2¹ + 1/2⁴ + 1/2^5, mais un tout petit peu plus petit que 1/2¹ + 1/2⁴ + 1/2⁵ + 1/2⁶ et un tout petit peu plus grand que 1/2¹ + 1/2⁴ + 1/2⁵ + 1/2⁸ + 1/2^9, mais un tout petit peu plus petit que 1/2¹ + 1/2⁴ + 1/2⁵ + 1/2⁸+ 1/2⁹+ 1/2^10, etc. Et aucune somme de fractions de 1/2ⁿ (n entier) ne pourra tomber exactement sur 0.6.

Python peut arriver à compenser en général l’erreur d’imprécision à l’affichage.

>>> 0.6
0.6

Mais cela n’est pas garanti dans toutes les situations…

>>> 0.6/3
0.19999999999999998
>>> 0.2*3
0.60000000000000001
>>>

… ce qui peut causer des soucis si la précision d’un nombre ou des calculs sur ce nombre est impérative au chiffre près (gestion de comptes bancaires par exemple).

Python possède cependant un module decimal offrant des outils de gestion et de manipulation des nombres décimaux avec une précision absolue. Le principe de ce module est de travailler le nombre décimal chiffre par chiffre, comme à l’école primaire. Ainsi 0.2*3 sera calculé chiffre par chiffre ('0', '.', '2') multiplié par '3' (avec la retenue si nécessaire, etc.).

>>> import decimal
>>> decimal.Decimal("0.6") / 3
Decimal('0.2')
>>> decimal.Decimal("0.2") * 3
Decimal('0.6')
>>>

Cela se paye toutefois en retour par un temps de calcul très important. Tout comme pour le principe d’incertitude de Heinsenberg, on ne peut pas avoir à la fois la précision et la vitesse.