Comment vérifier si une liste contient des éléments d'un type spécifique en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une liste contient des éléments d'un type spécifique en Python. Cela implique de comprendre le concept de vérification de type (type checking), qui est essentiel pour écrire un code robuste et maintenable dans l'environnement à typage dynamique de Python.

Vous explorerez les types de données de base de Python et utiliserez la fonction type() pour identifier le type des variables. Le laboratoire vous guidera dans la création d'un script Python pour démontrer la vérification de type, puis il présentera la fonction isinstance() ainsi que all() pour vérifier si tous les éléments d'une liste sont d'un type souhaité.

Apprendre sur la vérification de type

Dans cette étape, nous allons explorer le concept de vérification de type (type checking) en Python. La vérification de type est le processus consistant à vérifier que les types des valeurs utilisées dans un programme sont cohérents avec ce qui est attendu. Python est un langage à typage dynamique, ce qui signifie que la vérification de type est principalement effectuée à l'exécution (runtime). Cependant, comprendre comment vérifier les types et s'assurer qu'ils sont corrects est essentiel pour écrire un code robuste et maintenable.

Commençons par comprendre les types de données de base en Python :

int : Représente les entiers (par exemple, 1, 2, -5).
float : Représente les nombres à virgule flottante (par exemple, 3.14, 2.0).
str : Représente les chaînes de caractères (texte) (par exemple, "hello", "world").
bool : Représente les valeurs booléennes (True ou False).
list : Représente une collection ordonnée d'éléments (par exemple, [1, 2, 3]).
tuple : Représente une collection ordonnée et immuable d'éléments (par exemple, (1, 2, 3)).
dict : Représente une collection de paires clé-valeur (par exemple, {"name": "Alice", "age": 30}).

Pour vérifier le type d'une variable, vous pouvez utiliser la fonction type(). Créons un script Python pour démontrer cela.

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

Ajoutez le code suivant à type_checking.py :

## Assign values to different variables
x = 10
y = 3.14
name = "Bob"
is_valid = True
my_list = [1, 2, 3]
my_tuple = (4, 5, 6)
my_dict = {"key": "value"}

## Print the type of each variable
print(f"Type of x: {type(x)}")
print(f"Type of y: {type(y)}")
print(f"Type of name: {type(name)}")
print(f"Type of is_valid: {type(is_valid)}")
print(f"Type of my_list: {type(my_list)}")
print(f"Type of my_tuple: {type(my_tuple)}")
print(f"Type of my_dict: {type(my_dict)}")

Ce script assigne des valeurs de différents types à des variables, puis utilise la fonction type() pour afficher le type de chaque variable.

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

python ~/project/type_checking.py

Vous devriez voir une sortie similaire à ce qui suit :

Type of x: <class 'int'>
Type of y: <class 'float'>
Type of name: <class 'str'>
Type of is_valid: <class 'bool'>
Type of my_list: <class 'list'>
Type of my_tuple: <class 'tuple'>
Type of my_dict: <class 'dict'>

Cette sortie montre le type de chaque variable, confirmant que Python identifie correctement le type de chaque valeur.

Comprendre les types de vos variables est essentiel pour effectuer des opérations correctement. Par exemple, vous ne pouvez pas directement ajouter une chaîne de caractères à un entier sans convertir d'abord la chaîne de caractères en entier.

## Example of type error
x = 10
name = "Bob"

## This will raise a TypeError
## result = x + name

Si vous décommentez la dernière ligne du script, vous rencontrerez une erreur TypeError car Python ne sait pas comment ajouter un entier et une chaîne de caractères.

Pour résoudre ce problème, vous devrez convertir l'entier en chaîne de caractères ou vice versa, selon le résultat souhaité.

## Convert integer to string
x = 10
name = "Bob"
result = str(x) + name
print(result)  ## Output: 10Bob

Dans les étapes suivantes, nous explorerons des techniques plus avancées de vérification de type et d'assurance de la cohérence des types dans votre code Python.

Utiliser all() avec isinstance()

Dans cette étape, nous apprendrons à utiliser la fonction all() en combinaison avec la fonction isinstance() pour effectuer une vérification de type plus sophistiquée sur des collections de données. Cela est particulièrement utile lorsque vous devez vous assurer que tous les éléments d'une liste, d'un tuple ou d'un autre itérable ont un type spécifique.

La fonction isinstance() est utilisée pour vérifier si un objet est une instance d'une classe ou d'un type particulier. Elle prend deux arguments : l'objet à vérifier et le type à comparer. Elle retourne True si l'objet est une instance du type, et False sinon.

La fonction all() est utilisée pour vérifier si tous les éléments d'un itérable sont vrais. Elle prend un argument : un itérable (par exemple, une liste, un tuple ou un ensemble). Elle retourne True si tous les éléments de l'itérable sont vrais, et False sinon.

En combinant ces deux fonctions, nous pouvons facilement vérifier si tous les éléments d'une collection ont un type spécifique.

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

Ajoutez le code suivant à type_checking_all.py :

## List of values
values = [1, 2, 3, 4, 5]

## Check if all values are integers
all_integers = all(isinstance(x, int) for x in values)

