Travailler avec des nombres à virgule flottante

4.1 Arrondi des nombres à virgule flottante

Les nombres en virgule flottante (fractionnaires) en anglais s'appellent floating point number — des nombres à virgule flottante : aux États-Unis, pour séparer la partie entière de la partie fractionnaire d'un nombre, on utilise un point. D'où le nom float.

Comme nous l'avons déjà vu, lors de la conversion d'un nombre à virgule flottante (float) en entier (int), il est toujours arrondi vers le bas — sa partie fractionnaire est simplement ignorée. Pourtant, il est facile d'imaginer une situation où un nombre fractionnaire doit être arrondi simplement au nombre entier le plus proche. Que faire dans cette situation ?

Pour cela, en Python, il existe une fonction intégrée round(). Elle a été inventée avant la création de la bibliothèque math, elle n'en fait donc pas partie. Les fonctions pour l'arrondi vers le bas et vers le haut se trouvent dans la bibliothèque math.

La fonction round() arrondit le nombre au nombre entier le plus proche :

round(float_number)

Cette fonction renverra un nombre entier, le plus proche de celui qui lui a été transmis. Il est important de noter que si la partie fractionnaire du nombre est égale à 0.5, la fonction round() utilise la méthode d'arrondi au nombre entier pair le plus proche. Cela s'appelle "l'arrondi bancaire" et permet de réduire l'erreur systématique lors de multiples arrondis. Par exemple :

Exemples :

La fonction math.floor() arrondit le nombre à l'entier inférieur, exemples :

Bien qu'il soit plus simple d'utiliser la fonction de conversion de type int() pour arrondir un nombre à l'entier inférieur :

Si vous avez du mal à vous souvenir de ces commandes, un petit cours d'anglais peut vous aider :

• math — mathématiques
• round — rond/arrondir
• ceiling — plafond
• floor — sol

4.2 Structure des nombres à virgule flottante

Le type float en Python peut stocker des valeurs dans la plage de -1.7*10308 à +1.7*10308. Une telle plage gigantesque de valeurs s'explique par le fait que le type float est structuré de manière très différente des types entiers. Chaque variable de type float contient deux nombres : le premier s'appelle la mantisse et le second — l'exposant.

Supposons que nous avons le nombre 123456789, et que nous l'avons stocké dans une variable de type float. Alors le nombre sera converti en 1.23456789*10⁸ , et à l'intérieur du type float, deux nombres seront stockés — 23456789 et 8. En rouge, la « partie significative du nombre » (mantisse), en vert — l'exposant.

Cette approche permet de stocker à la fois des nombres très grands et très petits. Mais comme la taille du nombre est limitée à 8 octets (64 bits) et qu'une partie des bits est utilisée pour stocker l'exposant (ainsi que le signe du nombre et le signe de l'exposant), la longueur maximale de la mantisse est limitée à 15 chiffres.

C'est une description très simplifiée de la structure des nombres à virgule flottante, vous pouvez en trouver une plus complète sur Internet.

4.3 Perte de précision lors du travail avec les nombres à virgule flottante

Lors du travail avec les nombres à virgule flottante, il faut toujours garder à l'esprit que les nombres à virgule flottante sont imprécis. Il y aura toujours des erreurs d'arrondi, erreurs de conversion de la base dix à la base binaire et, enfin, le plus fréquent — perte de précision lors de l'addition/soustraction de nombres de tailles très différentes.

Cette dernière est la situation la plus inattendue pour les débutants en programmation.

Si vous soustrayez de 10⁹ 1/10⁹, vous obtiendrez à nouveau 10⁹.

1000000000.000000000 - 0.000000001 1000000000.000000000 

Que dire, la programmation ce n'est pas des maths.

4.4 Danger de la comparaison des nombres à virgule flottante

Un autre danger guette les programmeurs lors de la comparaison des nombres à virgule flottante. Étant donné qu'avec ces nombres, des erreurs d'arrondi peuvent s'accumuler, il peut y avoir des situations où les nombres à virgule flottante devraient être égaux, mais ne le sont pas. Et inversement : les nombres ne devraient pas être égaux, mais ils le sont.

Exemple :

Dans l'exemple ci-dessus, a et c ne devraient pas être égaux, mais ils le sont.

Ou prenons un autre exemple :

En pratique, les nombres à virgule flottante se comparent ainsi :

On prend un nombre très petit. Si la différence entre les nombres (en valeur absolue) est inférieure à ce petit nombre, alors ils sont considérés comme égaux. Exemple :

a = 0.00000000012
b = 0.000000000011 

if abs(a - b) < 0.00001:
    print("égaux")
else:
    print("non égaux")