Comment vérifier si un ensemble (set) est vide en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un ensemble (set) est vide en Python. Cela implique de comprendre le concept d'ensembles vides et d'utiliser différentes méthodes pour déterminer s'ils sont vides.

Le laboratoire vous guide tout au long de la création d'un ensemble vide à l'aide du constructeur set() et de la vérification de son type. Vous explorerez ensuite comment utiliser la fonction len() pour vérifier si un ensemble est vide en déterminant le nombre d'éléments qu'il contient. Enfin, vous apprendrez à évaluer un ensemble comme une valeur booléenne pour vérifier s'il est vide.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python/BasicConceptsGroup -.-> python/booleans("Booleans") python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") python/DataStructuresGroup -.-> python/sets("Sets") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") subgraph Lab Skills python/booleans -.-> lab-559564{{"Comment vérifier si un ensemble (set) est vide en Python"}} python/conditional_statements -.-> lab-559564{{"Comment vérifier si un ensemble (set) est vide en Python"}} python/sets -.-> lab-559564{{"Comment vérifier si un ensemble (set) est vide en Python"}} python/build_in_functions -.-> lab-559564{{"Comment vérifier si un ensemble (set) est vide en Python"}} python/data_collections -.-> lab-559564{{"Comment vérifier si un ensemble (set) est vide en Python"}} end

Apprenez-en sur les ensembles vides

Dans cette étape, vous apprendrez à connaître les ensembles vides (empty sets) en Python. Un ensemble vide est un ensemble qui ne contient aucun élément. C'est un concept fondamental en théorie des ensembles et il est souvent utilisé en programmation pour représenter une collection qui est initialement vide mais qui peut plus tard contenir des éléments.

Pour créer un ensemble vide en Python, vous pouvez utiliser le constructeur set() sans aucun argument. Créons un ensemble vide et affichons-le pour voir à quoi il ressemble.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé empty_set.py dans le répertoire ~/project.
```
~/project/empty_set.py
```
Ajoutez le code Python suivant au fichier empty_set.py :
```
## Create an empty set
empty_set = set()

## Print the empty set
print(empty_set)

## Check the type of the variable
print(type(empty_set))
```
Ce code crée d'abord un ensemble vide en utilisant set() et l'assigne à la variable empty_set. Ensuite, il affiche la valeur de empty_set et son type en utilisant la fonction type().
Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_set.py
```
Vous devriez voir la sortie suivante :
```
set()
<class 'set'>
```
La sortie set() indique que vous avez créé avec succès un ensemble vide. <class 'set'> confirme que la variable empty_set est bien un objet ensemble.

Un ensemble vide est différent de None ou d'une liste vide []. C'est un type spécifique de collection qui représente l'absence d'éléments. Comprendre comment créer et utiliser des ensembles vides est crucial pour diverses tâches de programmation, comme l'initialisation d'une collection avant d'ajouter des éléments ou la vérification si un ensemble est vide avant d'effectuer certaines opérations.

Utilisez la fonction `len()` pour vérifier

Dans cette étape, vous apprendrez à utiliser la fonction len() pour vérifier si un ensemble (set) est vide. La fonction len() renvoie le nombre d'éléments dans un ensemble. Pour un ensemble vide, elle renverra 0. C'est un moyen utile de déterminer de manière programmée si un ensemble contient des éléments.

En vous appuyant sur l'étape précédente, modifions le fichier empty_set.py pour inclure la fonction len().

Ouvrez le fichier empty_set.py dans l'éditeur VS Code. Il devrait se trouver dans le répertoire ~/project.
Modifiez le fichier empty_set.py pour inclure le code Python suivant :
```
## Create an empty set
empty_set = set()

## Print the empty set
print(empty_set)

## Check the type of the variable
print(type(empty_set))

## Check the length of the empty set
print(len(empty_set))
```
Dans ce code, nous avons ajouté une ligne qui utilise la fonction len() pour déterminer le nombre d'éléments dans empty_set et affiche le résultat.
Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_set.py
```
Vous devriez voir la sortie suivante :
```
set()
<class 'set'>
0
```
La sortie 0 confirme que la fonction len() indique correctement que l'ensemble vide a zéro élément.

Vous pouvez également utiliser len() pour vérifier la taille d'ensembles non vides. Par exemple, si vous ajoutez des éléments à l'ensemble, len() renverra le nombre d'éléments ajoutés. Cela fait de len() un outil polyvalent pour travailler avec des ensembles en Python.

Évaluation en tant que valeur booléenne

Dans cette étape, vous apprendrez comment un ensemble vide est évalué en tant que valeur booléenne en Python. En Python, certaines valeurs sont considérées comme « vraies » (elles s'évaluent à True dans un contexte booléen) et d'autres sont considérées comme « fausses » (elles s'évaluent à False). Un ensemble vide est considéré comme une valeur « fausse ». Cela signifie que lorsque vous utilisez un ensemble vide dans une instruction conditionnelle (comme une instruction if), il sera traité comme False.

Modifions le fichier empty_set.py pour démontrer ce comportement.

Ouvrez le fichier empty_set.py dans l'éditeur VS Code. Il devrait se trouver dans le répertoire ~/project.

Modifiez le fichier empty_set.py pour inclure le code Python suivant :

## Create an empty set
empty_set = set()

## Print the empty set
print(empty_set)

## Check the type of the variable
print(type(empty_set))

## Check the length of the empty set
print(len(empty_set))

## Evaluate the empty set as a boolean
if empty_set:
    print("The set is not empty")
else:
    print("The set is empty")

Dans ce code, nous avons ajouté une instruction if qui vérifie la valeur booléenne de empty_set. Si empty_set est « vrai » (non vide), il affichera « The set is not empty ». Sinon, il affichera « The set is empty ».

Exécutez le script Python en utilisant la commande suivante dans le terminal :
```
python ~/project/empty_set.py
```
Vous devriez voir la sortie suivante :
```
set()
<class 'set'>
0
The set is empty
```
La sortie « The set is empty » confirme que l'ensemble vide est évalué comme False dans un contexte booléen.

Ce comportement est utile pour écrire un code concis et lisible. Par exemple, vous pouvez vérifier si un ensemble a des éléments avant d'effectuer une opération qui nécessite la présence d'éléments. Comprendre comment les ensembles vides sont évalués en tant que valeurs booléennes est un aspect important de l'utilisation des ensembles en Python.

Résumé

Dans ce laboratoire (lab), vous avez appris à propos des ensembles vides en Python et à les créer en utilisant le constructeur set() sans arguments. Vous avez également appris à vérifier qu'une variable est bien un objet ensemble (set) en utilisant la fonction type().

De plus, vous avez commencé à apprendre à utiliser la fonction len() pour déterminer si un ensemble est vide en vérifiant le nombre d'éléments qu'il contient.