Introduction
Bienvenue dans ce laboratoire sur les Ensembles (Sets) Python ! Python fournit plusieurs types de données intégrés pour organiser les données, notamment les listes, les dictionnaires, les tuples et les ensembles (sets).
Selon la documentation officielle de Python, un ensemble est une collection non ordonnée sans éléments dupliqués. Ses utilisations principales sont le test d'appartenance et l'élimination des entrées en double.
Dans ce laboratoire, vous explorerez comment créer, manipuler et utiliser efficacement les ensembles à travers une série d'exercices pratiques.
Initialisation d'un Ensemble
Dans cette étape, vous apprendrez les deux principales façons de créer des ensembles (sets) en Python : en utilisant les accolades {} et la fonction intégrée set(). Il est crucial de comprendre que l'utilisation d'accolades vides {} crée un dictionnaire vide, et non un ensemble vide.
Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez vous familiariser d'abord avec ce laboratoire.
Tout d'abord, ouvrez le fichier step1.py depuis l'explorateur de fichiers à gauche.
Maintenant, copiez et collez le code suivant dans step1.py. Ce code démontre comment créer des ensembles et met en évidence le cas spécial de la création d'un ensemble vide.
## Create set using curly braces or set() function
s_braces = {1, 2, 3}
print(f"Set with braces: {s_braces}, type: {type(s_braces)}")
s_func = set([1, 2, 3])
print(f"Set with function: {s_func}, type: {type(s_func)}")
## Warning: empty {} creates a dictionary, not a set
s_dict = {}
print(f"Empty braces create a: {type(s_dict)}")
## To create an empty set, you must use set()
s_empty = set()
print(f"To create an empty set use set(): {type(s_empty)}")
Enregistrez le fichier, puis exécutez-le depuis le terminal en exécutant la commande suivante :
python3 step1.py
Vous devriez voir la sortie suivante, qui confirme les types des objets créés. Remarquez que {} résulte en <class 'dict'>.
Set with braces: {1, 2, 3}, type: <class 'set'>
Set with function: {1, 2, 3}, type: <class 'set'>
Empty braces create a: <class 'dict'>
To create an empty set use set(): <class 'set'>
Comprendre les Propriétés des Ensembles
Dans cette étape, vous explorerez les propriétés fondamentales des ensembles. Les ensembles sont puissants car ils appliquent automatiquement l'unicité et ne sont pas ordonnés. Cela signifie qu'un ensemble supprimera automatiquement toutes les valeurs dupliquées, et vous ne pouvez pas accéder à ses éléments en utilisant un index.
Ouvrez le fichier step2.py.
Copiez et collez le code suivant dans step2.py. La première partie du code démontre comment les doublons sont gérés, et la seconde partie montre ce qui se passe lorsque vous essayez d'indexer un ensemble.
## Sets automatically remove duplicates
s_duplicates = {1, 2, 3, 2, 3, 4}
print(f"Original with duplicates: {{1, 2, 3, 2, 3, 4}}")
print(f"Set with duplicates removed: {s_duplicates}")
## Sets are unordered and cannot be indexed
print("\nAttempting to access a set by index...")
try:
s = {1, 2, 3}
s[0]
except TypeError as e:
print(f"Error when indexing: {e}")
Maintenant, exécutez le script depuis le terminal :
python3 step2.py
La sortie sera :
Original with duplicates: {1, 2, 3, 2, 3, 4}
Set with duplicates removed: {1, 2, 3, 4}
Attempting to access a set by index...
Error when indexing: 'set' object is not subscriptable
Comme vous pouvez le constater, les doublons 2 et 3 ont été automatiquement supprimés. La tentative d'accéder à s[0] a entraîné une TypeError, confirmant que les ensembles ne prennent pas en charge l'indexation (subscripting).
Ajouter et Mettre à Jour des Éléments
Dans cette étape, vous apprendrez comment ajouter de nouveaux éléments à un ensemble existant. Python fournit deux méthodes principales pour cela : add() pour ajouter un seul élément et update() pour ajouter plusieurs éléments provenant d'un itérable (comme une liste ou un autre ensemble).
Ouvrez le fichier step3.py.
Copiez et collez le code suivant dans step3.py. Ce code créera d'abord un ensemble, puis ajoutera un seul élément, et enfin le mettra à jour avec plusieurs éléments.
## Start with a set
s = {1, 2, 3}
print(f"Original set: {s}")
## add() method: add a single element
s.add(4)
print(f"After adding 4: {s}")
## update() method: add multiple elements from an iterable
s.update([2, 3, 4, 5, 6]) ## Duplicates like 2, 3, 4 are ignored
print(f"After updating with [2, 3, 4, 5, 6]: {s}")
Exécutez le script depuis le terminal :
python3 step3.py
Votre sortie devrait ressembler à ceci. Notez que lors de l'utilisation de update(), tous les éléments déjà présents dans l'ensemble sont simplement ignorés.
Original set: {1, 2, 3}
After adding 4: {1, 2, 3, 4}
After updating with [2, 3, 4, 5, 6]: {1, 2, 3, 4, 5, 6}
Supprimer et Écarter des Éléments
Dans cette étape, vous apprendrez deux façons de supprimer des éléments d'un ensemble : remove() et discard(). Bien que les deux méthodes suppriment un élément, elles se comportent différemment lorsque l'élément est introuvable. remove() lèvera une KeyError, ce qui peut faire planter votre programme si elle n'est pas gérée, tandis que discard() ne fera rien et continuera silencieusement.
Ouvrez le fichier step4.py.
Copiez et collez le code suivant, qui démontre le comportement des deux méthodes.
## remove() method: raises KeyError if element is not found
s = {1, 2, 3}
print(f"Original set: {s}")
s.remove(3)
print(f"After removing 3: {s}")
## Trying to remove an element that doesn't exist with remove()
try:
s.remove(3)
except KeyError as e:
print(f"Error when removing 3 again: KeyError: {e}")
## discard() method: does not raise an error if element is not found
s = {1, 2, 3}
print(f"\nNew original set: {s}")
s.discard(3)
print(f"After discarding 3: {s}")
s.discard(3) ## No error is raised
print(f"After discarding 3 again (no error): {s}")
Exécutez le script depuis le terminal :
python3 step4.py
La sortie montre clairement la différence :
Original set: {1, 2, 3}
After removing 3: {1, 2}
Error when removing 3 again: KeyError: 3
New original set: {1, 2, 3}
After discarding 3: {1, 2}
After discarding 3 again (no error): {1, 2}
Le choix entre remove() et discard() dépend si vous souhaitez que votre programme échoue explicitement lorsqu'un élément est manquant ou s'il doit gérer son absence de manière plus souple (gracefully).
Opérations sur les Ensembles (Set Operations)
Dans cette dernière étape, vous pratiquerez les opérations sur les ensembles (set operations) les plus courantes. Ces opérations vous permettent de combiner et de comparer des ensembles de manière puissante. Vous utiliserez à la fois la syntaxe par méthode (ex: s1.union(s2)) et la syntaxe par opérateur (ex: s1 | s2).
- Union (
union()ou|) : Crée un nouvel ensemble contenant tous les éléments des ensembles fournis. - Intersection (
intersection()ou&) : Retourne un nouvel ensemble contenant uniquement les éléments communs à tous les ensembles. - Différence (
difference()ou-) : Retourne un nouvel ensemble contenant les éléments qui sont dans le premier ensemble mais pas dans le second. - Différence Symétrique (
symmetric_difference()ou^) : Retourne un nouvel ensemble contenant les éléments qui sont dans l'un ou l'autre ensemble, mais pas dans les deux.
Ouvrez le fichier step5.py.
Copiez et collez le code suivant pour effectuer ces quatre opérations sur deux ensembles d'exemple.
s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(f"s1 = {s1}")
print(f"s2 = {s2}\n")
## union() or |
## Returns a new set containing all items from both sets.
print(f"Union (s1 | s2): {s1.union(s2)}")
## intersection() or &
## Returns a new set containing items common to both sets.
s3 = {3, 4, 5}
print(f"Intersection (s1 & s2): {s1.intersection(s2)}")
## difference() or -
## Returns a new set containing items in the first set but not in the second.
print(f"Difference (s1 - s2): {s1.difference(s2)}")
print(f"Difference (s2 - s1): {s2.difference(s1)}")
## symmetric_difference() or ^
## Returns a new set with elements in either set, but not both.
print(f"Symmetric Difference (s1 ^ s2): {s1.symmetric_difference(s2)}")
Exécutez le script depuis le terminal :
python3 step5.py
Examinez la sortie pour comprendre le résultat de chaque opération :
s1 = {1, 2, 3}
s2 = {2, 3, 4}
Union (s1 | s2): {1, 2, 3, 4}
Intersection (s1 & s2): {2, 3}
Difference (s1 - s2): {1}
Difference (s2 - s1): {4}
Symmetric Difference (s1 ^ s2): {1, 4}
Résumé
Dans ce laboratoire, vous avez appris les fondamentaux des ensembles (sets) en Python. Vous avez commencé par initialiser des ensembles en utilisant à la fois les accolades {} et la fonction set(), notant la distinction importante pour la création d'ensembles vides. Vous avez exploré les propriétés fondamentales des ensembles : ils sont non ordonnés et ne stockent que des éléments uniques. Vous vous êtes exercé à modifier les ensembles en ajoutant des éléments avec add() et update(), et en les supprimant avec les méthodes remove() et discard(), en comprenant la différence clé entre elles. Enfin, vous avez effectué des opérations essentielles sur les ensembles, notamment l'union (|), l'intersection (&), la différence (-) et la différence symétrique (^). Vous disposez maintenant d'une base solide pour utiliser les ensembles afin de gérer des collections d'éléments uniques dans vos programmes Python.
