Discussion :

[Mr ZEE]

Bonjour,

Je suis débutant et je suis en train de me former au langage Python.
J'utilise sous Linux la version Python 2.7.6

je cherche à comparer 2 valeurs identiques l'une est donnée par l'utilisateur et l'autre est calculée avec la racine carrée de 2.
Voici mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
from math import sqrt
 
a = input("Entrez une valeur: ")
b = 20
c = b * sqrt(2)
 
print "a =", a
print "c =", c
 
if(a == c):
  print "GAGNÉ"
else:
  print a, "est différent de", c

Voici ce que me renvoi ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Entrez une valeur: 28.2842712475
a = 28.2842712475
c = 28.2842712475
28.2842712475 est différent de 28.2842712475

Si je n'utilise pas le module sqrt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
a = input("Entrez une valeur: ")
b = 20.0
d = 2 ** 0.5
c = b * d
 
print "a =", a
print "c =", c
 
if(a == c):
  print "GAGNÉ"
else:
  print a, "est différent de", c

J'ai la même chose.
Je dois me planté quelque part mais franchement je sèche lamentablement.

[dahtah]

Salut,

Comparer des flottants n'est pas aussi simple. Tu dois generalement comparer a une plage de tolerance, du genre (naivement) abs(a - b) <= tolerance.

Python 3.5 offre math.isclose() qui est bien pratique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
>> import math
>>> math.isclose(28.2842712475, 20*math.sqrt(2))
True
>>> math.isclose(28.2842712475, 20*math.sqrt(2), rel_tol=1e-15)
False

Sinon, pour les autres version de python. le code de isclose() est fourni dans la doc: https://docs.python.org/3/library/ma...l#math.isclose

[Laurent 1973]

Ton souci est en effet une erreur classique de débutant en informatique: les nombres réels n'existent pas en faite.

les nombres "réels" en informatique sont en faite une suite de nombres discrétisés.
c'est à dire qu'à 2 nombres décimaux donnés, il n'existe pas une infinité de nombre compris entre eux, mais un nombre fini.
C'est aussi ce qui caractérise l'informatique globalement: il y a toujours une limite (nombre minimal, maximal, précision, taille en mémoire, vitesse d’exécution, ...)

Mais revenons à ton problème, qui n'est pas propre à Python mais bien à tout langage de programmation.
donc, comme l'explique Mr Zee, il est important de ne jamais essayer de vérifier une égalité stricte entre 2 décimaux, quelque soit le langage utilisé.
Au mieux, on vérifie si abs(value1-value2)<1e-10 j'ai mis 1e-10 vu que cela semble être le niveau de précision que tu cherches a avoir.

[Mr ZEE]

Merci beaucoup pour vos réponses.

Laurent 1973 a écrit:

les nombres "réels" en informatique sont en faite une suite de nombres discrétisés.
c'est à dire qu'à 2 nombres décimaux donnés, il n'existe pas une infinité de nombre compris entre eux, mais un nombre fini.
C'est aussi ce qui caractérise l'informatique globalement: il y a toujours une limite (nombre minimal, maximal, précision, taille en mémoire, vitesse d’exécution, ...)

Après des tests avec le module Decimal j'avais encore plus d'interrogation, mais là avec ton explication c'est beaucoup plus clair pour moi.

Laurent 1973 a écrit:

il est important de ne jamais essayer de vérifier une égalité stricte entre 2 décimaux, quelque soit le langage utilisé.
Au mieux, on vérifie si abs(value1-value2)<1e-10 j'ai mis 1e-10 vu que cela semble être le niveau de précision que tu cherches a avoir.

dahtah a écrit:

Comparer des flottants n'est pas aussi simple. Tu dois generalement comparer a une plage de tolerance, du genre (naivement) abs(a - b) <= tolerance.

J'ai opter pour cette comparaison qui marche du tonnerre et ai testé aussi la solution qui consiste à convertir les flottants en chaîne de caractère pour ensuite comparer deux string et ça marche bien aussi.
Ceci étant je me demande quelle est la solution la plus pertinente entre la limite de tolérance et la conversion des flottants en chaîne de caractère.

