Les ensembles en Python

Les Ensembles (sets)

Définition — Ensemble (set) Un ensemble en Python est une collection non ordonnée (sans indices), sans doublons et modifiable. Ses éléments doivent être immuables : on peut y mettre des entiers, chaînes ou tuples, mais pas des listes ni des dictionnaires.

Quand utiliser un ensemble ?	Exemple concret
Éliminer les doublons d'une collection	`set([1, 2, 2, 3])` → `{1, 2, 3}`
Test d'appartenance rapide (`O(1)`)	`x in grand_ensemble`
Opérations mathématiques sur des groupes	Union, intersection, différence…
Comparer deux collections sans tenir compte de l'ordre	`{1,2,3} == {3,1,2}` → `True`

Créer un ensemble

Syntaxe Python

s1 = {1, 2, 3}            # accolades — ensemble non vide
s2 = set([1, 2, 2, 3])    # constructeur depuis une liste
s3 = set("hello")         # constructeur depuis une chaîne
s4 = set()                # ensemble vide ← OBLIGATOIRE (voir ci-dessous)

Erreur fréquente — {} ≠ ensemble vide Les accolades vides créent un dictionnaire, pas un ensemble. Pour créer un ensemble vide, utiliser impérativement set():

d = {}        # ❌ dict vide  → type(d) = <class 'dict'>
s = set()     # ✅ set  vide  → type(s) = <class 'set'>

Exemple n°1 — Différentes créations

# Accolades — les doublons sont automatiquement supprimés
s1 = {1, 2, 3, 3, 4}
print(f"s1 = {s1}")

# Depuis une liste
s2 = set([1, 2, 2, 3])
print(f"s2 = {s2}")

# Depuis une chaîne — chaque caractère devient un élément
s3 = set("hello")
print(f"s3 = {s3}")

# Ensemble vide
s4 = set()
print(f"s4 = {s4}  —  type : {type(s4)}")

Sortie

s1 = {1, 2, 3, 4}
s2 = {1, 2, 3}
s3 = {'h', 'e', 'l', 'o'}
s4 = set()  —  type : <class 'set'>

Remarque — Ordre non garanti L'affichage d'un ensemble peut varier à chaque exécution car les éléments ne sont pas ordonnés. Ne jamais supposer un ordre particulier dans un ensemble.

Ajouter et supprimer des éléments

Les ensembles sont modifiables : on peut ajouter ou retirer des éléments après la création.

Méthode	Description	Erreur si absent ?
`s.add(x)`	Ajoute un seul élément `x`	—
`s.update(iter)`	Ajoute plusieurs éléments depuis un itérable	—
`s.remove(x)`	Supprime `x`	✅ `KeyError`
`s.discard(x)`	Supprime `x` si présent, sinon ne fait rien	❌ Silencieux
`s.pop()`	Supprime et retourne un élément arbitraire	✅ `KeyError` si vide
`s.clear()`	Vide l'ensemble	—

Exemple n°2 — Ajout d'éléments

s = {1, 2, 3}

# Ajout d'un seul élément
s.add(4)
print(f"après add(4)         : {s}")

# Ajout d'un élément déjà présent → aucun changement
s.add(2)
print(f"après add(2) (exist) : {s}")

# Ajout de plusieurs éléments depuis une liste
s.update([5, 6, 6, 7])
print(f"après update([5,6,7]): {s}")

Sortie

après add(4)          : {1, 2, 3, 4}
après add(2) (exist)  : {1, 2, 3, 4}
après update([5,6,7]) : {1, 2, 3, 4, 5, 6, 7}

Exemple n°3 — Suppression d'éléments

s = {1, 2, 3, 5, 6}

# remove() — lève KeyError si absent
s.remove(6)
print(f"après remove(6)  : {s}")

# discard() — silencieux si absent
s.discard(10)
print(f"après discard(10): {s}")   # aucun changement, pas d'erreur

# pop() — supprime un élément arbitraire
x = s.pop()
print(f"pop() a retiré   : {x}")
print(f"après pop()      : {s}")

# clear() — vide tout
s.clear()
print(f"après clear()    : {s}")

