Comment vérifier si un nombre est un entier (pas un nombre à virgule flottante) en Python

Introduction

Dans ce labo (LabEx), vous apprendrez à déterminer si un nombre en Python est un entier (integer) ou un nombre à virgule flottante (float). Le labo commence par la différenciation entre les entiers et les nombres à virgule flottante, en mettant en évidence leurs caractéristiques clés et en fournissant des exemples.

Vous explorerez ensuite deux méthodes pour vérifier le type de données d'un nombre : en utilisant la fonction isinstance() avec int et en utilisant la fonction type() pour plus de précision. Grâce à des exercices pratiques, vous créerez un script Python pour identifier et distinguer les types de données entier et nombre à virgule flottante, renforçant ainsi votre compréhension de la vérification des types de données en Python.

Différencier les entiers et les nombres à virgule flottante

Dans cette étape, vous apprendrez à différencier deux types de données fondamentaux en Python : les entiers (integers) et les nombres à virgule flottante (floats). Comprendre la différence est crucial pour effectuer des calculs précis et manipuler des données.

Entiers (int)

Les entiers sont des nombres entiers, positifs ou négatifs, sans aucun point décimal. Des exemples incluent -3, 0, 5, 100.

Nombres à virgule flottante (float)

Les nombres à virgule flottante, ou nombres à virgule flottante en anglais (floating - point numbers), sont des nombres qui contiennent un point décimal. Ils peuvent également représenter des nombres en notation scientifique. Des exemples incluent -2.5, 0.0, 3.14, 1.0e5 (qui équivaut à 100000.0).

Commençons par créer un script Python pour explorer ces types de données.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé datatypes.py dans le répertoire ~/project.
```
touch ~/project/datatypes.py
```

Ouvrez le fichier datatypes.py dans l'éditeur et ajoutez le code Python suivant :

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

Enregistrez le fichier datatypes.py.
Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/datatypes.py
```
Vous devriez voir la sortie suivante :
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
```
Cette sortie montre clairement que integer_number est de type int et float_number est de type float.

Maintenant, effectuons une opération arithmétique simple pour voir comment Python gère ces types :

Modifiez le fichier datatypes.py pour inclure ce qui suit :

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

Enregistrez le fichier datatypes.py.
Exécutez le script à nouveau :
```
python ~/project/datatypes.py
```
Vous devriez voir la sortie suivante :
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
```
Notez que lorsque vous ajoutez un entier et un nombre à virgule flottante, le résultat est un nombre à virgule flottante. Cela s'explique par le fait que Python convertit automatiquement l'entier en nombre à virgule flottante pour maintenir la précision.

Utiliser isinstance() avec int

Dans cette étape, vous apprendrez à utiliser la fonction isinstance() pour vérifier si une variable est un entier. Cette fonction est un outil puissant pour vérifier les types de données en Python.

La fonction isinstance() prend deux arguments :

La variable que vous souhaitez vérifier.
Le type de données contre lequel vous souhaitez vérifier (par exemple, int, float, str).

Elle retourne True si la variable est du type spécifié, et False sinon.

Modifions le fichier datatypes.py de l'étape précédente pour inclure la fonction isinstance().

Ouvrez le fichier datatypes.py dans l'éditeur VS Code.

Ajoutez le code suivant au fichier :

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

## Check if integer_number is an integer
is_integer = isinstance(integer_number, int)
print("Is integer_number an integer?", is_integer)

## Check if float_number is an integer
is_integer = isinstance(float_number, int)
print("Is float_number an integer?", is_integer)

Enregistrez le fichier datatypes.py.
Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/datatypes.py
```
Vous devriez voir la sortie suivante :
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
Is integer_number an integer? True
Is float_number an integer? False
```
Comme vous pouvez le voir, isinstance(integer_number, int) retourne True car integer_number est effectivement un entier. isinstance(float_number, int) retourne False car float_number est un nombre à virgule flottante, pas un entier.

Cette fonction est particulièrement utile lorsque vous devez effectuer différentes actions en fonction du type de données d'une variable. Par exemple, vous pourriez vouloir effectuer une division entière si une variable est un entier, et une division à virgule flottante si c'est un nombre à virgule flottante.

Vérifier avec type() pour la précision

Dans cette étape, vous allez explorer comment la fonction type() peut être utilisée pour comprendre la précision des nombres en Python. Alors que isinstance() vérifie si une variable appartient à un type spécifique, type() retourne le type réel de la variable. Cela est utile pour comprendre comment Python gère différentes opérations numériques et la précision des résultats.

Continuons à modifier le fichier datatypes.py pour démontrer cela.

Ouvrez le fichier datatypes.py dans l'éditeur VS Code.

Ajoutez le code suivant au fichier :

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

## Check if integer_number is an integer
is_integer = isinstance(integer_number, int)
print("Is integer_number an integer?", is_integer)

## Check if float_number is an integer
is_integer = isinstance(float_number, int)
print("Is float_number an integer?", is_integer)

## Perform division with integers
division_result = integer_number / 3
print("Division result:", division_result, "Type:", type(division_result))

## Perform integer division with integers
integer_division_result = integer_number // 3
print("Integer division result:", integer_division_result, "Type:", type(integer_division_result))

Enregistrez le fichier datatypes.py.
Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/datatypes.py
```
Vous devriez voir la sortie suivante :
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
Is integer_number an integer? True
Is float_number an integer? False
Division result: 3.3333333333333335 Type: <class 'float'>
Integer division result: 3 Type: <class 'int'>
```
Remarquez les points suivants :
- Lorsque vous divisez deux entiers en utilisant l'opérateur /, le résultat est un nombre à virgule flottante, même si le résultat est un nombre entier. Cela s'explique par le fait que Python cherche à fournir le résultat le plus précis possible.
- Lorsque vous utilisez l'opérateur // (division entière), le résultat est un entier, tout le reste étant ignoré.

Comprendre ces subtilités est crucial pour écrire un code Python précis et efficace, surtout lorsqu'il s'agit de calculs numériques.

Résumé

Dans ce laboratoire, vous avez appris à différencier les entiers (integers) et les nombres à virgule flottante (floats) en Python. Les entiers sont des nombres entiers sans virgule décimale, tandis que les nombres à virgule flottante sont des nombres contenant une virgule décimale. Vous avez créé un script Python pour assigner des valeurs entières et des valeurs à virgule flottante à des variables, puis vous avez affiché leurs valeurs ainsi que leurs types respectifs en utilisant la fonction type(). La sortie a montré que les variables assignées des nombres entiers sont de type int, et celles avec des virgules décimales sont de type float.