int).]]>number]]>number n'est pas un type Python standard.]]>float]]>float (« nombre à virguleint]]>int est le type des entiers en Python.]]>real]]>real n'existe pas en Python (mais existefloat, $32$ bits),double, $64$ bits) et plus.0.1 + 0.2 ?]]>abs(a - b) < epsilon.]]>a et b sont « égaux »a == b]]>== est trop strict.]]>round(a, 2) == round(b, 2)]]>abs(a - b) < epsilon]]>epsilon choisie petite (par exemple $10^{-9}$), auepsilon dépend du contexte.]]>int(a) == int(b)]]>int supprime la partie décimale, ce qui ne mesure pasint(2.1) == int(2.9) vaut True alors que les deuxfloat ?]]>float du langage C). Python utilise par défaut lamoyenne, on exécute ledef moyenne(a, b):
return (a + b) / 2
assert moyenne(0.25, 0.75) == 0.5
assert moyenne(0.1, 0.2) == 0.15Que se passe-t-il ?
]]>assert abs(moyenne(0.1, 0.2) - 0.15) < 1e-9.]]>0.15000000000000002, et l'égalité0.15 est fausse.]]>AssertionError]]>0.15000000000000002, et la seconde égalité estAssertionError et arrête le programme]]>== entre deux flottants et lève une erreur]]>== s'applique aux flottants comme aux0.1 dans une bouclefor donne 0.9999999999999999, pas $1{,}0$, à cause des erreursprix = [0.1 + 0.2, 0.5, 0.3]
compte = 0
for p in prix:
if p == 0.3:
compte = compte + 1
print(compte)Qu'affiche ce programme ?
]]>abs(p - 0.3) < 1e-9, les2]]>0.1 + 0.2 ne vaut pas 0.3 en Python mais0.30000000000000004. Le test p == 0.3 est donc faux pour le1]]>0.3,0.30000000000000004 et0]]>0.3 du test sont== ne compare pas des flottants]]>== s'applique aux flottants et renvoie un booléen. Lefloat sont inacceptables pour desfloat]]>float(7) renvoie :]]>int(7.9) renvoie $7$ (troncature, pasround(7.9) qui7 (entier inchangé)]]>float change le type. Le7.0, qui est un flottant.]]>7.0 (flottant)]]>int àfloat.]]>'7' (chaîne de caractères)]]>float() convertit en flottant, pas enstr(7).]]>(1e16 + 1) - 1e16 donne-t-il $0$ en Python(1e16 + 1) - 1e16 = 0 mais (1e16 - 1e16) + 1 = 1.1.0000001 - 1.0 affiche1.0000000005838672e-07 au lieu de 1e-07. Les chiffres de têtedef proches(a, b):
return abs(a - b) < 1e-9
print(proches(1e-12, 2e-12))True, alors que 2e-12 est le1e-12. Comment expliquer ce résultat ?]]>a et b. Une toléranceabs(a - b) < 1e-9 * abs(b), qui renvoie ici False.]]>0.0 en machine]]>1e-12 == 2e-12False.]]>0.0, d'où un écart nul]]>1e-12 - 2e-12 renvoie -1e-12, un écart non1e-12 et2e-12 ; l'indiscernabilité ne concerne que des écarts== entre flottants est piégeux, préférer une tolérance]]>abs(a - b) < epsilon.]]>0.1 + 0.2 et 0.3 en flottant.]]>True ?]]>0.1 + 0.2 == 0.3]]>0.1 et 0.2 sont approchés en binaire, la0.30000000000000004.]]>0.7 + 0.1 == 0.8]]>0.7 + 0.1 vaut 0.7999999999999999, à cause0.7 et de 0.1.]]>1.5 - 0.25 == 1.25]]>0.1 * 3 == 0.3]]>0.1 * 3 vaut 0.30000000000000004, l'erreur0.1 est multipliée par trois.]]>print(1 / 3) ?]]>0.3333333333333333, une valeur approchée]]>0.333…, avec des chiffres qui défilent sans fin]]>1/3, la fraction exacte gardée en mémoire]]>/ renvoie un float, jamais une0.33, la valeur arrondie au centième]]>round.]]>float, avec ses $52$ chiffres,0.1 * 3 == 0.3 en Python ?]]>False, le produit valant 0.30000000000000004]]>0.3 au seizième chiffre.]]>True, le calcul étant exact en décimal comme en binaire]]>0.1 est déjà une approximation de $0{,}1$ ; la==]]>0.3, la valeur commune des deux membres]]>x = 0
while x != 1:
x = x + 0.1
print("fini")while sur un flottant doit utiliser < ou <=, jamais!= ou == : l'égalité exacte n'est pas atteignable.]]>x n'égalant jamais 1]]>0.1 donnent0.9999999999999999, puis x dépasse $1$ sans jamais l'égaler.fini après dix tours, x valant alors exactement 1]]>x vaut 0.9999999999999999, pas1.]]>fini après onze tours, x dépassant alors 1]]>x vaut environ 1.0999999999999999,1.]]>!= n'acceptant pas un entier et un flottant]]>int((0.1 + 0.7) * 10) en Python ?]]>round est plus sûr que int quand on attend une valeur entière.]]>7, le produit valant 7.999999999999999]]>0.1 + 0.7 vaut 0.7999999999999999, un peuint tronque à $7$.]]>8, le calcul tombant juste sur un entier]]>8.0, int conservant un flottant]]>int renvoie toujours un entier.]]>int ne s'appliquant qu'aux chaînes]]>int accepte un flottant et le tronque.]]>0.1 n'est pas représentable exactement en binaire, et pourtantprint(0.1) affiche 0.1. Pourquoi ?]]>0.1 suffit à la0.1 est stocké exactement, contrairement à 0.3]]>print arrondit toujours à un chiffre après la virgule]]>print(0.30000000000000004) affiche bien dix-sept1e3 en Python ?]]>3.5e-2 vaut $0{,}035$ et 6e23 vaut $6 \times 10^{23}$ : lae et produit un flottant.]]>1000.0, un flottant]]>1e3 signifie $1 \times 10^{3}$ et cette1000, un entier]]>e donne un float, pas un int.]]>13]]>e ne concatène pas des chiffres, il introduit une n'étant pas un chiffre]]>1e3 est une écriture valide, la notation scientifiquea et babs(a - b) < 1e-9]]>a soit un peu au-dessus ou un peu en dessous de b.]]>abs(a) - abs(b) < 1e-9]]>round(a) == round(b)]]>a == b ou a - b == 0]]>