Travailler avec les Ensembles (Sets) en Python

PythonBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique avec les ensembles (sets) en Python. Les ensembles sont une structure de données fondamentale utilisée pour stocker des éléments uniques et non ordonnés. Ils sont très efficaces pour des tâches telles que vérifier si un élément est présent dans une collection et pour effectuer des opérations mathématiques sur les ensembles.

Vous apprendrez à créer des ensembles, à ajouter et à supprimer des éléments, et à effectuer des opérations courantes comme l'union, l'intersection et la différence. Enfin, vous verrez une application pratique des ensembles en les utilisant pour supprimer facilement les éléments dupliqués d'une liste.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 100%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Créer un Ensemble et Ajouter des Éléments

Dans cette première étape, vous apprendrez à créer des ensembles (sets) et à y ajouter de nouveaux éléments. Les ensembles sont des collections d'éléments uniques, ce qui signifie qu'ils rejettent automatiquement les doublons.

Votre environnement inclut un fichier vide nommé set_basics.py. En utilisant l'explorateur de fichiers sur le côté gauche de l'éditeur, trouvez et ouvrez ~/project/set_basics.py.

Ajoutez le code Python suivant au fichier. Ce code démontre plusieurs façons de créer un ensemble.

## Méthode 1 : Utilisation des accolades {}
## Ceci crée un ensemble avec des éléments initiaux.
my_set = {'apple', 'banana', 'cherry'}
print("Ensemble créé avec des accolades:", my_set)
print("Type de my_set:", type(my_set))

## Note : Les ensembles suppriment automatiquement les éléments en double.
duplicate_set = {'apple', 'banana', 'apple'}
print("Ensemble avec doublons:", duplicate_set)

## Méthode 2 : Utilisation du constructeur set() sur un itérable (comme une chaîne de caractères)
## Ceci crée un ensemble à partir des caractères uniques de la chaîne.
char_set = set('hello world')
print("Ensemble à partir d'une chaîne:", char_set)

## Méthode 3 : Création d'un ensemble vide
## Vous devez utiliser set() pour créer un ensemble vide. {} crée un dictionnaire vide.
empty_set = set()
print("Un ensemble vide:", empty_set)
print("Type de empty_set:", type(empty_set))

Enregistrez le fichier. Ouvrez maintenant un terminal dans votre éditeur (vous pouvez utiliser le menu : Terminal -> New Terminal) et exécutez votre script avec la commande suivante.

python ~/project/set_basics.py

Vous verrez une sortie similaire à ce qui suit. Notez que l'ordre des éléments dans un ensemble n'est pas garanti et que les doublons sont supprimés.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

Ensuite, ajoutons de nouveaux éléments à un ensemble existant. Vous pouvez ajouter un seul élément avec la méthode add() ou plusieurs éléments avec la méthode update().

Ajoutez le code suivant au bas de votre fichier set_basics.py.

## --- Ajout d'éléments ---
fruits = {'apple', 'banana'}
print("\nEnsemble de fruits original:", fruits)

## Utiliser add() pour ajouter un seul élément
fruits.add('orange')
print("Après ajout de 'orange':", fruits)

## add() n'a aucun effet si l'élément est déjà présent
fruits.add('apple')
print("Après ajout de 'apple' à nouveau:", fruits)

## Utiliser update() pour ajouter plusieurs éléments à partir d'un itérable (comme une liste)
fruits.update(['mango', 'grape'])
print("Après mise à jour avec une liste:", fruits)

Enregistrez à nouveau le fichier et exécutez le script mis à jour depuis le terminal.

python ~/project/set_basics.py

La sortie inclura désormais les résultats de l'ajout d'éléments.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

Original fruits set: {'banana', 'apple'}
After adding 'orange': {'banana', 'orange', 'apple'}
After adding 'apple' again: {'banana', 'orange', 'apple'}
After updating with a list: {'grape', 'mango', 'banana', 'orange', 'apple'}

Vous avez maintenant appris à créer des ensembles et à les modifier en y ajoutant de nouveaux éléments.

Supprimer des Éléments d'un Ensemble

Dans cette étape, vous apprendrez les différentes manières de supprimer des éléments d'un ensemble. Comme les ensembles ne sont pas ordonnés, vous ne pouvez pas utiliser un index pour supprimer des éléments. Au lieu de cela, Python fournit des méthodes spécifiques à cet effet.

