Comment vérifier si un nombre est pair en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un nombre est pair ou impair en Python. Nous commencerons par comprendre les concepts fondamentaux des nombres pairs et impairs, en les définissant comme des entiers divisibles par 2 avec un reste de 0 (pair) ou 1 (impair).

Le laboratoire vous guidera ensuite dans l'utilisation de l'opérateur modulo (%) pour vérifier si un nombre est pair. Vous créerez un script Python qui utilise une instruction if et l'opérateur modulo pour déterminer et afficher si un nombre donné est pair ou impair. Le laboratoire comprend des instructions étape par étape pour créer le script dans VS Code et l'exécuter depuis le terminal.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ErrorandExceptionHandlingGroup(["Error and Exception Handling"]) python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python/BasicConceptsGroup -.-> python/numeric_types("Numeric Types") python/BasicConceptsGroup -.-> python/type_conversion("Type Conversion") python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") python/ErrorandExceptionHandlingGroup -.-> python/catching_exceptions("Catching Exceptions") subgraph Lab Skills python/numeric_types -.-> lab-559548{{"Comment vérifier si un nombre est pair en Python"}} python/type_conversion -.-> lab-559548{{"Comment vérifier si un nombre est pair en Python"}} python/conditional_statements -.-> lab-559548{{"Comment vérifier si un nombre est pair en Python"}} python/catching_exceptions -.-> lab-559548{{"Comment vérifier si un nombre est pair en Python"}} end

Apprenez-en sur les nombres pairs et impairs

Dans cette étape, nous allons explorer les concepts fondamentaux des nombres pairs et impairs. Comprendre ces concepts est crucial pour diverses tâches de programmation, notamment la validation de données, la conception d'algorithmes et le développement de jeux.

Qu'est-ce qu'un nombre pair ?

Un nombre pair est un entier qui est exactement divisible par 2. Cela signifie que lorsque vous divisez un nombre pair par 2, le reste est toujours 0. Des exemples de nombres pairs sont : 2, 4, 6, 8, 10, etc.

Qu'est-ce qu'un nombre impair ?

Un nombre impair est un entier qui n'est pas exactement divisible par 2. Lorsque vous divisez un nombre impair par 2, le reste est toujours 1. Des exemples de nombres impairs sont : 1, 3, 5, 7, 9, etc.

Comment déterminer si un nombre est pair ou impair

En programmation, nous devons souvent déterminer si un nombre donné est pair ou impair. Python offre un moyen simple de le faire en utilisant l'opérateur modulo (%). L'opérateur modulo renvoie le reste d'une division.

Par exemple, 7 % 2 vaut 1 car lorsque vous divisez 7 par 2, le reste est 1. De même, 8 % 2 vaut 0 car lorsque vous divisez 8 par 2, le reste est 0.

Créons un simple script Python pour illustrer cela :

Ouvrez l'éditeur VS Code dans le WebIDE.
Créez un nouveau fichier nommé even_odd.py dans le répertoire ~/project.
```
~/project/even_odd.py
```
Ajoutez le code suivant au fichier even_odd.py :
```
number = 10
if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Ce code attribue d'abord la valeur 10 à la variable number. Ensuite, il utilise une instruction if pour vérifier si le reste de la division de number par 2 est égal à 0. Si c'est le cas, le code affiche que le nombre est pair. Sinon, il affiche que le nombre est impair.
Exécutez le script en utilisant la commande suivante dans le terminal :
```
python ~/project/even_odd.py
```
Vous devriez voir la sortie suivante :
```
10 is an even number
```

Maintenant, changez la valeur de number dans le fichier even_odd.py en 7 :

number = 7
if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")

Exécutez le script à nouveau :
```
python ~/project/even_odd.py
```
Vous devriez maintenant voir la sortie suivante :
```
7 is an odd number
```

Cet exemple simple montre comment utiliser l'opérateur modulo pour déterminer si un nombre est pair ou impair en Python. Dans les étapes suivantes, nous allons nous appuyer sur cette base pour créer des programmes plus complexes.

Utilisation de l'opérateur modulo

Dans l'étape précédente, vous avez appris ce que sont les nombres pairs et impairs et comment l'opérateur modulo (%) peut être utilisé pour déterminer si un nombre est pair ou impair. Dans cette étape, nous allons approfondir notre connaissance de l'opérateur modulo et explorer ses diverses applications.

Comprendre l'opérateur modulo

L'opérateur modulo (%) renvoie le reste d'une division. La syntaxe est a % b, où a est le dividende (le nombre à diviser) et b est le diviseur (le nombre par lequel on divise). Le résultat est le reste de la division.

Voici quelques exemples :

7 % 2 vaut 1 car 7 divisé par 2 donne 3 avec un reste de 1.
10 % 3 vaut 1 car 10 divisé par 3 donne 3 avec un reste de 1.
15 % 5 vaut 0 car 15 divisé par 5 donne 3 avec un reste de 0.

Applications de l'opérateur modulo

L'opérateur modulo a de nombreuses applications utiles en programmation, notamment :

Déterminer si un nombre est pair ou impair : Comme vous l'avez vu dans l'étape précédente, number % 2 == 0 indique que number est pair, et number % 2 != 0 indique que number est impair.
Bouclage : L'opérateur modulo peut être utilisé pour boucler sur une plage de nombres. Par exemple, si vous avez un compteur qui doit cycler à travers les nombres de 0 à 9, vous pouvez utiliser l'opérateur modulo pour réinitialiser le compteur à 0 lorsqu'il atteint 10.
Extraire des chiffres : L'opérateur modulo peut être utilisé pour extraire le dernier chiffre d'un nombre. Par exemple, number % 10 renvoie le dernier chiffre de number.

Modifions le script even_odd.py pour obtenir le nombre à partir de l'entrée utilisateur et utiliser l'opérateur modulo pour vérifier s'il est pair ou impair.

Ouvrez le fichier even_odd.py dans le répertoire ~/project à l'aide de l'éditeur VS Code.
Modifiez le code comme suit :
```
number_str = input("Enter an integer: ")
number = int(number_str)

