Comment vérifier si un ensemble (set) contient des éléments uniques en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un ensemble (set) contient des éléments uniques en Python. Les ensembles sont un type de données intégré qui stockent des collections non ordonnées d'éléments uniques, éliminant automatiquement les doublons. Vous commencerez par créer et afficher des ensembles, en observant comment les valeurs en double sont gérées.

Le laboratoire approfondira ensuite les propriétés des ensembles, en explorant comment tirer parti de leurs caractéristiques uniques pour des tâches telles que la suppression d'entrées en double ou la vérification de la présence d'un élément. Vous apprendrez à vérifier l'unicité en utilisant les méthodes len() et le comptage des éléments.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) 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/sets -.-> lab-559561{{"Comment vérifier si un ensemble (set) contient des éléments uniques en Python"}} python/build_in_functions -.-> lab-559561{{"Comment vérifier si un ensemble (set) contient des éléments uniques en Python"}} python/data_collections -.-> lab-559561{{"Comment vérifier si un ensemble (set) contient des éléments uniques en Python"}} end

Apprendre sur l'unicité des ensembles (sets)

Dans cette étape, vous apprendrez le concept fondamental de l'unicité des ensembles (sets) en Python. Les ensembles sont un type de données intégré en Python qui stockent une collection non ordonnée d'éléments uniques. Cela signifie qu'un ensemble ne peut pas contenir de valeurs en double. Comprendre cette propriété est crucial pour gérer et manipuler efficacement des données où l'unicité est importante.

Commençons par créer un ensemble simple :

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Créez un nouveau fichier nommé set_example.py dans le répertoire ~/project.

## Create a set of numbers
my_set = {1, 2, 3, 4, 5}

## Print the set
print(my_set)

Enregistrez le fichier.
Exécutez le script en utilisant la commande python dans le terminal :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
{1, 2, 3, 4, 5}
```

Maintenant, voyons ce qui se passe lorsque nous essayons d'ajouter des éléments en double à un ensemble :

Modifiez le fichier set_example.py pour inclure des valeurs en double :

## Create a set with duplicate numbers
my_set = {1, 2, 2, 3, 4, 4, 5}

## Print the set
print(my_set)

Enregistrez le fichier.
Exécutez le script à nouveau :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
{1, 2, 3, 4, 5}
```

Remarquez que même si nous avons essayé d'ajouter des valeurs en double (2 et 4), l'ensemble ne contient que des éléments uniques. Cela démontre la propriété essentielle des ensembles : ils éliminent automatiquement les doublons.

Cette propriété d'unicité rend les ensembles très utiles pour des tâches telles que la suppression d'entrées en double d'une liste ou la vérification si un élément est déjà présent dans une collection. Dans les étapes suivantes, nous explorerons davantage les applications des ensembles et comment tirer parti de leurs caractéristiques uniques.

Comprendre les propriétés des ensembles (sets)

Dans cette étape, nous approfondirons les propriétés des ensembles (sets) en Python. Les ensembles ne sont pas seulement des collections d'éléments uniques ; ils prennent également en charge diverses opérations qui en font un outil puissant pour la manipulation de données. Nous explorerons comment ajouter des éléments, supprimer des éléments et effectuer des opérations d'ensemble courantes telles que l'union, l'intersection et la différence.

Commençons par ajouter des éléments à un ensemble :

Ouvrez le fichier set_example.py dans le répertoire ~/project à l'aide de l'éditeur VS Code.

Modifiez le fichier pour ajouter des éléments à l'ensemble en utilisant la méthode add() :

## Create a set
my_set = {1, 2, 3}

## Add elements to the set
my_set.add(4)
my_set.add(5)

## Print the set
print(my_set)

Enregistrez le fichier.
Exécutez le script en utilisant la commande python dans le terminal :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
{1, 2, 3, 4, 5}
```

Maintenant, voyons comment supprimer des éléments d'un ensemble :

Modifiez le fichier set_example.py pour supprimer un élément en utilisant la méthode remove() :

## Create a set
my_set = {1, 2, 3, 4, 5}

## Remove an element from the set
my_set.remove(3)

## Print the set
print(my_set)

Enregistrez le fichier.
Exécutez le script à nouveau :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
{1, 2, 4, 5}
```