Sortie

après remove(6)   : {1, 2, 3, 5}
après discard(10) : {1, 2, 3, 5}
pop() a retiré    : 1
après pop()       : {2, 3, 5}
après clear()     : set()

Astuce — remove() vs discard() Préférer discard() quand on n'est pas sûr que l'élément est présent, pour éviter un try/exceptinutile :

# ❌ Verbeux
try:
    s.remove(x)
except KeyError:
    pass

# ✅ Concis
s.discard(x)

Opérations ensemblistes

Les ensembles Python supportent directement les opérations mathématiques classiques de la théorie des ensembles, avec des opérateurs symboliques ou des méthodes équivalentes.

Opération	Opérateur	Méthode	Résultat (A={1,2,3}, B={3,4,5})
Union	`A \| B`	`A.union(B)`	`{1, 2, 3, 4, 5}`
Intersection	`A & B`	`A.intersection(B)`	`{3}`
Différence A\B	`A - B`	`A.difference(B)`	`{1, 2}`
Différence B\A	`B - A`	`B.difference(A)`	`{4, 5}`
Diff. symétrique	`A ^ B`	`A.symmetric_difference(B)`	`{1, 2, 4, 5}`

Exemple n°4 — Opérations ensemblistes

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(f"A          = {A}")
print(f"B          = {B}")
print(f"A | B      = {A | B}")        # union
print(f"A & B      = {A & B}")        # intersection
print(f"A - B      = {A - B}")        # différence A\B
print(f"B - A      = {B - A}")        # différence B\A
print(f"A ^ B      = {A ^ B}")        # différence symétrique

Sortie

A          = {1, 2, 3, 4}
B          = {3, 4, 5, 6}
A | B      = {1, 2, 3, 4, 5, 6}
A & B      = {3, 4}
A - B      = {1, 2}
B - A      = {5, 6}
A ^ B      = {1, 2, 5, 6}

Remarque — Différence non commutative Contrairement à l'union et à l'intersection, la différence n'est pas commutative : A - B ≠ B - A en général. La différence symétrique A ^ B est l'union des deux : (A - B) | (B - A).

Exemple n°5 — Application : étudiants par matière

maths = {"Alice", "Bob", "Carlos", "Diana"}
info  = {"Bob", "Diana", "Eve", "Frank"}

print(f"Inscrits en maths ET info  : {maths & info}")
print(f"Inscrits en maths OU info  : {maths | info}")
print(f"Maths uniquement           : {maths - info}")
print(f"Info uniquement            : {info - maths}")
print(f"Une seule matière (pas les deux) : {maths ^ info}")

Sortie

Inscrits en maths ET info        : {'Bob', 'Diana'}
Inscrits en maths OU info        : {'Alice', 'Bob', 'Carlos', 'Diana', 'Eve', 'Frank'}
Maths uniquement                 : {'Alice', 'Carlos'}
Info uniquement                  : {'Eve', 'Frank'}
Une seule matière (pas les deux) : {'Alice', 'Carlos', 'Eve', 'Frank'}

Tests d'appartenance et de sous-ensemble

Test	Opérateur	Méthode	Signification
Appartenance	`x in s`	—	`x` est dans `s`
Sous-ensemble	`A <= B`	`A.issubset(B)`	Tous les éléments de A sont dans B
Sous-ensemble strict	`A < B`	—	A ⊆ B et A ≠ B
Sur-ensemble	`A >= B`	`A.issuperset(B)`	A contient tous les éléments de B
Disjoints	—	`A.isdisjoint(B)`	A et B n'ont aucun élément commun

Exemple n°6 — Tests d'appartenance et de sous-ensemble

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

print(f"2 in a          : {2 in a}")           # True
print(f"9 in a          : {9 in a}")           # False

print(f"a <= b          : {a <= b}")           # True  (a ⊆ b)
print(f"a < b           : {a < b}")            # True  (a ⊂ b, strictement)
print(f"a < a           : {a < a}")            # False (pas strict)

print(f"b >= a          : {b >= a}")           # True  (b ⊇ a)
print(f"a.issubset(b)   : {a.issubset(b)}")    # True
print(f"b.issuperset(a) : {b.issuperset(a)}") # True

