Comment vérifier si un dictionnaire Python a un certain nombre de clés

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un dictionnaire Python possède un nombre spécifique de clés. Cela implique d'explorer la taille d'un dictionnaire à l'aide de la fonction intégrée len() pour déterminer le nombre de paires clé-valeur.

Vous allez créer un script Python pour définir un dictionnaire, utiliser len() pour obtenir sa taille et afficher le résultat. Vous allez également expérimenter avec un dictionnaire vide pour observer la sortie. Cette expérience pratique montrera comment utiliser efficacement len() pour vérifier le nombre de clés dans les dictionnaires.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") python/DataStructuresGroup -.-> python/dictionaries("Dictionaries") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") subgraph Lab Skills python/conditional_statements -.-> lab-559506{{"Comment vérifier si un dictionnaire Python a un certain nombre de clés"}} python/dictionaries -.-> lab-559506{{"Comment vérifier si un dictionnaire Python a un certain nombre de clés"}} python/build_in_functions -.-> lab-559506{{"Comment vérifier si un dictionnaire Python a un certain nombre de clés"}} end

Explorer la taille d'un dictionnaire

Dans cette étape, vous apprendrez à déterminer la taille d'un dictionnaire en Python. La taille d'un dictionnaire fait référence au nombre de paires clé-valeur qu'il contient. Connaître la taille d'un dictionnaire peut être utile pour diverses tâches, comme vérifier si un dictionnaire est vide ou déterminer s'il a atteint une certaine capacité.

Pour trouver la taille d'un dictionnaire, vous pouvez utiliser la fonction intégrée len(). Cette fonction renvoie le nombre d'éléments (paires clé-valeur) dans le dictionnaire.

Commençons par créer un simple script Python pour explorer ceci.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé dictionary_size.py dans le répertoire ~/project.
```
touch ~/project/dictionary_size.py
```
Ouvrez le fichier dictionary_size.py dans l'éditeur et ajoutez le code Python suivant :
```
## Create a sample dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Get the size of the dictionary using the len() function
dict_size = len(my_dict)

## Print the size of the dictionary
print("The size of the dictionary is:", dict_size)
```
Ce code crée d'abord un dictionnaire appelé my_dict avec trois paires clé-valeur. Ensuite, il utilise la fonction len() pour obtenir la taille du dictionnaire et la stocke dans la variable dict_size. Enfin, il affiche la taille du dictionnaire dans la console.
Maintenant, exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The size of the dictionary is: 3
```
Cette sortie confirme que la fonction len() renvoie correctement le nombre de paires clé-valeur dans le dictionnaire.

Essayons avec un dictionnaire vide. Modifiez le fichier dictionary_size.py comme suit :

## Create an empty dictionary
my_dict = {}

## Get the size of the dictionary using the len() function
dict_size = len(my_dict)

## Print the size of the dictionary
print("The size of the dictionary is:", dict_size)

Exécutez le script à nouveau :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The size of the dictionary is: 0
```
Cela montre qu'un dictionnaire vide a une taille de 0.

Utiliser `len()` sur les clés

Dans l'étape précédente, vous avez appris à utiliser la fonction len() pour déterminer le nombre total de paires clé-valeur dans un dictionnaire. Dans cette étape, vous allez explorer comment utiliser len() en conjonction avec la méthode .keys() pour trouver le nombre de clés dans un dictionnaire.

La méthode .keys() renvoie un objet vue (view object) qui affiche une liste de toutes les clés du dictionnaire. Vous pouvez ensuite utiliser la fonction len() sur cet objet vue pour obtenir le nombre de clés. Cela peut être utile lorsque vous avez seulement besoin de connaître le nombre de clés et non le nombre total de paires clé-valeur.

Modifions le script Python de l'étape précédente pour démontrer ceci.

