Dans ce guide, vous explorerez les principes fondamentaux des ensembles en Python, ainsi que les diverses méthodes associées pour les modifier.
Les ensembles figurent parmi les structures de données intrinsèques à Python. Ils s’avèrent particulièrement utiles lorsque vous travaillez avec des collections d’éléments uniques, sans doublons.
Nous allons détailler les aspects essentiels des ensembles Python, leurs méthodes d’utilisation, et comment exécuter des opérations courantes sur ces ensembles.
C’est parti !
Fondamentaux des Ensembles Python
En Python, un ensemble représente une collection non ordonnée d’éléments distincts. Cela signifie qu’aucun élément ne peut être dupliqué au sein d’un même ensemble.
Vous avez la possibilité d’ajouter et de supprimer des éléments d’un ensemble, ce qui en fait une collection mutable. Ces ensembles peuvent contenir divers types de données, à condition que chaque élément soit hachable.
En Python, un objet est considéré comme hachable si sa valeur de hachage demeure constante. La plupart des objets immuables comme les chaînes, les tuples et les dictionnaires sont hachables.
Nous allons maintenant examiner la création d’ensembles. Pour commencer, étudions les deux exemples ci-dessous :
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Résultat
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Le premier ensemble comprend trois nombres, un tuple et une chaîne. Son initialisation se fait sans problème. Le second ensemble remplace le tuple par une liste. Une liste étant modifiable, elle n’est pas hachable, ce qui provoque une erreur TypeError lors de l’initialisation.
📑 En résumé, un ensemble Python est une collection mutable d’éléments uniques et hachables.
Comment Créer un Ensemble en Python
Voyons comment créer des ensembles en Python.
#1. Utilisation de l’Initialisation Explicite
Pour créer un ensemble, vous pouvez simplement énumérer ses éléments, séparés par des virgules (,) et les encadrer par des accolades {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Résultat
set
Si vous avez déjà manipulé des listes Python, vous savez que [] initialise une liste vide. Bien qu’un ensemble Python utilise des accolades {}, vous ne pouvez pas employer une paire {} pour initialiser un ensemble. En effet, {} sert à créer un dictionnaire Python et non un ensemble.
py_set2 = {}
type(py_set2)
# Résultat
dict
La fonction `type()` permet de confirmer que `py_set2` est bien un dictionnaire (dict).
#2. Utilisation de la Fonction `set()`
Pour initialiser un ensemble vide auquel vous ajouterez des éléments par la suite, utilisez la fonction `set()`.
py_set3 = set() type(py_set3) # Résultat set
#3. Conversion d’Autres Itérables en Ensemble
Vous pouvez aussi créer des ensembles en convertissant des itérables comme les listes et les tuples via `set(iterable)`.
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # l'élément 'C' en doublon a été retiré
type(py_set4)
# set
Dans cet exemple, `py_list` contient ‘C’ deux fois. Cependant, ‘C’ n’apparaît qu’une seule fois dans `py_set4`, car un ensemble ne contient que des éléments uniques. Cette méthode est couramment employée pour éliminer les doublons des listes Python.
Comment Ajouter des Éléments à un Ensemble Python
Créons un ensemble vide nommé `py_set` que nous utiliserons dans la suite de ce tutoriel.
py_set = set() len(py_set) # retourne la longueur d'un ensemble # Résultat 0
#1. Utilisation de la Méthode `.add()`
Pour ajouter des éléments, utilisez la méthode `.add()`. La syntaxe `set.add(element)` ajoute un élément à l’ensemble.
Pour plus de clarté, nous allons ajouter des éléments à l’ensemble Python et l’afficher à chaque étape.
▶️ Ajoutons la chaîne ‘Python’ à `py_set`.
py_set.add('Python')
print(py_set)
# Résultat
{'Python'}
Ensuite, ajoutons un autre élément.
py_set.add('C++')
print(py_set)
# Résultat
{'Python', 'C++'}
Il est crucial de comprendre que `.add()` n’ajoute un élément que s’il n’est pas déjà présent. Si l’élément à ajouter est déjà dans l’ensemble, l’opération n’a aucun effet.
Pour vérifier cela, essayons d’ajouter ‘C++’ à `py_set`.
py_set.add('C++')
print(py_set)
# Résultat
{'Python', 'C++'}
Puisque ‘C++’ est déjà présent, l’opération n’a aucun effet.
▶️ Ajoutons quelques éléments supplémentaires.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Résultat
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Utilisation de la Méthode `.update()`
Jusqu’à présent, nous avons vu comment ajouter des éléments individuellement.
Comment faire pour ajouter plusieurs éléments simultanément ?
Vous pouvez utiliser la méthode `.update()` avec la syntaxe : `set.update(collection)`, qui ajoute tous les éléments de la collection à l’ensemble. La collection peut être une liste, un tuple, un dictionnaire, etc.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Résultat
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Cette méthode est utile pour ajouter une collection d’éléments sans créer un nouvel objet en mémoire.
Dans la section suivante, apprenons à supprimer des éléments d’un ensemble.
Comment Supprimer des Éléments d’un Ensemble Python
Considérons l’ensemble suivant (l’état de `py_set` avant l’opération `.update()` ci-dessus).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Utilisation de la Méthode `.pop()`
`set.pop()` supprime un élément aléatoire de l’ensemble et le retourne. Voyons ce que renvoie cette méthode appliquée à `py_set`.
py_set.pop() # Résultat 'Rust'
Cette fois, l’appel à `.pop()` a renvoyé la chaîne ‘Rust’.
Note : Comme `.pop()` retourne un élément aléatoirement, vous obtiendrez peut-être un élément différent en exécutant le code de votre côté.
Si nous examinons l’ensemble, ‘Rust’ n’est plus présent.
print(py_set)
# Résultat
{'JavaScript', 'Python', 'C++', 'C'}
#2. Utilisation des Méthodes `.remove()` et `.discard()`
En pratique, vous aurez souvent besoin de supprimer des éléments spécifiques. Pour cela, vous pouvez utiliser `.remove()` ou `.discard()`.
`set.remove(element)` supprime l’élément spécifié.
py_set.remove('C')
print(py_set)
# Résultat
{'JavaScript', 'Python', 'C++'}
Si l’on tente de supprimer un élément absent de l’ensemble, une KeyError est déclenchée.
py_set.remove('Scala')
# Résultat
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Regardons à nouveau `py_set`. Il contient désormais trois éléments.
print(py_set)
# Résultat
{'JavaScript', 'Python', 'C++'}
Avec la syntaxe `set.discard(element)`, `.discard()` supprime aussi des éléments.
py_set.discard('C++')
print(py_set)
# Résultat
{'JavaScript', 'Python'}
Cependant, cette méthode diffère de `.remove()` en ce qu’elle n’engendre pas d’erreur KeyError si l’élément à supprimer n’est pas présent.
Si nous tentons de supprimer ‘Scala’ (qui n’existe pas) avec `.discard()`, aucune erreur n’est levée.
py_set.discard('Scala') # aucune erreur !
print(py_set)
# Résultat
{'JavaScript', 'Python'}
Comment Accéder aux Éléments d’un Ensemble Python
Jusqu’à présent, nous avons vu comment ajouter et supprimer des éléments des ensembles. Mais nous n’avons pas encore abordé la manière d’accéder à un élément spécifique.
Comme un ensemble est non ordonné, l’indexation n’est pas possible. Tenter d’accéder aux éléments par leur index provoquera une erreur, comme illustré.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Résultat
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Alors, comment accéder aux éléments ?
Deux méthodes sont couramment utilisées :
- Parcourir l’ensemble et accéder à chaque élément.
- Vérifier la présence d’un élément spécifique.
▶️ Parcourir l’ensemble à l’aide d’une boucle for.
for elt in py_set: print(elt) # Résultat C++ JavaScript Python Rust C
En pratique, vous pouvez vérifier si un élément donné est présent dans l’ensemble grâce à l’opérateur `in`.
Note : L’expression `element in set` retourne True si l’élément est présent, sinon, elle retourne False.
Dans cet exemple, `py_set` contient ‘C++’ mais pas ‘Julia’. L’opérateur `in` retourne donc True pour le premier et False pour le second.
'C++' in py_set # True 'Julia' in py_set # False
Comment Déterminer la Longueur d’un Ensemble Python
Comme nous l’avons vu précédemment, la fonction `len()` permet de connaître le nombre d’éléments présents dans un ensemble.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Résultat: 5
Comment Vider un Ensemble Python
Pour supprimer tous les éléments d’un ensemble, utilisez la méthode `.clear()`.
Appliquons la méthode `.clear()` sur `py_set`.
py_set.clear()
Si vous affichez l’ensemble, vous obtiendrez `set()` – signifiant qu’il est vide. Vous pouvez également utiliser `len()` pour confirmer que la longueur de l’ensemble est nulle.
print(py_set) # set() print(len(py_set)) # 0
Jusqu’à présent, nous avons appris les opérations CRUD de base sur les ensembles Python :
- Créer : utiliser `set()`, la conversion de type et l’initialisation.
- Lire : accéder aux éléments via les boucles et les tests d’appartenance avec l’opérateur `in`.
- Mettre à jour : ajouter et supprimer des éléments, ainsi que mettre à jour l’ensemble.
- Supprimer : vider l’ensemble de tous ses éléments.
Opérations Courantes sur les Ensembles, Expliquées avec du Code Python
Les ensembles Python permettent également d’effectuer des opérations d’ensemble classiques. Examinons ces opérations dans cette section.
#1. Union d’Ensembles en Python
En théorie des ensembles, l’union de deux ensembles est l’ensemble de tous les éléments appartenant à au moins un des deux ensembles. Si nous avons deux ensembles, A et B, leur union contient les éléments de A, ceux de B, et ceux qui sont présents à la fois dans A et B.
Pour obtenir l’union d’ensembles, vous pouvez utiliser l’opérateur `|` ou la méthode `.union()` avec la syntaxe `setA.union(setB)`.
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
L’union d’ensembles est une opération commutative ; donc AUB est identique à BUA. Vérifions cela en inversant l’ordre de `setA` et `setB` dans l’appel de `.union()`.
setB.union(setA)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Intersection d’Ensembles en Python
Une autre opération d’ensemble est l’intersection de deux ensembles, A et B. L’intersection d’ensembles retourne un ensemble contenant tous les éléments présents à la fois dans A et B.
Pour calculer l’intersection, vous pouvez utiliser l’opérateur `&` ou la méthode `.intersection()`, comme le montre le code ci-dessous.
print(setA & setB)
# Résultat
{9}
setA.intersection(setB)
# Résultat
{9}
Dans cet exemple, l’élément 9 est présent à la fois dans `setA` et `setB`. L’ensemble d’intersection ne contient donc que cet élément.
Comme l’union, l’intersection d’ensembles est aussi une opération commutative.
setB.intersection(setA)
# Résultat
{9}
#3. Différence d’Ensembles en Python
L’union et l’intersection permettent de trouver les éléments qui appartiennent aux deux ensembles ou à au moins l’un d’eux. La différence d’ensembles, quant à elle, nous aide à trouver les éléments présents dans un ensemble, mais pas dans l’autre.
– `setA.difference(setB)` donne l’ensemble des éléments présents uniquement dans `setA` et non dans `setB`.
– `setB.difference(setA)` donne l’ensemble des éléments présents uniquement dans `setB` et non dans `setA`.
print(setA - setB)
print(setB - setA)
# Résultat
{1, 3, 5, 7}
{8, 2, 4, 6}
Évidemment, A-B n’est pas identique à B-A, donc la différence d’ensembles n’est pas une opération commutative.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Différence Symétrique d’Ensembles en Python
Tandis que l’intersection nous donne les éléments communs aux deux ensembles, la différence symétrique retourne l’ensemble des éléments présents dans exactement un seul des deux ensembles.
Prenons l’exemple suivant.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Pour calculer la différence symétrique, utilisez l’opérateur `^` ou la méthode `.symmetric_difference()`.
print(setA ^ setB)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8}
Les éléments 10 et 12 sont présents à la fois dans `setA` et `setB`, ils ne figurent donc pas dans l’ensemble de différence symétrique.
setA.symmetric_difference(setB)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8}
Comme la différence symétrique inclut tous les éléments qui apparaissent dans un seul des ensembles, le résultat est le même quel que soit l’ordre des ensembles. La différence symétrique est donc une opération commutative.
setB.symmetric_difference(setA)
# Résultat
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Sous-Ensembles et Sur-Ensembles en Python
En théorie des ensembles, les sous-ensembles et les sur-ensembles aident à comprendre la relation entre deux ensembles.
Étant donné deux ensembles, A et B, B est un sous-ensemble de A si tous les éléments de B sont également présents dans A. Dans ce cas, A est le sur-ensemble de B.
Considérons les deux ensembles suivants : `languages` et `languages_extended`.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
En Python, vous pouvez utiliser la méthode `.issubset()` pour vérifier si un ensemble est un sous-ensemble d’un autre.
`setA.issubset(setB)` retourne True si `setA` est un sous-ensemble de `setB`, sinon, il retourne False.
Dans cet exemple, `languages` est un sous-ensemble de `languages_extended`.
languages.issubset(languages_extended) # Résultat True
De même, utilisez `.issuperset()` pour vérifier si un ensemble est un sur-ensemble d’un autre.
`setA.issuperset(setB)` retourne True si `setA` est un sur-ensemble de `setB`, sinon, il retourne False.
languages_extended.issuperset(languages) # Résultat True
Comme `languages_extended` est un sur-ensemble de `languages`, `languages_extended.issuperset(languages)` retourne True.
Conclusion
J’espère que ce guide vous a permis de comprendre les ensembles Python, leurs méthodes pour les opérations CRUD, ainsi que les opérations d’ensemble courantes. Vous pouvez désormais les utiliser dans vos projets Python.
N’hésitez pas à consulter nos autres guides Python détaillés. Bon apprentissage !