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 :

  1. Affichez les nombres qui sont en commun dans les deux séries

  2. Affichez le plus grand nombre qui n’est présent que dans une seule série

  3. Affichez tous les nombres sans doublon.