Discussion :

[PainBeur]

Bonjour,

J'ai une petite question simple et rapide :
pourquoi est ce que : math.log(125)/math.log(5) renvoi 3.0000000000000004 ?
ça fausse l'utilisation de float.is_integer()
alors qu'il est claire que 5**3 = 125
et cela ne survient pas pour par exemple math.log(81)/math.log(3) qui renvoi 4.0

merci à vous

[mathieu]

cela vient de la façon dont les entiers flottants sont stockés :
https://docs.python.org/3/tutorial/floatingpoint.html

si vous avez besoin de plus de précision, il y a ça :
https://docs.python.org/3/tutorial/floatingpoint.html

vous pouvez aussi tester si le nombre est dans un intervalle de tolérance comme cela par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
import math
 
 
valeur = math.log(125) / math.log(5)
 
print("valeur = math.log(125) / math.log(5)", valeur) # affiche 3.0000000000000004
print("valeur.is_integer()", valeur.is_integer()) # retourne False
print()
 
 
def est_entier_avec_tolerance(nombre, tolerance) :
	arrondi = round(nombre)
	return abs(nombre - arrondi) < tolerance
 
 
tolerance = 10 ** -8
 
print("round(valeur)", round(valeur)) # affiche 3
print(
	 "est_entier_avec_tolerance(valeur, tolerance)"
	, est_entier_avec_tolerance(valeur, tolerance) # retourne True
)
print(
	 "est_entier_avec_tolerance(2.00000001, tolerance)"
	, est_entier_avec_tolerance(2.00000001, tolerance) # retourne True
)
print(
	 "est_entier_avec_tolerance(2.0000001, tolerance)"
	, est_entier_avec_tolerance(2.0000001, tolerance) # retourne False
)

[PainBeur]

J'suis content d'avoir eu une explication, donc si j'ai bien compris j'imagine que ma calculatrice fais la meme chose mais à une tolérence plus faible ?
Merci à toi en tout cas

[Sve@r]

Bonjour

J'suis content d'avoir eu une explication, donc si j'ai bien compris j'imagine que ma calculatrice fais la meme chose mais à une tolérence plus faible ?

Pas forcément. Tu peux très bien avoir des calculatrices qui calculent en précision exacte. Par exemple le COBOL, langage des années 1970, stocke ses nombres décimaux dans des cases, avec une case par nombre. Exemple 3.1416 sera stocké dans 5 cases "3", "1", "4", "1", "6". De là il est très facile de faire des calculs sans perte de précision, ex 3.1416 + 5.1234 il sera fait comme au primaire avec "4" + "6" = 0 (1 de retenue) etc. Plus long, mais sans faille.
C'est pour ça que le COBOL est toujours utilisé dans les banques.

Python possède aussi un truc analogue: le module decimal

Code python :

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

1
2
3
4
5
6
7
>>> a=0.1
>>> a*3
0.30000000000000004
>>> import decimal
>>> a=decimal.Decimal("0.1")
>>> a*3
Decimal('0.3')

[PainBeur]

Ok, je vois, je te remercie pour la précision.
J'met ça en résolu, merci à vous bonne soirée