Comment vérifier si un nombre est zéro en Python

Introduction

Dans ce laboratoire (lab), nous allons explorer comment vérifier si un nombre est égal à zéro en Python. Le laboratoire couvre les concepts fondamentaux du zéro, la comparaison directe avec zéro et la gestion de la précision des nombres à virgule flottante.

Nous commencerons par créer un script Python pour démontrer les propriétés de base du zéro, y compris l'addition, la soustraction et la multiplication. Nous explorerons également le comportement de la division par zéro, qui génère une erreur en Python.

Skills Graph

Explorer le concept de zéro

Dans cette étape, nous allons explorer le concept de zéro en Python. Le zéro est une valeur numérique fondamentale qui représente l'absence de quantité. Comprendre le comportement du zéro dans différents contextes est crucial pour écrire un code Python précis et fiable.

Tout d'abord, créons un simple script Python pour démontrer les propriétés de base du zéro.

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.

2. Créez un nouveau fichier nommé zero_example.py dans le répertoire ~/project.

   ~/project/zero_example.py

3. Ajoutez le code suivant à zero_example.py :

   ## Assigning zero to a variable
   x = 0
   
   ## Printing the value of the variable
   print("The value of x is:", x)
   
   ## Adding a number to zero
   y = x + 5
   print("x + 5 =", y)
   
   ## Subtracting a number from zero
   z = x - 3
   print("x - 3 =", z)
   
   ## Multiplying a number by zero
   result = 10 * x
   print("10 * x =", result)

   Ce script démontre les opérations arithmétiques de base impliquant le zéro.

4. Enregistrez le fichier.

5. Exécutez le script en utilisant la commande python dans le terminal :

   python zero_example.py

   Vous devriez voir la sortie suivante :

   The value of x is: 0
   x + 5 = 5
   x - 3 = -3
   10 * x = 0

   Comme vous pouvez le voir, ajouter ou soustraire un nombre au zéro donne ce nombre (ou son opposé), et multiplier n'importe quel nombre par zéro donne zéro.

Maintenant, explorons la division par zéro. La division par zéro est indéfinie en mathématiques et générera une erreur en Python.

1. Modifiez le fichier zero_example.py pour inclure une division par zéro :

   ## Assigning zero to a variable
   x = 0
   
   ## Printing the value of the variable
   print("The value of x is:", x)
   
   ## Adding a number to zero
   y = x + 5
   print("x + 5 =", y)
   
   ## Subtracting a number from zero
   z = x - 3
   print("x - 3 =", z)
   
   ## Multiplying a number by zero
   result = 10 * x
   print("10 * x =", result)
   
   ## Division by zero (will cause an error)
   try:
       division_result = 10 / x
       print("10 / x =", division_result)
   except ZeroDivisionError as e:
       print("Error:", e)

   Nous utilisons un bloc try-except pour gérer l'erreur potentielle ZeroDivisionError.

2. Enregistrez le fichier.

3. Exécutez le script à nouveau :

   python zero_example.py

   Vous devriez voir la sortie suivante :

   The value of x is: 0
   x + 5 = 5
   x - 3 = -3
   10 * x = 0
   Error: division by zero

   Le script capture maintenant l'erreur ZeroDivisionError et affiche un message d'erreur informatif au lieu de planter.

Comprendre comment gérer le zéro dans votre code est essentiel pour éviter les erreurs inattendues et garantir le bon fonctionnement de vos programmes.

Comparer directement avec zéro

Dans cette étape, nous allons apprendre à comparer directement des nombres avec zéro en Python. La comparaison directe est une méthode simple pour vérifier si un nombre est égal à, supérieur ou inférieur à zéro. C'est une opération courante dans de nombreuses tâches de programmation, telles que la validation des entrées, le contrôle du flux du programme et la mise en œuvre de fonctions mathématiques.

Créons un script Python pour démontrer la comparaison directe avec zéro.

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.

2. Créez un nouveau fichier nommé compare_zero.py dans le répertoire ~/project.

   ~/project/compare_zero.py

3. Ajoutez le code suivant à compare_zero.py :

   ## Assigning a number to a variable
   number = 5
   
   ## Comparing the number with zero
   if number > 0:
       print(number, "is greater than zero")
   elif number < 0:
       print(number, "is less than zero")
   else:
       print(number, "is equal to zero")
   
   ## Changing the value of the number to zero
   number = 0
   
   ## Comparing the number with zero again
   if number > 0:
       print(number, "is greater than zero")
   elif number < 0:
       print(number, "is less than zero")
   else:
       print(number, "is equal to zero")
   
   ## Changing the value of the number to a negative number
   number = -3
   
   ## Comparing the number with zero one more time
   if number > 0:
       print(number, "is greater than zero")
   elif number < 0:
       print(number, "is less than zero")
   else:
       print(number, "is equal to zero")

   Ce script compare différents nombres avec zéro en utilisant les instructions if, elif et else.