[Laurent 1973]

Je t'invite plutôt à utiliser la technique de contrôle de différence à une tolérance pret pour la comparaison de 2 décimaux.

Deux raisons pour cela:

1. Logique: tu veux comparer des décimaux, reste en décimal, ne passe pas par un autre type intermédiaire.
2. Habitude: ce principe est une règle quelque soit le langage informatique utilisé, c'est plutôt bien de prendre les bonnes habitudes.
   Si demain tu fais du PHP, du VB, du C/C++ ou du Fortran, tu auras eu la bonne habitude.
   Et si tu veux utiliser ta technique de passer par du texte en C par exemple, bonne chance

[Clodion]

J'ai opter pour cette comparaison qui marche du tonnerre et ai testé aussi la solution qui consiste à convertir les flottants en chaîne de caractère pour ensuite comparer deux string et ça marche bien aussi.
Ceci étant je me demande quelle est la solution la plus pertinente entre la limite de tolérance et la conversion des flottants en chaîne de caractère.

Bonjour,
Toutes les réponses abordaient la précision.
Qui a parlé de convertir en chaîne de caractères?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> 100*(1.043-1)
4.299999999999993
>>>

Alors que manifestement le résultat devrait être "4.3"
La conversion en chaîne de caractère donnerait donc… "4.3" et "4.2"…

Voilà pourquoi…
Clodion

[marco056]

ou plus simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
>>> 0.1+0.2
0.30000000000000004

[Clodion]

ou plus simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
>>> 0.1+0.2
0.30000000000000004

Bonsoir,
Oui, mais là, le passage aux chaînes de caractères et la comparaison des premiers caractères, renvoie une égalité!
Mais il y a effectivement, sans doutes, plus simple!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> .3 - .1
0.19999999999999998
>>>

Clodion

[plxpy]

Mais revenons à ton problème, qui n'est pas propre à Python mais bien à tout langage de programmation.
donc, comme l'explique Mr Zee, il est important de ne jamais essayer de vérifier une égalité stricte entre 2 décimaux, quelque soit le langage utilisé.

Je suis d'accord à (100 - epsilon) % ! Le epsilon pour le "jamais".

Il y a des cas où la comparaison stricte entre flottants est nécessaire. Le tout est de savoir ce qu'on fait !

Un exemple (un que je connais bien) : des données géographiques surfaciques qui "s'enchevêtrent" (un puzzle, quoi !).
En topologie, le "rabouttage" de surfaces ne se fait pas à epsilon près. Un chevauchement est un chevauchement, un trou est un trou (tout ça, entre surfaces).

Mais c'était juste pour moduler les propos. Je suis OK sur le fond et ma remarque ne s'applique pas au cas du PO. Suffit d'imaginer un script qui vérifie que l'utilisateur saisit bien PI ...

[Mr ZEE]

Merci pour vos réponses, suggestions et remarques

Envoyé par Laurent 1973
1. Logique: tu veux comparer des décimaux, reste en décimal, ne passe pas par un autre type intermédiaire.

J’adhère complètement, j'avais déjà un antécédent avec une histoire "de torchons et de serviettes", je vais continuer sur les bonnes habitudes

Envoyé par Clodion
Qui a parlé de convertir en chaîne de caractères?

C'est une méthode que j'ai chopé sur le net, mais effectivement j'ai fait des tests comme dans ton exemple où l'égalité n'est pas bonne en passant par la conversion en string.
En tous cas merci pour ta démonstration

Envoyé par plxpy
Il y a des cas où la comparaison stricte entre flottants est nécessaire. Le tout est de savoir ce qu'on fait !

OK mais comment fait-on une comparaison stricte entre flottants? On passe par une conversion en décimal?

Envoyé par plxpy
Suffit d'imaginer un script qui vérifie que l'utilisateur saisit bien PI ...

Qu'est ce que tu entends par "l'utilisateur saisit bien PI"?