Trouvez et ouvrez le fichier set_removal.py dans votre répertoire ~/project.

Ajoutez le code suivant au fichier. Il démontre les méthodes remove(), discard(), pop() et clear().

## --- Suppression d'éléments ---
my_set = {'a', 'b', 'c', 'd', 'e'}
print("Ensemble original:", my_set)

## Méthode 1 : remove()
## Ceci supprime un élément spécifié. Cela lève une KeyError si l'élément n'est pas trouvé.
my_set.remove('b')
print("Après suppression de 'b':", my_set)
## La ligne suivante provoquerait une erreur : my_set.remove('z')

## Méthode 2 : discard()
## Ceci supprime également un élément spécifié, mais NE lève PAS d'erreur si l'élément n'est pas trouvé.
print("\nEnsemble de départ pour discard:", my_set)
my_set.discard('c')
print("Après avoir écarté 'c':", my_set)
my_set.discard('z') ## 'z' n'est pas dans l'ensemble, mais aucune erreur ne se produit.
print("Après avoir écarté 'z' (inexistant):", my_set)

## Méthode 3 : pop()
## Ceci supprime et retourne un élément arbitraire de l'ensemble.
## Comme les ensembles ne sont pas ordonnés, vous ne savez pas quel élément sera retiré.
print("\nEnsemble de départ pour pop:", my_set)
popped_item = my_set.pop()
print("Élément retiré (popped):", popped_item)
print("Ensemble après pop():", my_set)

## Méthode 4 : clear()
## Ceci supprime tous les éléments de l'ensemble, laissant un ensemble vide.
print("\nEnsemble de départ pour clear:", my_set)
my_set.clear()
print("Ensemble après clear():", my_set)

Enregistrez le fichier. Exécutez maintenant le script depuis votre terminal.

python ~/project/set_removal.py

Votre sortie devrait ressembler à ceci. L'élément supprimé par pop() peut être différent à chaque fois que vous exécutez le script car les ensembles ne sont pas ordonnés.

Original set: {'d', 'c', 'e', 'a', 'b'}
After removing 'b': {'d', 'c', 'e', 'a'}

Starting set for discard: {'d', 'c', 'e', 'a'}
After discarding 'c': {'d', 'e', 'a'}
After discarding 'z' (non-existent): {'d', 'e', 'a'}

Starting set for pop: {'d', 'e', 'a'}
Popped item: d
Set after pop(): {'e', 'a'}

Starting set for clear: {'e', 'a'}
Set after clear(): set()

Vous connaissez maintenant les méthodes clés pour supprimer des éléments d'un ensemble et comprenez la différence importante entre remove() et discard().

Effectuer des Opérations sur les Ensembles

Les ensembles sont particulièrement puissants pour effectuer des opérations mathématiques telles que l'union, l'intersection et la différence. Dans cette étape, vous apprendrez à effectuer ces opérations en Python.

Trouvez et ouvrez le fichier set_operations.py dans votre répertoire ~/project.

Ajoutez le code suivant au fichier. Ce code définit deux ensembles, puis effectue les trois principales opérations d'ensemble sur eux.

set_a = {'a', 'b', 'c', 'd'}
set_b = {'c', 'd', 'e', 'f'}

print("Ensemble A:", set_a)
print("Ensemble B:", set_b)

## --- Union (Réunion) ---
## L'union contient tous les éléments uniques des deux ensembles.
## Vous pouvez utiliser l'opérateur | ou la méthode .union().
union_set_op = set_a | set_b
union_set_method = set_a.union(set_b)
print("\nUnion avec l'opérateur |:", union_set_op)
print("Union avec la méthode .union():", union_set_method)

## --- Intersection ---
## L'intersection contient uniquement les éléments communs aux deux ensembles.
## Vous pouvez utiliser l'opérateur & ou la méthode .intersection().
intersection_set_op = set_a & set_b
intersection_set_method = set_a.intersection(set_b)
print("\nIntersection avec l'opérateur &:", intersection_set_op)
print("Intersection avec la méthode .intersection():", intersection_set_method)

