Méthodes des ensembles Python – Référence complète avec exemples

Les ensembles Python sont des collections non ordonnées d'éléments uniques et hachables. Parce que les ensembles implémentent le concept mathématique d'ensemble, ils disposent d'une riche collection de méthodes intégrées pour les combiner, les comparer et les modifier. Ce chapitre couvre chaque méthode intégrée des ensembles avec des exemples clairs, la sortie attendue, et des conseils sur le moment de choisir une méthode plutôt qu'une autre.

Si vous débutez avec les ensembles, lisez d'abord Python Sets pour comprendre comment les ensembles sont créés et en quoi ils diffèrent des listes et des tuples.

Création des ensembles

Utilisez des accolades {} ou le constructeur set() pour créer un ensemble. Le constructeur accepte également tout itérable — une liste, un tuple ou une string — et supprime automatiquement les doublons.

fruits = {'apple', 'banana', 'cherry'}
colors = set(['red', 'green', 'blue'])   # from a list
vowels = set('aeiou')                    # from a string → {'a', 'e', 'i', 'o', 'u'}

empty = set()   # NOT {} — that creates an empty dict

Les ensembles sont non ordonnés : l'ordre d'affichage des éléments peut varier entre les exécutions et les versions de Python.

Méthodes d'opérations sur les ensembles

Ces méthodes combinent ou comparent deux ensembles ou plus sans modifier les originaux.

union()

union(*others) renvoie un nouvel ensemble contenant chaque élément qui apparaît dans l'ensemble courant ou dans l'un des others.

L'opérateur | est l'équivalent abrégé pour deux ensembles : A | B.

Quand l'utiliser : fusionner plusieurs collections tout en éliminant les doublons en une seule étape.

intersection()

intersection(*others) renvoie un nouvel ensemble contenant uniquement les éléments qui apparaissent dans l'ensemble courant et dans chacun des others.

L'opérateur & est l'abréviation pour deux ensembles : A & B.

Quand l'utiliser : trouver des éléments communs — par exemple, les utilisateurs qui ont cliqué à la fois sur l'annonce A et sur l'annonce B.

difference()

difference(*others) renvoie un nouvel ensemble d'éléments qui sont dans l'ensemble courant mais pas dans l'un des others.

L'opérateur - est l'abréviation : A - B.

Quand l'utiliser : filtrer un groupe d'un autre — par exemple, trouver les produits en stock mais pas encore expédiés.

symmetric_difference()

symmetric_difference(other) renvoie un nouvel ensemble d'éléments qui apparaissent dans exactement un des deux ensembles — les éléments qui ne sont pas partagés.

L'opérateur ^ est l'abréviation : A ^ B.

Quand l'utiliser : détecter ce qui a changé entre deux instantanés — par exemple, les fichiers ajoutés ou supprimés entre deux listes de répertoires.

issubset()

issubset(other) renvoie True si chaque élément de l'ensemble courant est également dans other.

L'opérateur <= est équivalent ; utilisez < pour tester un sous-ensemble propre (A est plus petit que B et entièrement contenu).

issuperset()

issuperset(other) renvoie True si l'ensemble courant contient chaque élément de other.

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

print(A.issuperset(B))   # True
print(B.issuperset(A))   # False

L'opérateur >= est équivalent ; utilisez > pour tester un sur-ensemble propre.

isdisjoint()

isdisjoint(other) renvoie True si les deux ensembles n'ont aucun élément en commun — leur intersection est vide.

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

print(A.isdisjoint(B))   # True  — no overlap
print(A.isdisjoint(C))   # False — 3 is in both

Quand l'utiliser : valider des catégories non chevauchantes, vérifier que deux ensembles de permissions sont mutuellement exclusifs.

Méthodes de mise à jour en place

Ces méthodes modifient l'ensemble en place et renvoient None — elles ne créent pas de nouvel ensemble.

update()

update(*others) ajoute tous les éléments d'un ou plusieurs itérables dans l'ensemble courant, en ignorant les doublons.

update() accepte tout itérable, pas seulement un autre ensemble — une liste, un tuple ou une string conviennent également. L'opérateur |= est l'abréviation pour deux ensembles.

intersection_update()

intersection_update(*others) conserve uniquement les éléments qui se trouvent également dans chacun des others, en supprimant tout le reste.

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

A.intersection_update(B)
print(A)   # {2, 3, 4}

L'opérateur &= est l'abréviation.

difference_update()

difference_update(*others) supprime de l'ensemble courant chaque élément qui apparaît dans l'un des others.

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

A.difference_update(B)
print(A)   # {1, 2}

L'opérateur -= est l'abréviation.

symmetric_difference_update()

symmetric_difference_update(other) conserve uniquement les éléments qui apparaissent dans exactement un des deux ensembles, en mettant à jour en place.

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

A.symmetric_difference_update(B)
print(A)   # {1, 4}

L'opérateur ^= est l'abréviation.

Méthodes de manipulation des éléments

add()

add(elem) insère elem dans l'ensemble. Si elem est déjà présent, l'ensemble reste inchangé.

Consultez Adding Set Items pour d'autres façons de remplir un ensemble.

remove()

remove(elem) supprime elem de l'ensemble. Lève KeyError si elem n'est pas présent.

Utilisez remove() lorsque l'élément doit être dans l'ensemble et qu'une absence inattendue constitue une erreur de programmation qu'il convient de signaler.

discard()

discard(elem) supprime elem de l'ensemble. Ne lève pas d'erreur si elem est absent.

Utilisez discard() lorsque l'élément peut être présent ou non dans l'ensemble et que vous souhaitez simplement le supprimer.

pop()

pop() supprime et renvoie un élément arbitraire. Les ensembles étant non ordonnés, vous ne pouvez pas prédire quel élément est supprimé. Lève KeyError si l'ensemble est vide.

Consultez Removing Set Items pour une comparaison de toutes les approches de suppression.

clear()

clear() supprime chaque élément, laissant un ensemble vide.

Notez que print(set()) affiche set(), et non {}, pour distinguer un ensemble vide d'un dictionnaire vide.

copy()

copy() renvoie une copie superficielle de l'ensemble. La modification de la copie n'affecte pas l'original.

A = {1, 2, 3}
B = A.copy()

B.add(4)
print(A)   # {1, 2, 3}  — unchanged
print(B)   # {1, 2, 3, 4}

Ceci est important car une simple affectation (B = A) crée une seconde référence vers le même ensemble — les modifications apportées à B affecteraient également A.

Méthode vs. opérateur : lequel préférer ?

La plupart des opérations sur les ensembles ont à la fois une forme méthode et une forme opérateur :

Différence clé : les méthodes acceptent tout itérable comme argument, tandis que les opérateurs nécessitent que les deux côtés soient des ensembles. Utilisez les méthodes lorsque vous souhaitez opérer directement sur une liste ou un tuple sans le convertir au préalable :

tags = {'python', 'web'}
new_tags = ['python', 'ml', 'data']

tags.update(new_tags)         # works — list is fine
# tags |= new_tags            # TypeError — operator needs a set
print(tags)   # {'python', 'web', 'ml', 'data'}

Référence complète des méthodes d'ensembles

Pratique