## Print the result
print(f"Are all values integers? {all_integers}")

## List with mixed types
mixed_values = [1, 2, "3", 4, 5]

## Check if all values are integers
all_integers_mixed = all(isinstance(x, int) for x in mixed_values)

## Print the result
print(f"Are all values integers in mixed_values? {all_integers_mixed}")

## List of strings
string_values = ["a", "b", "c"]

## Check if all values are strings
all_strings = all(isinstance(x, str) for x in string_values)

## Print the result
print(f"Are all values strings? {all_strings}")

Ce script démontre comment utiliser all() et isinstance() pour vérifier les types des éléments d'une liste.

Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/type_checking_all.py
```
Vous devriez voir une sortie similaire à ce qui suit :
```
Are all values integers? True
Are all values integers in mixed_values? False
Are all values strings? True
```
Cette sortie montre que la fonction all() identifie correctement si tous les éléments de la liste sont du type spécifié.

Analysons comment cela fonctionne :

isinstance(x, int) vérifie si l'élément x est un entier.
(isinstance(x, int) for x in values) est une expression génératrice qui renvoie True ou False pour chaque élément de la liste values.
all(...) vérifie ensuite si toutes les valeurs renvoyées par l'expression génératrice sont True.

Cette approche est très flexible et peut être utilisée pour vérifier n'importe quel type ou combinaison de types dans une collection.

Spécifier le type souhaité

Dans cette étape, nous allons explorer comment spécifier le type souhaité pour les variables et les arguments de fonction, et comment imposer ces types à l'aide d'indices de type (type hints) et de vérifications conditionnelles. Bien que Python soit un langage à typage dynamique, les indices de type vous permettent d'ajouter des informations de type statique à votre code, que des vérificateurs de type comme mypy peuvent utiliser pour détecter les erreurs de type avant l'exécution.

Les indices de type sont des annotations qui spécifient le type attendu d'une variable, d'un argument de fonction ou de la valeur de retour d'une fonction. Ils sont écrits en utilisant la syntaxe : pour les variables et les arguments, et la syntaxe -> pour les valeurs de retour.

Commençons par ajouter des indices de type à notre exemple précédent.

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

Ajoutez le code suivant à type_hints.py :

def add_numbers(x: int, y: int) -> int:
    """Adds two numbers together."""
    return x + y

## Example usage
result: int = add_numbers(5, 3)
print(f"Result: {result}")

## Example with incorrect types
## This will not raise an error at runtime, but a type checker will flag it
## result: int = add_numbers("5", "3")
## print(f"Result: {result}")

Dans ce script :

x: int et y: int spécifient que les arguments x et y doivent être des entiers.
-> int spécifie que la fonction add_numbers doit retourner un entier.
result: int spécifie que la variable result doit être un entier.

Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/type_hints.py
```
Vous devriez voir une sortie similaire à ce qui suit :
```
Result: 8
```
Le script s'exécute sans erreur car les types sont corrects. Cependant, si vous décommentez les lignes avec des types incorrects, le script s'exécutera toujours, mais un vérificateur de type comme mypy signalerait ces lignes comme des erreurs de type.

Pour installer et exécuter mypy, vous pouvez utiliser les commandes suivantes :

pip install mypy
mypy ~/project/type_hints.py

Étant donné que pip n'est pas pré-configuré, vous pourriez rencontrer des erreurs liées à des paquets manquants ou à des versions incorrectes. Dans le cadre de ce laboratoire, nous nous concentrerons sur la démonstration du concept des indices de type et des vérifications conditionnelles.

Une autre façon d'imposer des types est d'utiliser des vérifications conditionnelles dans votre code. Cela vous permet de lever des exceptions si les types ne sont pas ceux que vous attendez.

def divide_numbers(x, y):
    if not isinstance(x, (int, float)):
        raise TypeError("x must be a number")
    if not isinstance(y, (int, float)):
        raise TypeError("y must be a number")
    if y == 0:
        raise ValueError("y cannot be zero")
    return x / y

## Example usage
result = divide_numbers(10, 2)
print(f"Result: {result}")

## Example with incorrect types
## This will raise a TypeError
## result = divide_numbers("10", 2)
## print(f"Result: {result}")

Dans cet exemple, nous utilisons isinstance() pour vérifier si x et y sont des nombres (soit des int, soit des float). Si ce n'est pas le cas, nous levons une TypeError. Nous vérifions également si y est égal à zéro et levons une ValueError dans ce cas.

En combinant les indices de type et les vérifications conditionnelles, vous pouvez écrire un code Python plus robuste et maintenable, moins sujet aux erreurs de type.

Résumé

Dans ce laboratoire, la première étape consiste à comprendre la vérification de type en Python, un langage à typage dynamique où la vérification de type se produit principalement à l'exécution. Le laboratoire présente les types de données de base en Python, notamment int, float, str, bool, list, tuple et dict.

Le laboratoire montre ensuite comment utiliser la fonction type() pour déterminer le type de données d'une variable. Un script Python nommé type_checking.py est créé pour assigner des valeurs de différents types à des variables et afficher ensuite leurs types respectifs à l'aide de la fonction type().