L’ensemble (set)¶
Un ensemble est un groupement non ordonné d’éléments uniques.
Prudence
Pour qu’un élément puisse faire partie d’un ensemble, il faut qu’il puisse produire une valeur de hachage (hash en anglais). Il s’agit d’une valeur numérique qui permet d’identifier l’élément sans forcément lui être unique. Par défaut en Python, les nombres, les chaînes de caractères et les valeurs booléennes peuvent produire une valeur de hachage. Ils peuvent donc être mis dans un ensemble.
Créer un ensemble¶
Pour créer un ensemble, on écrit ses éléments entre accolades {}
et
séparés par des virgules :
mon_ensemble = {10, 20, 30, 40}
ensemble_depareillee = {None, 1, "shrubbery", True}
Comme le montre la variable ensemble_depareillee
ci-dessus, un ensemble peut contenir
des éléments de types différents. Il peut même contenir un élément ou des
éléments None
ce qui signifie qu’il contient un élément qui n’est rien.
Si vous déclarez plusieurs fois la même valeur dans un ensemble alors la valeur ne sera présente qu’un fois (les doublons sont ignorés).
mon_ensemble = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4}
print(mon_ensemble)
# affiche {1, 2, 3, 4}
Prudence
v = {}
Le code ci-dessus ne crée pas un ensemble vide mais un dictionnaire
vide. Pour créer une dictionnaire vide, il faut utiliser la fonction
set()
:
v = set()
Accéder aux éléments¶
Il n’est pas possible d’accéder aux éléments d’un ensemble avec l’opérateur
[]
. En revanche, nous verrons avec les structures de contrôle qu’il est
possible de parcourir un ensemble.
Les opérations sur les ensembles¶
Connaître la taille d’un ensemble¶
Pour connaître le nombre d’éléments d’un ensemble, il faut utiliser la fonction
len()
(qui est la contraction de length) :
mon_ensemble = {10, 20, 30, 40}
taille_ensemble = len(mon_ensemble)
print(taille_ensemble)
# affiche 4
Savoir si un élément est présent dans un ensemble¶
Pour savoir si un élément est présent dans un ensemble, on peut utiliser le mot-clé
in
:
>>> mon_ensemble = {1, 2, 3}
>>> 2 in mon_ensemble
True
>>> 12 in mon_ensemble
False
>>> 12 not in mon_ensemble
True
Comparer deux ensembles¶
On peut utiliser tous les opérateurs de comparaison entre deux ensembles.
>>> mon_ensemble = {1, 2, 3}
>>> mon_ensemble == {1, 2, 3}
True
>>> mon_ensemble != {}
True
>>> mon_ensemble < {1, 2, 3, 4}
True
>>> mon_ensemble > {2}
True
Pour que deux ensembles soient égaux, il faut qu’ils contiennent les mêmes éléments.
Connaître le plus grand élément d’un ensemble¶
Pour connaître le plus grand élément d’un ensemble, il faut utiliser la fonction
max()
:
mon_ensemble = {10, 20, 30, 40}
element = max(mon_ensemble)
print(element)
# affiche 40
Cela suppose néanmoins que tous les éléments d’un ensemble sont comparables et
donc de type similaire sinon on obtient une erreur de type TypeError
.
>>> mon_ensemble = {10, "coconut"}
>>> element = max(mon_ensemble)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'
Connaître le plus petit élément d’un ensemble¶
Pour connaître le plus petit élément d’un ensemble, il faut utiliser la fonction
min()
:
mon_ensemble = {"a", "b", "c"}
element = min(mon_ensemble)
print(element)
# affiche a
Comme pour la méthode max()
, cela suppose que tous les éléments d’un
ensemble sont comparables et donc de type similaire.
Quelques méthodes pour les ensembles¶
copy()
Copie un ensemble pour créer un nouvel ensemble
mon_ensemble = {10, 20, 30} nouvel_ensemble = mon_ensemble.copy()
add()
Ajoute un élément à un ensemble
mon_ensemble = {10, 20, 30} mon_ensemble.add(40) print(mon_ensemble) # affiche {10, 20, 30, 40}
remove()
Supprime un élément d’un ensemble
mon_ensemble = {10, 20, 30} mon_ensemble.remove(20) print(mon_ensemble) # affiche {10, 30}
clear()
Supprime tous les éléments d’un ensemble
mon_ensemble = {10, 20, 30} mon_ensemble.clear() print(mon_ensemble) # affiche {}
union(e)
Crée un ensemble représentant l’union entre deux ou plusieurs ensembles :
e1 = {1, 2} e2 = {2, 3} e3 = e1.union(e2) print(e3) # affiche {1, 2, 3}
Astuce
L’union peut également se représenter avec l’opérateur
|
:e1 = {1, 2} e2 = {2, 3} e3 = e1 | e2 print(e3) # affiche {1, 2, 3}
intersection(e)
Crée un ensemble représentant l’intersection entre deux ou plusieurs ensembles :
e1 = {1, 2} e2 = {2, 3} e3 = e1.intersection(e2) print(e3) # affiche {2}
Astuce
L’intersection peut également se représenter avec l’opérateur
&
:e1 = {1, 2} e2 = {2, 3} e3 = e1 & e2 print(e3) # affiche {2}
difference(e)
Crée un ensemble représentant la différence entre deux ou plusieurs ensembles :
e1 = {1, 2} e2 = {2, 3} e3 = e1.difference(e2) print(e3) # affiche {1}
Astuce
La différence peut également se représenter avec l’opérateur
-
:e1 = {1, 2} e2 = {2, 3} e3 = e1 - e2 print(e3) # affiche {1}
symmetric_difference(e)
Crée un ensemble contenant les éléments présents dans un des ensembles mais pas dans les deux :
e1 = {1, 2} e2 = {2, 3} e3 = e1.symmetric_difference(e2) print(e3) # affiche {1, 3}
Astuce
La différence symétrique peut également se représenter avec l’opérateur
^
:e1 = {1, 2} e2 = {2, 3} e3 = e1 ^ e2 print(e3) # affiche {1, 3}
Ensemble, liste et tuple¶
Les ensembles, listes et tuples sont des collections d’éléments, il est possible
de passer de l’un à l’autre grâce aux méthode set
, list
,
tuple
.
ma_liste = [1, 1, 2, 2]
mon_ensemble = set(ma_liste)
mon_tuple = tuple(mon_ensemble)
Prudence
Comme un ensemble n’est pas ordonné, si vous créez une liste ou un tuple à partir d’un ensemble, vous n’avez aucune garantie sur l’ordre des éléments dans la liste ou le tuple qui sera créé.
De la même manière, si vous parcourez un ensemble avec une instruction for
,
vous n’avez aucune garantie sur l’ordre de parcours des éléments. Dit autrement,
un ensemble n’est pas une structure de données recommandée quand il existe
une relation d’ordre entre les éléments.
Ensemble figé¶
On peut créer un ensemble non modifiable grâce à la fonction frozenset()
.
Cette fonction attend en paramètre une séquence (liste, tuple ou ensemble) :
mon_ensemble = (1, 2, 3)
ensemble = frozenset(mon_ensemble)
Un ensemble figé se comporte comme un ensemble sauf que l’on obtient une erreur pour toute tentative de modification.
Exercices¶
Exercice : jeu sur les nombres
Demandez à l’utilisateur de saisir deux séries de nombres.
Puis :
Affichez les nombres qui sont en commun dans les deux séries
Affichez le plus grand nombre qui n’est présent que dans une seule série
Affichez tous les nombres sans doublon.