if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Dans ce code, nous utilisons la fonction input() pour inviter l'utilisateur à saisir un entier. La fonction input() renvoie une chaîne de caractères, donc nous utilisons la fonction int() pour convertir la chaîne en entier. Ensuite, nous utilisons l'opérateur modulo pour vérifier si le nombre est pair ou impair, comme précédemment.
Exécutez le script en utilisant la commande suivante :
```
python ~/project/even_odd.py
```
Le script vous invitera à saisir un entier. Saisissez un nombre et appuyez sur Entrée. Par exemple :
```
Enter an integer: 15
```
Le script affichera ensuite si le nombre est pair ou impair :
```
15 is an odd number
```
Essayez d'exécuter le script avec différents nombres pour voir comment fonctionne l'opérateur modulo.

Cet exemple montre comment utiliser l'opérateur modulo avec l'entrée utilisateur pour déterminer si un nombre est pair ou impair. Dans l'étape suivante, nous ajouterons une gestion des erreurs pour nous assurer que l'utilisateur saisit un entier valide.

Assurez-vous que le nombre est un entier

Dans l'étape précédente, vous avez appris à utiliser la fonction input() pour obtenir l'entrée de l'utilisateur et la fonction int() pour convertir l'entrée en un entier. Cependant, si l'utilisateur entre quelque chose qui n'est pas un entier (par exemple, "hello" ou "3.14"), la fonction int() lèvera une exception ValueError, faisant planter le programme. Dans cette étape, nous ajouterons une gestion des erreurs pour nous assurer que l'utilisateur entre un entier valide.

Gestion des erreurs avec try-except

Python propose un bloc try-except pour gérer les exceptions. Le code dans le bloc try est exécuté. Si une exception se produit, le code dans le bloc except est exécuté.

Voici la syntaxe de base :

try:
    ## Code that might raise an exception
except ValueError:
    ## Code to handle the ValueError exception

Si une exception ValueError se produit dans le bloc try, le code dans le bloc except ValueError sera exécuté.

Modifions le script even_odd.py pour utiliser un bloc try-except afin de gérer les exceptions ValueError potentielles.

Ouvrez le fichier even_odd.py dans le répertoire ~/project à l'aide de l'éditeur VS Code.
Modifiez le code comme suit :
```
while True:
    number_str = input("Enter an integer: ")
    try:
        number = int(number_str)
        break  ## Exit the loop if the input is a valid integer
    except ValueError:
        print("Invalid input. Please enter an integer.")

if number % 2 == 0:
    print(number, "is an even number")
else:
    print(number, "is an odd number")
```
Dans ce code, nous avons ajouté une boucle while True qui continue d'inviter l'utilisateur à entrer des données jusqu'à ce qu'un entier valide soit saisi. À l'intérieur de la boucle, nous avons un bloc try-except. Le bloc try tente de convertir l'entrée de l'utilisateur en un entier. Si la conversion réussit, l'instruction break quitte la boucle. Si une exception ValueError se produit (ce qui signifie que l'utilisateur a entré quelque chose qui n'est pas un entier), le bloc except affiche un message d'erreur et la boucle continue.
Exécutez le script en utilisant la commande suivante :
```
python ~/project/even_odd.py
```
Si vous entrez une valeur non entière, comme "hello", vous verrez la sortie suivante :
```
Enter an integer: hello
Invalid input. Please enter an integer.
Enter an integer:
```
Le script continuera d'inviter vous à entrer des données jusqu'à ce que vous entriez un entier valide. Une fois que vous avez entré un entier valide, comme 12, le script affichera si le nombre est pair ou impair :
```
Enter an integer: 12
12 is an even number
```

Cet exemple montre comment utiliser un bloc try-except pour gérer les exceptions ValueError potentielles lors de la conversion de l'entrée de l'utilisateur en un entier. Cela rend votre programme plus robuste et plus convivial.

Résumé

Dans ce laboratoire, nous avons exploré les concepts fondamentaux des nombres pairs et impairs, en comprenant que les nombres pairs sont divisibles par 2 avec un reste de 0, tandis que les nombres impairs ont un reste de 1 lorsqu'ils sont divisés par 2.

Nous avons utilisé l'opérateur modulo (%) en Python pour déterminer si un nombre est pair ou impair. Un simple script Python a été créé et exécuté pour démontrer cela, en vérifiant si le reste d'un nombre divisé par 2 est égal à 0 pour identifier les nombres pairs.