Les ensembles

Les ensembles (set en Python) sont des collections sans doublons et non ordonnées. Moins connus que les listes et dicts, ils sont pourtant extrêmement utiles pour deux cas : supprimer les doublons et faire des opérations ensemblistes (union, intersection, différence). Le TOSA les teste surtout sur ces deux usages.

Qu'est-ce qu'un ensemble ?

Un ensemble est une collection d'éléments uniques et non ordonnés. On le crée avec des accolades {} comme un dictionnaire, mais sans paires clé: valeur.

couleurs = {"rouge", "vert", "bleu"}
nombres = {1, 2, 3, 4, 5}

print(couleurs)
print(nombres)
print(type(couleurs))

Quatre caractéristiques :

1. Éléments uniques : les doublons sont automatiquement supprimés.
2. Non ordonnés : pas d'indice, l'ordre n'est pas garanti.
3. Modifiables : on peut ajouter et retirer des éléments.
4. Éléments immuables uniquement : comme pour les clés de dict.

Les doublons sont supprimés automatiquement

s = {1, 2, 2, 3, 3, 3, 4}
print(s)                 # {1, 2, 3, 4}

Pas d'indice possible

s = {10, 20, 30}
print(s[0])

Ensemble vide : piège !

Créer un ensemble à partir d'une autre collection

# Depuis une liste (supprime les doublons automatiquement)
nombres = set([1, 2, 2, 3, 3, 4])
print(nombres)

# Depuis une chaîne (supprime les doublons de caractères)
lettres = set("banana")
print(lettres)

Les méthodes principales

Ajouter et retirer

s = {1, 2, 3}

s.add(4)
print(s)

s.add(2)                # déjà présent : sans effet
print(s)

s.remove(1)
print(s)

s.discard(99)           # pas d'erreur même si absent
print(s)

Tester l'appartenance : in

Le test in est extrêmement rapide sur un set (complexité O(1)) — bien plus rapide qu'une liste.

ens = {1, 2, 3, 4, 5}
print(3 in ens)       # True
print(99 in ens)      # False

Parcourir un ensemble

Comme une liste, un ensemble se parcourt avec for :

couleurs = {"rouge", "vert", "bleu"}
for c in couleurs:
    print(c)

Attention : l'ordre de parcours n'est pas garanti pour un ensemble. Si l'ordre compte, triez d'abord : for c in sorted(couleurs).

Les opérations ensemblistes (le cœur des ensembles)

C'est ce qui fait la valeur unique des sets : effectuer des opérations mathématiques d'ensembles.

Union — tout, sans doublons

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)
print(a.union(b))

Intersection — éléments communs

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a & b)
print(a.intersection(b))

Différence — éléments de a qui ne sont pas dans b

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a - b)           # {1, 2} — dans a mais pas dans b
print(b - a)           # {5, 6} — dans b mais pas dans a

Différence symétrique — éléments dans l'un OU l'autre, mais pas les deux

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a ^ b)           # {1, 2, 5, 6} — sans les éléments communs

Tableau récapitulatif

Tests ensemblistes

a = {1, 2}
b = {1, 2, 3, 4}
c = {10, 20}

print(a.issubset(b))       # True
print(b.issuperset(a))     # True
print(a.isdisjoint(c))     # True
print(a.isdisjoint(b))     # False (ils partagent 1 et 2)

Cas d'usage typique : supprimer les doublons

L'usage #1 des sets dans du code Python réel.

# À partir d'une liste avec doublons
notes = [12, 15, 12, 9, 15, 17, 12, 9]

notes_uniques = set(notes)
print(notes_uniques)

# Si on veut RÉCUPÉRER une liste sans doublons
liste_sans_doublons = list(set(notes))
print(liste_sans_doublons)

Les frozenset : ensembles immuables

Python propose un type frozenset : un set immuable, comme un tuple est une liste immuable. On l'utilise rarement au niveau Basique, mais il est bon de savoir qu'il existe.

f = frozenset([1, 2, 3])
print(f, type(f))

f.add(4)     # ❌ impossible, immuable

À la différence d'un set classique, un frozenset peut servir de clé de dictionnaire ou d'élément dans un autre set.

Vue synthétique : les 4 structures de données de base

Tableau essentiel pour le TOSA — à connaître par cœur :

Exercices

À retenir