print(f"a.isdisjoint(c) : {a.isdisjoint(c)}") # True  (aucun commun)
print(f"a.isdisjoint(b) : {a.isdisjoint(b)}") # False

Sortie

2 in a          : True
9 in a          : False
a <= b          : True
a < b           : True
a < a           : False
b >= a          : True
a.issubset(b)   : True
b.issuperset(a) : True
a.isdisjoint(c) : True
a.isdisjoint(b) : False

Compréhension d'ensembles

Comme pour les listes, on peut créer des ensembles par compréhension avec une syntaxe concise. Les doublons sont automatiquement éliminés.

Syntaxe Python

{expression for variable in iterable}
{expression for variable in iterable if condition}

Exemple n°7 — Compréhensions d'ensembles

# Carrés de 0 à 9
carres = {x**2 for x in range(10)}
print(f"Carrés   : {sorted(carres)}")

# Nombres pairs de 0 à 20
pairs = {x for x in range(21) if x % 2 == 0}
print(f"Pairs    : {sorted(pairs)}")

# Lettres uniques d'une phrase (hors espaces)
phrase  = "bonjour le monde"
lettres = {c for c in phrase if c != ' '}
print(f"Lettres  : {sorted(lettres)}")

# Éliminer les doublons d'une liste via compréhension
notes  = [12, 15, 12, 18, 15, 20, 18]
uniques = {n for n in notes}
print(f"Uniques  : {sorted(uniques)}")

Sortie

Carrés   : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Pairs    : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
Lettres  : ['b', 'd', 'e', 'j', 'l', 'm', 'n', 'o', 'r', 'u']
Uniques  : [12, 15, 18, 20]

Les ensembles immuables — `frozenset`

Définition — frozenset Un frozenset est un ensemble immuable : on ne peut ni ajouter ni supprimer d'éléments après sa création. Comme les tuples, il est hashable et peut donc servir de clé de dictionnaire ou d'élément d'un autre ensemble.

Exemple n°8 — frozenset

f = frozenset([1, 2, 3, 3, 4])
print(f"frozenset : {f}")
print(f"type      : {type(f)}")

# Opérations ensemblistes toujours disponibles
g = frozenset([3, 4, 5])
print(f"f | g     : {f | g}")
print(f"f & g     : {f & g}")

# Utilisation comme clé de dictionnaire
groupes = {
    frozenset(["Alice", "Bob"])   : "Groupe A",
    frozenset(["Carlos", "Diana"]): "Groupe B",
}
print(groupes[frozenset(["Alice", "Bob"])])

Sortie

frozenset : frozenset({1, 2, 3, 4})
type      : <class 'frozenset'>
f | g     : frozenset({1, 2, 3, 4, 5})
f & g     : frozenset({3, 4})
Groupe A

Récapitulatif — set vs list vs tuple vs frozenset

Propriété	`list`	`tuple`	`set`	`frozenset`
Ordonnée	✅	✅	❌	❌
Modifiable	✅	❌	✅	❌
Doublons	✅	✅	❌	❌
Indexée	✅	✅	❌	❌
Clé de dict	❌	✅	❌	✅
Opérations math.	❌	❌	✅	✅
Syntaxe	`[]`	`()`	`{}`	`frozenset()`

Précédent Les tuples en Python

Suivant Les dictionnaires en Python

Les Ensembles (sets)

Créer un ensemble

Ajouter et supprimer des éléments

Opérations ensemblistes

Tests d'appartenance et de sous-ensemble

Compréhension d'ensembles

Les ensembles immuables — `frozenset`

Récapitulatif — set vs list vs tuple vs frozenset

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Les ensembles en Python

Les Ensembles (sets)

Créer un ensemble

Ajouter et supprimer des éléments

Opérations ensemblistes

Tests d'appartenance et de sous-ensemble

Compréhension d'ensembles

Les ensembles immuables — frozenset

Récapitulatif — set vs list vs tuple vs frozenset

Discussion (0)

Laisser un commentaire

Les ensembles immuables — `frozenset`