Ouvrez le fichier dictionary_size.py dans l'éditeur VS Code (s'il n'est pas déjà ouvert).
Modifiez le fichier dictionary_size.py avec le code Python suivant :
```
## Create a sample dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Get the keys of the dictionary using the .keys() method
keys = my_dict.keys()

## Get the number of keys using the len() function
num_keys = len(keys)

## Print the number of keys
print("The number of keys in the dictionary is:", num_keys)
```
Dans ce code, nous créons d'abord un dictionnaire appelé my_dict. Ensuite, nous utilisons la méthode .keys() pour obtenir un objet vue contenant toutes les clés du dictionnaire. Nous stockons cet objet vue dans la variable keys. Enfin, nous utilisons la fonction len() pour obtenir le nombre de clés dans l'objet vue keys et affichons le résultat.
Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The number of keys in the dictionary is: 3
```
Cette sortie confirme que la fonction len(), lorsqu'elle est utilisée avec la méthode .keys(), renvoie correctement le nombre de clés dans le dictionnaire.

Maintenant, essayons d'ajouter une nouvelle paire clé-valeur au dictionnaire et voyons comment cela affecte le nombre de clés. Modifiez le fichier dictionary_size.py comme suit :

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

## Add a new key-value pair
my_dict["occupation"] = "Engineer"

## Get the keys of the dictionary using the .keys() method
keys = my_dict.keys()

## Get the number of keys using the len() function
num_keys = len(keys)

## Print the number of keys
print("The number of keys in the dictionary is:", num_keys)

Exécutez le script à nouveau :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The number of keys in the dictionary is: 4
```
Cela montre que l'ajout d'une nouvelle paire clé-valeur augmente le nombre de clés dans le dictionnaire.

Comparer avec un nombre souhaité

Dans les étapes précédentes, vous avez appris à déterminer la taille d'un dictionnaire et à compter le nombre de clés. Dans cette étape, vous allez apprendre à comparer la taille d'un dictionnaire (ou le nombre de clés) avec un nombre souhaité. Cela est utile lorsque vous devez valider qu'un dictionnaire a un nombre spécifique de paires clé-valeur ou de clés avant de poursuivre avec d'autres opérations.

Modifions le script Python de l'étape précédente pour démontrer ceci.

Ouvrez le fichier dictionary_size.py dans l'éditeur VS Code (s'il n'est pas déjà ouvert).

Modifiez le fichier dictionary_size.py avec le code Python suivant :

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

## Desired count
desired_count = 3

## Get the size of the dictionary
dict_size = len(my_dict)

## Compare with desired count
if dict_size == desired_count:
    print("The dictionary size matches the desired count.")
else:
    print("The dictionary size does not match the desired count.")

## Get the number of keys
num_keys = len(my_dict.keys())

## Compare the number of keys with desired count
if num_keys == desired_count:
    print("The number of keys matches the desired count.")
else:
    print("The number of keys does not match the desired count.")

Dans ce code, nous créons d'abord un dictionnaire appelé my_dict et définissons une variable desired_count à 3. Ensuite, nous obtenons la taille du dictionnaire en utilisant la fonction len() et la comparons avec le desired_count. Nous affichons un message indiquant si la taille du dictionnaire correspond au nombre souhaité. Nous répétons ensuite le même processus pour le nombre de clés dans le dictionnaire.

Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The dictionary size matches the desired count.
The number of keys matches the desired count.
```
Cette sortie confirme que la taille du dictionnaire et le nombre de clés correspondent tous deux au nombre souhaité de 3.

Maintenant, modifions le dictionnaire et le nombre souhaité pour voir comment la comparaison change. Modifiez le fichier dictionary_size.py comme suit :

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

## Add a new key-value pair
my_dict["occupation"] = "Engineer"

## Desired count
desired_count = 4

## Get the size of the dictionary
dict_size = len(my_dict)

## Compare with desired count
if dict_size == desired_count:
    print("The dictionary size matches the desired count.")
else:
    print("The dictionary size does not match the desired count.")

## Get the number of keys
num_keys = len(my_dict.keys())

## Compare the number of keys with desired count
if num_keys == desired_count:
    print("The number of keys matches the desired count.")
else:
    print("The number of keys does not match the desired count.")

Exécutez le script à nouveau :
```
python ~/project/dictionary_size.py
```
Vous devriez voir la sortie suivante :
```
The dictionary size matches the desired count.
The number of keys matches the desired count.
```
Maintenant, la taille du dictionnaire et le nombre de clés correspondent tous deux au nombre souhaité mis à jour de 4.

Résumé

Dans ce laboratoire (lab), vous avez appris à déterminer la taille d'un dictionnaire Python en utilisant la fonction len(). Le laboratoire consistait à créer un script Python, dictionary_size.py, pour explorer cette fonctionnalité. Vous avez créé un dictionnaire exemple avec des paires clé-valeur, puis utilisé len(my_dict) pour obtenir le nombre d'éléments dans le dictionnaire, affichant le résultat dans la console.

Le laboratoire a également démontré le fonctionnement de la fonction len() avec un dictionnaire vide, mettant en évidence sa capacité à retourner précisément le nombre de paires clé-valeur, même lorsque le dictionnaire est vide. Cette connaissance est essentielle pour des tâches telles que vérifier si un dictionnaire est vide ou déterminer s'il a atteint une capacité spécifique.