Comment vérifier si un dictionnaire est vide en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un dictionnaire est vide en Python. Le laboratoire couvre la création de dictionnaires vides en utilisant les accolades {} et le constructeur dict(). Vous explorerez ensuite comment utiliser la fonction len() pour vérifier le nombre de paires clé-valeur dans un dictionnaire, ce qui permet d'identifier efficacement les dictionnaires vides.

Enfin, le laboratoire montrera comment les dictionnaires vides sont évalués dans des contextes booléens, offrant une compréhension complète de la manipulation et de l'identification des dictionnaires vides en Python.

Apprendre les dictionnaires vides

Dans cette étape, vous apprendrez à connaître les dictionnaires vides en Python. Un dictionnaire est une collection de paires clé-valeur, et un dictionnaire vide est simplement un dictionnaire qui ne contient aucune paire clé-valeur. Comprendre comment créer et manipuler des dictionnaires vides est fondamental pour de nombreuses tâches de programmation.

Pour créer un dictionnaire vide, vous pouvez utiliser soit les accolades {} soit le constructeur dict(). Voyons comment faire cela en pratique.

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

Ajoutez le code Python suivant au fichier empty_dict.py :

## Creating an empty dictionary using curly braces
empty_dict_1 = {}
print("Empty dictionary 1:", empty_dict_1)

## Creating an empty dictionary using the dict() constructor
empty_dict_2 = dict()
print("Empty dictionary 2:", empty_dict_2)

Ce code crée deux dictionnaires vides, empty_dict_1 et empty_dict_2, en utilisant des méthodes différentes. La fonction print() est ensuite utilisée pour afficher ces dictionnaires.

Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_dict.py
```
Vous devriez voir la sortie suivante :
```
Empty dictionary 1: {}
Empty dictionary 2: {}
```
Cette sortie confirme que les deux méthodes ont réussi à créer des dictionnaires vides.

Les dictionnaires vides sont utiles comme points de départ pour construire des structures de données plus complexes. Vous pouvez y ajouter des paires clé-valeur selon vos besoins. Dans les étapes suivantes, vous apprendrez à vérifier si un dictionnaire est vide et comment les dictionnaires vides sont évalués dans des contextes booléens.

Utiliser len() pour vérifier

Dans cette étape, vous apprendrez à utiliser la fonction len() pour vérifier si un dictionnaire est vide. La fonction len() renvoie le nombre d'éléments (paires clé-valeur) dans un dictionnaire. Si un dictionnaire est vide, len() renverra 0.

Modifions le fichier empty_dict.py que vous avez créé à l'étape précédente pour inclure la fonction len().

Ouvrez le fichier empty_dict.py dans l'éditeur VS Code.
```
~/project/empty_dict.py
```

Modifiez le code Python dans le fichier empty_dict.py pour inclure la fonction len() :

## Creating an empty dictionary using curly braces
empty_dict_1 = {}
print("Empty dictionary 1:", empty_dict_1)
print("Length of empty_dict_1:", len(empty_dict_1))

## Creating an empty dictionary using the dict() constructor
empty_dict_2 = dict()
print("Empty dictionary 2:", empty_dict_2)
print("Length of empty_dict_2:", len(empty_dict_2))

## Checking if a dictionary is empty using len()
if len(empty_dict_1) == 0:
    print("empty_dict_1 is empty")
else:
    print("empty_dict_1 is not empty")

Ce code calcule la longueur des dictionnaires vides à l'aide de len() et affiche le résultat. Il montre également comment utiliser len() dans une instruction conditionnelle pour vérifier si un dictionnaire est vide.

Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_dict.py
```
Vous devriez voir la sortie suivante :
```
Empty dictionary 1: {}
Length of empty_dict_1: 0
Empty dictionary 2: {}
Length of empty_dict_2: 0
empty_dict_1 is empty
```
Cette sortie confirme que la fonction len() renvoie 0 pour les dictionnaires vides, et que l'instruction conditionnelle identifie correctement le dictionnaire comme vide.

Utiliser len() est un moyen simple et efficace de déterminer si un dictionnaire contient des paires clé-valeur. Cela peut être utile dans diverses situations, par exemple lorsque vous devez effectuer des actions différentes en fonction de l'état vide ou non d'un dictionnaire.

Évaluer en tant que booléen

Dans cette étape, vous apprendrez comment les dictionnaires vides sont évalués dans un contexte booléen. En Python, certaines valeurs sont considérées comme « vraies » (elles s'évaluent à True) et d'autres comme « fausses » (elles s'évaluent à False) lorsqu'elles sont utilisées dans un contexte booléen, comme dans une instruction if. Un dictionnaire vide est considéré comme « faux ».

Modifions le fichier empty_dict.py sur lequel vous avez travaillé pour illustrer ce concept.

Ouvrez le fichier empty_dict.py dans l'éditeur VS Code.
```
~/project/empty_dict.py
```

Modifiez le code Python dans le fichier empty_dict.py pour inclure une évaluation booléenne d'un dictionnaire vide :

## Creating an empty dictionary using curly braces
empty_dict_1 = {}
print("Empty dictionary 1:", empty_dict_1)
print("Length of empty_dict_1:", len(empty_dict_1))

## Creating an empty dictionary using the dict() constructor
empty_dict_2 = dict()
print("Empty dictionary 2:", empty_dict_2)
print("Length of empty_dict_2:", len(empty_dict_2))

## Checking if a dictionary is empty using len()
if len(empty_dict_1) == 0:
    print("empty_dict_1 is empty")
else:
    print("empty_dict_1 is not empty")

## Evaluating an empty dictionary as a boolean
if empty_dict_1:
    print("empty_dict_1 is truthy")
else:
    print("empty_dict_1 is falsy")

Ce code ajoute une instruction if qui évalue directement la variable empty_dict_1. Étant donné qu'il s'agit d'un dictionnaire vide, il sera traité comme False dans le contexte booléen.

Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_dict.py
```
Vous devriez voir la sortie suivante :
```
Empty dictionary 1: {}
Length of empty_dict_1: 0
Empty dictionary 2: {}
Length of empty_dict_2: 0
empty_dict_1 is empty
empty_dict_1 is falsy
```
Cette sortie confirme que le dictionnaire vide empty_dict_1 est évalué comme « faux » dans l'instruction if.

Comprendre que les dictionnaires vides s'évaluent à False peut simplifier votre code et le rendre plus lisible. Vous pouvez directement utiliser un dictionnaire dans un contexte booléen sans vérifier explicitement sa longueur.

Résumé

Dans ce laboratoire, vous avez appris à propos des dictionnaires vides en Python et à les créer en utilisant soit les accolades {} soit le constructeur dict(). Vous avez créé un fichier empty_dict.py et utilisé la fonction print() pour afficher les dictionnaires vides créés, confirmant que les deux méthodes ont réussi à créer des dictionnaires vides.

Le laboratoire a également introduit le concept d'utilisation de la fonction len() pour vérifier si un dictionnaire est vide, qui sera exploré plus en détail dans les étapes suivantes.