Comment vérifier si un nombre flottant n'a pas de partie décimale en Python

Introduction

Dans ce labo (atelier), vous apprendrez à vérifier si un nombre à virgule flottante (float) n'a pas de partie décimale en Python, en abordant les défis posés par la représentation des nombres à virgule flottante. Le labo commence par explorer l'imprécision inhérente des nombres à virgule flottante et son impact sur les comparaisons directes. Vous créerez un script Python pour observer comment des calculs apparemment simples comme 0.1 + 0.2 peuvent donner des valeurs légèrement différentes de celles attendues, entraînant des résultats de comparaison inattendus.

Le labo vous guide ensuite à travers deux méthodes pour déterminer si un nombre à virgule flottante représente effectivement un entier : en utilisant la méthode is_integer() et en comparant le nombre à virgule flottante à sa conversion en entier. Ces techniques offrent des solutions pratiques pour identifier précisément les nombres à virgule flottante sans composante décimale, malgré les limitations de représentation sous-jacentes.

Skills Graph

Explorer la représentation des nombres à virgule flottante

Dans cette étape, vous allez explorer comment les nombres à virgule flottante (floating-point numbers) sont représentés en Python et les implications potentielles de cette représentation sur les comparaisons numériques. Les nombres à virgule flottante sont utilisés pour représenter les nombres réels (nombres avec des points décimaux) dans les ordinateurs. Cependant, en raison de la manière dont ils sont stockés en mémoire, ils sont souvent des approximations des nombres réels réels. Cela peut entraîner des résultats inattendus lors de comparaisons.

Commençons par créer un fichier Python nommé float_representation.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## Create a floating-point number
x = 0.1 + 0.2

## Print the value of x
print(x)

Enregistrez le fichier, puis exécutez-le en utilisant la commande suivante dans le terminal :

python float_representation.py

Vous pourriez vous attendre à ce que la sortie soit 0.3, mais vous verrez probablement quelque chose comme ceci :

0.30000000000000004

Cela est dû au fait que 0.1 et 0.2 ne peuvent pas être représentés exactement comme des nombres à virgule flottante. Le résultat de l'addition est un nombre très proche de 0.3, mais pas exactement égal à celui-ci.

Maintenant, voyons comment cette imprécision peut affecter les comparaisons. Ajoutez le code suivant à votre fichier float_representation.py :

## Create a floating-point number
x = 0.1 + 0.2

## Check if x is equal to 0.3
if x == 0.3:
    print("x is equal to 0.3")
else:
    print("x is not equal to 0.3")

Enregistrez le fichier et exécutez-le à nouveau :

python float_representation.py

Vous verrez probablement la sortie suivante :

x is not equal to 0.3

Cela est dû au fait que x n'est pas exactement égal à 0.3 en raison du problème de représentation des nombres à virgule flottante.

Pour comparer précisément les nombres à virgule flottante, vous devriez utiliser une valeur de tolérance. Au lieu de vérifier l'égalité exacte, vérifiez si la différence absolue entre les deux nombres est inférieure à une petite valeur de tolérance.

Modifiez votre fichier float_representation.py pour inclure une tolérance :

## Create a floating-point number
x = 0.1 + 0.2

## Define a tolerance value
tolerance = 1e-9  ## A small value like 0.000000001

## Check if x is approximately equal to 0.3
if abs(x - 0.3) < tolerance:
    print("x is approximately equal to 0.3")
else:
    print("x is not approximately equal to 0.3")

Enregistrez le fichier et exécutez-le une dernière fois :

python float_representation.py

Maintenant, vous devriez voir la sortie suivante :

x is approximately equal to 0.3

En utilisant une tolérance, vous pouvez comparer précisément les nombres à virgule flottante malgré l'imprécision inhérente de leur représentation. C'est un concept crucial à comprendre lorsque vous travaillez avec des nombres à virgule flottante en Python et dans d'autres langages de programmation.

Utiliser la méthode is_integer()