## --- Différence ---
## La différence contient les éléments qui sont dans le premier ensemble mais PAS dans le second.
## Vous pouvez utiliser l'opérateur - ou la méthode .difference().
difference_set_op = set_a - set_b
difference_set_method = set_a.difference(set_b)
print("\nDifférence (A - B) avec l'opérateur -:", difference_set_op)
print("Différence (A - B) avec la méthode .difference():", difference_set_method)

## Notez que l'ordre est important pour la différence
difference_b_a = set_b - set_a
print("Différence (B - A):", difference_b_a)

Enregistrez le fichier et exécutez-le depuis le terminal.

python ~/project/set_operations.py

La sortie affichera clairement les résultats de chaque opération.

Set A: {'d', 'c', 'a', 'b'}
Set B: {'d', 'c', 'f', 'e'}

Union with | operator: {'d', 'c', 'f', 'e', 'a', 'b'}
Union with .union() method: {'d', 'c', 'f', 'e', 'a', 'b'}

Intersection with & operator: {'d', 'c'}
Intersection with .intersection() method: {'d', 'c'}

Difference (A - B) with - operator: {'a', 'b'}
Difference (A - B) with .difference() method: {'a', 'b'}
Difference (B - A): {'f', 'e'}

Vous avez réussi à utiliser à la fois les symboles d'opérateur et les méthodes pour effectuer les opérations d'union, d'intersection et de différence sur les ensembles.

Utiliser un Ensemble pour Supprimer les Doublons d'une Liste

L'une des utilisations les plus courantes et pratiques des ensembles est de supprimer rapidement les éléments dupliqués d'une liste. Étant donné que les ensembles ne peuvent contenir que des éléments uniques, convertir une liste en ensemble, puis reconvertir cet ensemble en liste, est une manière simple et efficace d'y parvenir.

Trouvez et ouvrez le fichier final de ce laboratoire, remove_duplicates.py, dans votre répertoire ~/project.

Ajoutez le code suivant au fichier.

## Une liste contenant plusieurs nombres en double
numbers_list = [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
print("Liste originale avec doublons:", numbers_list)

## Étape 1 : Convertir la liste en ensemble (set).
## Ceci supprime automatiquement tous les éléments dupliqués.
unique_numbers_set = set(numbers_list)
print("Ensemble créé à partir de la liste (doublons supprimés):", unique_numbers_set)

## Étape 2 : Reconvertir l'ensemble en liste (list).
## La nouvelle liste ne contiendra que les éléments uniques.
unique_numbers_list = list(unique_numbers_set)
print("Liste finale sans doublons:", unique_numbers_list)

## Note : Ce processus ne préserve pas l'ordre original des éléments
## car les ensembles sont une structure de données non ordonnée.

Enregistrez le fichier et exécutez-le depuis le terminal.

python ~/project/remove_duplicates.py

La sortie démontre l'ensemble du processus, montrant la liste originale, l'ensemble intermédiaire et la liste finale, débarrassée des doublons.

Original list with duplicates: [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
Set created from list (duplicates gone): {1, 2, 3, 4, 5}
Final list with duplicates removed: [1, 2, 3, 4, 5]

Vous avez réussi à appliquer vos connaissances sur les ensembles pour résoudre un problème de programmation courant : supprimer les doublons d'une liste.

Résumé

Dans ce laboratoire, vous avez acquis les compétences essentielles pour travailler avec les ensembles (sets) en Python. Vous avez commencé par créer des ensembles en utilisant différentes syntaxes et avez appris comment ils imposent intrinsèquement l'unicité. Vous vous êtes exercé à modifier les ensembles en ajoutant des éléments avec add() et update(), et en les supprimant avec remove(), discard(), pop(), et clear(), en notant les différences clés entre ces méthodes.

De plus, vous avez exploré les opérations mathématiques fondamentales sur les ensembles — l'union (|), l'intersection (&) et la différence (-) — qui sont cruciales pour l'analyse de données et la conception d'algorithmes. Enfin, vous avez mis ces connaissances en pratique en implémentant une technique élégante pour supprimer les éléments dupliqués d'une liste, une tâche courante dans le nettoyage et la préparation des données. Vous êtes maintenant équipé pour utiliser efficacement les ensembles dans vos programmes Python.