Comment vérifier si un dictionnaire Python ne contient que des types spécifiques

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un dictionnaire Python ne contient que des types spécifiques pour ses clés et ses valeurs. Le laboratoire se concentre sur la compréhension de l'importance de la vérification des types au sein des dictionnaires pour garantir l'intégrité des données.

Vous commencerez par créer un dictionnaire d'exemple et explorer le concept de vérification des types. Ensuite, vous apprendrez à utiliser la fonction isinstance() en conjonction avec la fonction all() pour vérifier que toutes les clés et les valeurs d'un dictionnaire correspondent aux types de données attendus. Cette expérience pratique vous dotera des compétences nécessaires pour valider le contenu des dictionnaires et maintenir la fiabilité du code.

Skills Graph

Comprendre la vérification des types dans les dictionnaires

Dans cette étape, nous allons explorer l'importance de la vérification des types au sein des dictionnaires en Python. Les dictionnaires sont des structures de données polyvalentes qui peuvent stocker des paires clé-valeur. Cependant, pour garantir l'intégrité et la fiabilité de votre code, il est crucial de savoir comment vérifier les types des clés et des valeurs stockées dans un dictionnaire.

Les dictionnaires en Python sont définis à l'aide d'accolades {}. Chaque élément d'un dictionnaire est composé d'une clé et d'une valeur correspondante, séparées par deux points :.

Commençons par créer un simple dictionnaire :

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

print(my_dict)

Enregistrez le code ci-dessus dans un fichier nommé type_checking.py dans votre répertoire ~/project. Vous pouvez utiliser l'éditeur VS Code pour créer et modifier ce fichier.

Maintenant, exécutez le script en utilisant la commande suivante dans le terminal :

python ~/project/type_checking.py

Vous devriez voir la sortie suivante :

{'name': 'Alice', 'age': 30, 'city': 'New York'}

Dans ce dictionnaire, les clés sont des chaînes de caractères ("name", "age", "city") et les valeurs sont une chaîne de caractères ("Alice"), un entier (30) et une autre chaîne de caractères ("New York").

La vérification des types devient importante lorsque vous souhaitez vous assurer que les données stockées dans votre dictionnaire correspondent à vos attentes. Par exemple, vous pourriez vouloir vérifier que l'âge est toujours un entier ou que le nom est toujours une chaîne de caractères.

Considérons un scénario où vous souhaitez ajouter une nouvelle paire clé-valeur au dictionnaire, mais vous voulez vous assurer que la valeur est d'un type spécifique.

Ouvrez le fichier type_checking.py dans VS Code et modifiez-le comme suit :

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking
def add_item(dictionary, key, value, expected_type):
    if isinstance(value, expected_type):
        dictionary[key] = value
        print(f"Added {key}: {value} to the dictionary.")
    else:
        print(f"Error: {key} must be of type {expected_type.__name__}.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str)
add_item(my_dict, "salary", 75000, int)
add_item(my_dict, "is_active", True, bool)
add_item(my_dict, "height", "5.8", float) ## Intentionally incorrect type

print(my_dict)

Dans ce code, nous définissons une fonction add_item qui prend un dictionnaire, une clé, une valeur et un type attendu en entrée. La fonction utilise la fonction isinstance() pour vérifier si la valeur est du type attendu. Si c'est le cas, la paire clé-valeur est ajoutée au dictionnaire. Sinon, un message d'erreur est affiché.

Exécutez le script à nouveau :

python ~/project/type_checking.py

Vous devriez voir la sortie suivante :

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Added is_active: True to the dictionary.
Error: height must be of type float.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000, 'is_active': True}

Comme vous pouvez le voir, la fonction add_item a réussi à ajouter les paires clé-valeur "occupation", "salary" et "is_active" au dictionnaire car leurs valeurs correspondent aux types attendus. Cependant, elle a affiché un message d'erreur pour "height" car la valeur fournie ("5.8") est une chaîne de caractères, tandis que le type attendu était float.

Cet exemple démontre le concept de base de la vérification des types dans les dictionnaires. Dans les étapes suivantes, nous explorerons des techniques plus avancées pour garantir la sécurité des types dans votre code Python.

Vérifier les types des clés et des valeurs

Dans l'étape précédente, nous avons appris à vérifier le type des valeurs lors de leur ajout à un dictionnaire. Maintenant, approfondissons le sujet et explorons comment vérifier les types à la fois des clés et des valeurs dans un dictionnaire.

Il est essentiel de s'assurer que les clés d'un dictionnaire sont de types immuables tels que les chaînes de caractères, les nombres ou les tuples. Les valeurs, en revanche, peuvent être de n'importe quel type. Modifions notre fichier type_checking.py pour inclure la vérification du type des clés.

