Python et l'arithmetique de flottants

Apres etre tombe sur cet exemple en surfant paisiblement sur le web, chacun comprendra ma stupeur a la vue de ceci:

1
2
3
4
5
6
7
8

>>> 0.3 == 0.2 + 0.1
False
>>> 0.2 + 0.1
0.30000000000000004
>>> 0.3 - 0.2 == 0.1
False
>>> 0.3 - 0.2
0.09999999999999998

Aucune explication ne l'accompagnant, j'ai decide d'en faire part a mes amis les zestueux, qui, j'en suis convaincu, sauront m'eclairer de leur savoir.

J'aurais voulu savoir quel est la representation precise (si possible ) d'un float python en memoire. Est-t'elle la meme qu'un double ou qu'un float en C?

Je pose la question car supposant que c'etait le cas, en me basant sur ca, je n'arrive pas a tomber sur un resultat qui s'en rapprocherait en C avec une representation de type float ou double.

Ce que tu présente est une conséquence de l'imprécision de la norme IEEE 754 utilisé dans nos processeurs pour le calcul flottant.

Le problème de base est que tous les nombres flottants ne sont pas représentable. Des imprécisions sont introduites. Donc en faisant des opérations, ça donne pas forcément le même résultat.

C'est exactement le même problème dans la majorité des langages. Je me trompe peut être mais je pense que tu aura le même comportement en C (en désactivant les optimisations du compilateurs qui pourrait cacher des choses).

C'est d'ailleurs pour ça que normalement pour comparer des flottants on préfères toujours vérifier que la valeur absolus de la différence est "très proche de 0" (la différence est toute petite).

Salut,

Yep, c'est pareil en C avec ou sans optimisations. En revanche, la comparaison est vraie avec des float.

Effectivement, 0.2 + 0.1 en C me donne quelque chose comme ceci: 0.300000000000000044408920985006....

Je vais essayer de retrouver ce resultat sur papier pour que les choses soient claires.

En vrai on devrait toujours regarder la Doc, celle de python à une page dédié au problème

Pour préciser (un tout petit peu) ce que les autres ont dit 0.1 possède un développement infini et n'est donc pas représentable en machine.
De manière générale le calcul sur des flottants et un test d'égalité c'est comme sauter en parachute sans vérifier que tu en as pris un avant de monter dans l'avion.

À noter aussi que la fonction isclose a été introduite en Python 3.5 pour les comparaisons entre flottants.

Apres coup ma question etait vraiment tres bete.

Je vous remercie a tous et retourne manger ma clementine, chose que je n'aurais jamais du cesser de faire en voyant cet exemple

Lesson learned: toujours finir sa clementine avant de poser une question…

Apres coup ma question etait vraiment tres bete.

Non. C'est un problème classique et trop souvent ignoré. C'est pas pour rien que Python a une page de doc dessus.

En realite, Python etant un langage de script haut niveau, bizarrement, je ne m'attendais pas a retrouver ce type de probleme sur ce type de langage. Et je ne sais pour quelle raison absurde, j'aurais pense que Python gererait ces problemes a la source.

Je veux dire, que la fonction isclose citee par entwanne serait en quelque sortes "inclue" dans l'operateur == a la comparaison de deux floats, sans avoir besoin de l'appeller explicitement.

Tu peux trouver des cours à la fac et en école d'ingénieur sur le sujet tellement c'est important.

Python est pas du genre à te cacher les problèmes de cette façon. Si ils voulaient vraiment te les cacher, tout comme les int "augmentent" tout seul, j'imagine que les flottant serait plutot une forme exact (type ce qui est dispo dans fractions ou decimal) mais ce serait catastrophique pour les perfs.

+1 : Python est essentiellement haut niveau, mais te permet de descendre jusqu'aux interactions directes avec le noyau (donc les appels système). Sans rien te cacher si tu ne le souhaites pas.

C'est un des trucs que j'apprécie le plus dans ce langage : sa limite la plus basse n'est pas arbitraire, c'est la frontière du userland.