4. Enregistrez le fichier.

5. Exécutez le script en utilisant la commande python dans le terminal :

   python compare_zero.py

   Vous devriez voir la sortie suivante :

   5 is greater than zero
   0 is equal to zero
   -3 is less than zero

   Le script identifie correctement si le nombre est supérieur, inférieur ou égal à zéro.

La comparaison directe avec zéro est simple et efficace pour les valeurs entières. Cependant, lorsqu'il s'agit de nombres à virgule flottante, vous devez être prudent en raison des problèmes potentiels de précision, que nous explorerons dans l'étape suivante.

Gérer la précision des nombres à virgule flottante

Dans cette étape, nous allons discuter de la manière de gérer la précision des nombres à virgule flottante lors de la comparaison de ces nombres avec zéro. En raison de la manière dont les nombres à virgule flottante sont représentés dans les ordinateurs, ils sont souvent sujets à de petites erreurs d'arrondi. Cela peut entraîner des résultats inattendus lors de leur comparaison directe avec zéro.

Par exemple, un calcul qui devrait théoriquement donner zéro peut en réalité produire un très petit nombre non nul comme 1e-16 (0,0000000000000001). Comparer directement ce nombre avec zéro en utilisant == renverra False, ce qui peut ne pas être le résultat souhaité.

Pour gérer ce problème, nous utilisons généralement une valeur de tolérance (également appelée epsilon) pour vérifier si un nombre à virgule flottante est « suffisamment proche » de zéro.

Créons un script Python pour démontrer cela.

1. Ouvrez l'éditeur VS Code dans l'environnement LabEx.

2. Créez un nouveau fichier nommé float_precision.py dans le répertoire ~/project.

   ~/project/float_precision.py

3. Ajoutez le code suivant à float_precision.py :

   ## Import the math module
   import math
   
   ## Define a tolerance value (epsilon)
   tolerance = 1e-9  ## A small value like 0.000000001
   
   ## A floating-point number that is very close to zero due to calculation
   number = 1e-10
   
   ## Direct comparison with zero (may fail)
   if number == 0:
       print("Direct comparison: number is zero")
   else:
       print("Direct comparison: number is not zero")
   
   ## Using tolerance to compare with zero
   if math.isclose(number, 0, abs_tol=tolerance):
       print("Comparison with tolerance: number is close to zero")
   else:
       print("Comparison with tolerance: number is not close to zero")
   
   ## Another example with a slightly larger number
   number = 1e-7
   
   ## Direct comparison with zero (will fail)
   if number == 0:
       print("Direct comparison: number is zero")
   else:
       print("Direct comparison: number is not zero")
   
   ## Using tolerance to compare with zero
   if math.isclose(number, 0, abs_tol=tolerance):
       print("Comparison with tolerance: number is close to zero")
   else:
       print("Comparison with tolerance: number is not close to zero")

   Ce script démontre comment utiliser la fonction math.isclose() avec une valeur de tolérance pour comparer des nombres à virgule flottante avec zéro.

4. Enregistrez le fichier.

5. Exécutez le script en utilisant la commande python dans le terminal :

   python float_precision.py

   Vous devriez voir la sortie suivante :

   Direct comparison: number is not zero
   Comparison with tolerance: number is close to zero
   Direct comparison: number is not zero
   Comparison with tolerance: number is not close to zero

   Comme vous pouvez le voir, la comparaison directe échoue car le nombre n'est pas exactement zéro. Cependant, lorsque vous utilisez une valeur de tolérance avec math.isclose(), la comparaison identifie correctement que le nombre est proche de zéro.

La fonction math.isclose() vérifie si deux valeurs à virgule flottante sont proches l'une de l'autre dans une tolérance spécifiée. L'argument abs_tol spécifie la tolérance absolue. Si la différence absolue entre les deux nombres est inférieure ou égale à la tolérance, la fonction renvoie True.

En utilisant une valeur de tolérance, vous pouvez éviter les problèmes causés par la précision des nombres à virgule flottante et vous assurer que vos comparaisons avec zéro sont précises et fiables.

Résumé

Dans ce laboratoire, nous avons commencé par explorer le concept fondamental de zéro en Python, en comprenant son comportement dans les opérations arithmétiques de base. Nous avons créé un script zero_example.py pour démontrer que l'ajout ou la soustraction d'un nombre à zéro donne ce nombre (ou son opposé), et que la multiplication de tout nombre par zéro donne zéro.

Le script a été exécuté pour observer ces propriétés, préparant le terrain pour une exploration plus approfondie du zéro en Python, y compris les implications de la division par zéro.