Ouvrez le fichier type_checking.py dans VS Code et modifiez-le comme suit :

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking for both key and value
def add_item(dictionary, key, value, expected_key_type, expected_value_type):
    if not isinstance(key, expected_key_type):
        print(f"Error: Key must be of type {expected_key_type.__name__}.")
        return
    if not isinstance(value, expected_value_type):
        print(f"Error: Value must be of type {expected_value_type.__name__}.")
        return
    dictionary[key] = value
    print(f"Added {key}: {value} to the dictionary.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str, str)
add_item(my_dict, "salary", 75000, str, int)
add_item(my_dict, 123, "Some Value", str, str) ## Intentionally incorrect key type

print(my_dict)

Dans ce code mis à jour, la fonction add_item prend maintenant expected_key_type et expected_value_type en arguments. Elle vérifie si la clé et la valeur fournies sont des types attendus en utilisant isinstance(). Si la clé ou la valeur est d'un type incorrect, un message d'erreur est affiché et la fonction se termine sans ajouter l'élément au dictionnaire.

Maintenant, exécutez le script :

python ~/project/type_checking.py

Vous devriez voir la sortie suivante :

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Error: Key must be of type str.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000}

La sortie montre que les paires clé-valeur "occupation" et "salary" ont été ajoutées avec succès au dictionnaire car leurs clés et valeurs correspondent aux types attendus. Cependant, lorsque nous avons essayé d'ajouter une paire clé-valeur avec une clé entière (123), la fonction a affiché un message d'erreur car le type de clé attendu était str.

Vérifier les types des clés et des valeurs contribue à maintenir la cohérence et la justesse de vos données. Cela évite les erreurs inattendues et garantit que votre dictionnaire se comporte comme prévu.

Utiliser all() avec isinstance()

Dans cette étape, nous allons explorer comment utiliser la fonction all() en combinaison avec isinstance() pour vérifier efficacement les types de toutes les clés et valeurs dans un dictionnaire. Cette approche est particulièrement utile lorsque vous avez besoin de valider l'ensemble du dictionnaire par rapport à un ensemble de types attendus.

La fonction all() en Python renvoie True si tous les éléments d'un itérable sont vrais. Nous pouvons utiliser cette fonction pour parcourir le dictionnaire et vérifier si toutes les clés et valeurs correspondent aux types attendus.

Modifions notre fichier type_checking.py pour intégrer cette approche.

Ouvrez le fichier type_checking.py dans VS Code et modifiez-le comme suit :

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to check types of all keys and values in a dictionary
def check_dictionary_types(dictionary, expected_key_type, expected_value_type):
    key_types_correct = all(isinstance(key, expected_key_type) for key in dictionary)
    value_types_correct = all(isinstance(value, expected_value_type) for value in dictionary.values())

    if key_types_correct and value_types_correct:
        print("All keys and values have the correct types.")
        return True
    else:
        print("Not all keys and values have the correct types.")
        return False

## Example usage
check_dictionary_types(my_dict, str, (str, int)) ## Expecting keys to be strings and values to be either strings or integers

my_dict["zip"] = "10001"
check_dictionary_types(my_dict, str, (str, int))

my_dict["country"] = 123
check_dictionary_types(my_dict, str, (str, int))

Dans ce code, la fonction check_dictionary_types prend un dictionnaire, un type de clé attendu et un type de valeur attendu en entrée. Elle utilise la fonction all() avec une expression génératrice pour vérifier si toutes les clés sont du type attendu et si toutes les valeurs sont du type attendu. Si les deux conditions sont vraies, elle affiche un message de réussite et renvoie True. Sinon, elle affiche un message d'erreur et renvoie False.

Exécutez le script :

python ~/project/type_checking.py

Vous devriez voir la sortie suivante :

All keys and values have the correct types.
All keys and values have the correct types.
Not all keys and values have the correct types.

Le premier appel à check_dictionary_types renvoie True car toutes les clés sont des chaînes de caractères et toutes les valeurs sont soit des chaînes de caractères, soit des entiers. Le deuxième appel renvoie également True après avoir ajouté la clé "zip". Cependant, le troisième appel renvoie False après avoir ajouté la clé "country" avec une valeur entière, car maintenant l'une des clés est un entier, ce qui viole le type de clé attendu.

L'utilisation de all() avec isinstance() offre un moyen concis et efficace de valider les types de tous les éléments d'un dictionnaire, garantissant l'intégrité des données et évitant les erreurs inattendues dans votre code Python.

Résumé

Dans ce laboratoire, nous avons commencé par comprendre l'importance de la vérification de type dans les dictionnaires Python, qui sont des structures de données polyvalentes permettant de stocker des paires clé-valeur. Nous avons créé un dictionnaire d'exemple avec des clés de type chaîne de caractères et des valeurs de types mixtes (chaîne de caractères et entier), et nous avons souligné la nécessité de garantir l'intégrité des données en vérifiant les types des clés et des valeurs.

La première étape a mis en évidence l'importance de la vérification de type pour s'assurer que les données stockées dans un dictionnaire correspondent aux types attendus, par exemple en vérifiant qu'un âge est toujours un entier ou qu'un nom est toujours une chaîne de caractères. La configuration du laboratoire a consisté à créer un fichier type_checking.py et à l'exécuter pour afficher le contenu du dictionnaire.