Notez que si vous essayez de supprimer un élément qui n'est pas dans l'ensemble, une erreur KeyError sera levée. Pour éviter cela, vous pouvez utiliser la méthode discard(), qui ne lève pas d'erreur si l'élément n'est pas présent.

```python
## Create a set
my_set = {1, 2, 3, 4, 5}

## Discard an element from the set
my_set.discard(6) ## No error raised

## Print the set
print(my_set)
```

Enfin, explorons quelques opérations d'ensemble courantes :

Modifiez le fichier set_example.py pour effectuer des opérations d'union, d'intersection et de différence :

## Create two sets
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

## Union of the sets
union_set = set1.union(set2)
print("Union:", union_set)

## Intersection of the sets
intersection_set = set1.intersection(set2)
print("Intersection:", intersection_set)

## Difference of the sets (elements in set1 but not in set2)
difference_set = set1.difference(set2)
print("Difference:", difference_set)

Enregistrez le fichier.

Exécutez le script à nouveau :

python set_example.py

Vous devriez voir la sortie suivante :

Union: {1, 2, 3, 4, 5, 6, 7}
Intersection: {3, 4, 5}
Difference: {1, 2}

Comprendre ces propriétés et opérations d'ensemble vous permettra d'utiliser efficacement les ensembles pour diverses tâches de manipulation de données en Python.

Vérifier avec len() et le nombre d'éléments

Dans cette étape, nous apprendrons à vérifier les propriétés d'un ensemble (set) en utilisant la fonction len() et en vérifiant la présence d'éléments spécifiques. La fonction len() renvoie le nombre d'éléments dans un ensemble, et nous pouvons utiliser l'opérateur in pour vérifier si un élément est présent dans un ensemble. Ces techniques sont utiles pour valider l'état d'un ensemble après avoir effectué des opérations.

Commençons par utiliser la fonction len() pour déterminer la taille d'un ensemble :

Ouvrez le fichier set_example.py dans le répertoire ~/project à l'aide de l'éditeur VS Code.

Modifiez le fichier pour utiliser la fonction len() afin d'afficher le nombre d'éléments dans l'ensemble :

## Create a set
my_set = {1, 2, 3, 4, 5}

## Get the number of elements in the set
set_length = len(my_set)

## Print the length of the set
print("Length of the set:", set_length)

Enregistrez le fichier.
Exécutez le script en utilisant la commande python dans le terminal :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
Length of the set: 5
```

Maintenant, voyons comment vérifier si un élément est présent dans un ensemble en utilisant l'opérateur in :

Modifiez le fichier set_example.py pour vérifier la présence d'éléments spécifiques :

## Create a set
my_set = {1, 2, 3, 4, 5}

## Check if an element is in the set
if 3 in my_set:
    print("3 is in the set")
else:
    print("3 is not in the set")

## Check if an element is not in the set
if 6 in my_set:
    print("6 is in the set")
else:
    print("6 is not in the set")

Enregistrez le fichier.
Exécutez le script à nouveau :
```
python set_example.py
```
Vous devriez voir la sortie suivante :
```
3 is in the set
6 is not in the set
```

En combinant la fonction len() et l'opérateur in, vous pouvez efficacement vérifier les propriétés d'un ensemble et vous assurer qu'il contient les éléments attendus. Cela est particulièrement utile lorsque vous travaillez avec des ensembles dans des programmes plus complexes où vous devez valider l'état de vos données.

Résumé

Dans ce laboratoire (lab), vous commencez par apprendre le concept fondamental de l'unicité des ensembles (sets) en Python. Les ensembles sont présentés comme un type de données intégré qui stocke des collections non ordonnées d'éléments uniques, éliminant automatiquement les doublons. Vous créez un script Python pour démontrer cette propriété, en observant que l'ajout de valeurs en double à un ensemble ne conduit pas à ce que ces doublons soient stockés.

Le laboratoire poursuit ensuite en approfondissant les propriétés des ensembles, soulignant qu'ils sont plus que de simples collections d'éléments uniques. (Le contenu fourni est tronqué, donc cela repose sur l'hypothèse que l'étape suivante s'appuie sur la compréhension initiale de l'unicité des ensembles.)