Dans cette étape, vous apprendrez à utiliser la méthode is_integer() pour vérifier si un nombre à virgule flottante (floating-point number) représente une valeur entière. La méthode is_integer() est une méthode intégrée pour les objets de type float en Python qui renvoie True si le nombre à virgule flottante a une valeur entière (c'est-à-dire que la partie décimale est nulle) et False dans le cas contraire.

Créons un nouveau fichier Python nommé is_integer_example.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## Example 1: Integer value
x = 5.0
print(x.is_integer())

## Example 2: Non-integer value
y = 3.14
print(y.is_integer())

## Example 3: Another integer value
z = -2.0
print(z.is_integer())

Enregistrez le fichier et exécutez-le en utilisant la commande suivante dans le terminal :

python is_integer_example.py

Vous devriez voir la sortie suivante :

True
False
True

Comme vous pouvez le voir, is_integer() renvoie True pour 5.0 et -2.0 car ils représentent des valeurs entières, et False pour 3.14 car il a une partie décimale.

Maintenant, considérons le problème de représentation des nombres à virgule flottante que nous avons discuté dans l'étape précédente. Parfois, un nombre qui devrait être un entier peut ne pas être représenté exactement en raison de l'imprécision des nombres à virgule flottante.

Modifiez votre fichier is_integer_example.py pour inclure le code suivant :

## Example 4: Floating-point imprecision
a = 0.1 + 0.2
print(a)
print(a.is_integer())

Enregistrez le fichier et exécutez-le à nouveau :

python is_integer_example.py

Vous verrez probablement la sortie suivante :

0.30000000000000004
False

Même si 0.1 + 0.2 est mathématiquement égal à 0.3, la représentation en nombre à virgule flottante le rend légèrement différent, donc is_integer() renvoie False.

Pour gérer de tels cas, vous pouvez combiner is_integer() avec une vérification de tolérance, comme nous l'avons appris dans l'étape précédente. Cependant, dans ce cas, nous vérifions si un nombre représente un entier, pas s'il est égal à une valeur spécifique.

En résumé, la méthode is_integer() est un outil utile pour déterminer si un nombre à virgule flottante représente une valeur entière. Cependant, soyez conscient de l'impact potentiel de l'imprécision des nombres à virgule flottante et considérez ses implications lors de l'utilisation de cette méthode.

Comparaison avec la conversion en int()

Dans cette étape, vous allez explorer une autre méthode pour vérifier si un nombre à virgule flottante (floating-point number) représente une valeur entière : en le comparant à sa conversion en entier à l'aide de la fonction int(). La fonction int() tronque la partie décimale d'un nombre à virgule flottante, le convertissant effectivement en l'entier le plus proche en direction de zéro.

Créons un nouveau fichier Python nommé int_conversion.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## Example 1: Integer value
x = 5.0
if x == int(x):
    print("x is an integer")
else:
    print("x is not an integer")

## Example 2: Non-integer value
y = 3.14
if y == int(y):
    print("y is an integer")
else:
    print("y is not an integer")

## Example 3: Another integer value
z = -2.0
if z == int(z):
    print("z is an integer")
else:
    print("z is not an integer")

Enregistrez le fichier et exécutez-le en utilisant la commande suivante dans le terminal :

python int_conversion.py

Vous devriez voir la sortie suivante :

x is an integer
y is not an integer
z is an integer

Cette approche fonctionne car si un nombre à virgule flottante représente déjà un entier, sa conversion en entier à l'aide de int() ne changera pas sa valeur. Si le nombre à virgule flottante a une partie décimale, la fonction int() la tronquera, ce qui donnera une valeur différente.

Maintenant, considérons à nouveau le problème de représentation des nombres à virgule flottante. Modifiez votre fichier int_conversion.py pour inclure le code suivant :

## Example 4: Floating-point imprecision
a = 0.1 + 0.2
print(a)
if a == int(a):
    print("a is an integer")
else:
    print("a is not an integer")

Enregistrez le fichier et exécutez-le à nouveau :

python int_conversion.py

Vous verrez probablement la sortie suivante :

0.30000000000000004
a is not an integer

Comme dans l'étape précédente, l'imprécision des nombres à virgule flottante fait que a est légèrement différent de 0.3, et donc pas égal à sa conversion en entier (qui serait 0).

Il est important de noter que l'utilisation de la conversion int() pour vérifier la représentation d'un entier peut être moins précise que l'utilisation de is_integer(). is_integer() vérifie si le nombre à virgule flottante représente une valeur entière, tandis que la comparaison avec int() vérifie si le nombre à virgule flottante est égal à sa troncature en entier.

En résumé, comparer un nombre à virgule flottante avec sa conversion en entier à l'aide de int() est une autre façon de vérifier s'il représente une valeur entière. Cependant, soyez attentif à l'impact potentiel de l'imprécision des nombres à virgule flottante et envisagez d'utiliser is_integer() pour obtenir des résultats plus précis.

Résumé

Dans ce laboratoire (lab), vous avez exploré les subtilités de la représentation des nombres à virgule flottante (floating-point) en Python et son impact sur les comparaisons numériques. Vous avez appris que les nombres à virgule flottante sont souvent des approximations de nombres réels en raison de leur stockage en mémoire, ce qui peut entraîner des inexactitudes potentielles lors de vérifications d'égalité directes.

Vous avez observé que l'addition de 0.1 et de 0.2 peut ne pas donner exactement 0.3 et que la comparaison directe à l'aide de == peut donner des résultats inattendus. Le laboratoire a mis en évidence l'importance de comprendre ces limitations et la nécessité de recourir à des méthodes de comparaison alternatives, telles que l'utilisation de valeurs de tolérance, pour évaluer précisément l'égalité de nombres à virgule flottante.