Les ensembles Python

Un ensemble Python est une collection non ordonnée d'éléments uniques et hachables. Comme les ensembles garantissent l'unicité automatiquement et permettent un test d'appartenance rapide, ils sont idéaux pour la déduplication, l'algèbre des ensembles mathématiques et la vérification du chevauchement entre collections.

Ce chapitre couvre :

• Comment créer des ensembles (syntaxe littérale et set())
• L'ajout et la suppression d'éléments — et quand chaque méthode lève une erreur
• Les quatre opérations sur les ensembles : union, intersection, différence, différence symétrique
• Les raccourcis d'opérateurs (|, &, -, ^)
• Les tests de sous-ensemble et de sur-ensemble
• Les compréhensions d'ensembles
• Les ensembles figés (frozenset) pour des ensembles immuables et hachables

Créer des ensembles

Utiliser les accolades

La façon la plus rapide de créer un ensemble non vide est d'utiliser un littéral entre accolades. Chaque valeur n'apparaît qu'une seule fois, quel que soit le nombre de fois où vous l'écrivez.

Définir un ensemble en Python

Utiliser le constructeur set()

Passez n'importe quel itérable — une liste, un tuple, une string ou un range — à set() pour en construire un ensemble. Les valeurs dupliquées sont silencieusement supprimées.

Convertir une liste en ensemble en Python

Important : ensemble vide

Pour créer un ensemble vide, vous devez utiliser set(). Écrire {} crée un dictionnaire vide, pas un ensemble.

empty_set  = set()          # correct
empty_dict = {}             # this is a dict!

print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

Que peut-on mettre dans un ensemble ?

Un élément d'un ensemble doit être hachable — les types immuables tels que int, float, str, bool et tuple fonctionnent parfaitement. Les listes et les autres ensembles ne peuvent pas être des éléments car ils sont mutables et donc non hachables.

valid   = {1, "hello", (2, 3), True}  # OK
# invalid = {[1, 2]}                  # TypeError: unhashable type: 'list'
print(valid)

Accéder aux éléments d'un ensemble

Les ensembles sont non ordonnés, donc les éléments n'ont pas d'index et vous ne pouvez pas récupérer un seul élément par position. La façon standard de parcourir chaque élément est une boucle for.

colors = {"red", "green", "blue"}
for color in colors:
    print(color)
# Output order may vary — sets are unordered

Pour vérifier si une valeur spécifique existe, utilisez l'opérateur in :

colors = {"red", "green", "blue"}
print("red" in colors)    # True
print("yellow" in colors) # False

Le test d'appartenance sur un ensemble est O(1) en moyenne — bien plus rapide que la recherche dans une liste lorsque les collections sont grandes.

Pour un chapitre dédié, consultez Accéder aux éléments d'un ensemble.

Ajouter des éléments

Utilisez add() pour insérer un seul élément, ou update() pour ajouter plusieurs éléments depuis n'importe quel itérable.

Ajouter un élément à un ensemble en Python

update() accepte n'importe quel itérable et en ajoute tous les éléments :

my_set = {1, 2, 3}
my_set.update([4, 5], {6, 7})
print(my_set)   # {1, 2, 3, 4, 5, 6, 7}

Consultez Ajouter des éléments à un ensemble pour plus de détails.

Supprimer des éléments

Python vous propose plusieurs méthodes pour supprimer des éléments, chacune avec un comportement différent lorsque l'élément est absent.

Supprimer un élément d'un ensemble en Python

Quand choisir remove plutôt que discard : utilisez remove() quand l'élément doit être présent et que son absence indique un bug. Utilisez discard() quand l'élément peut ou non être présent et que vous voulez simplement le supprimer.

Consultez Supprimer des éléments d'un ensemble pour toutes les méthodes de suppression.

Opérations sur les ensembles

Les ensembles Python implémentent les quatre opérations classiques de l'algèbre des ensembles. Chaque opération est disponible à la fois comme méthode et comme opérateur — choisissez celui qui est le plus clair dans le contexte.

Opérations sur les ensembles en Python

set1 = {1, 2, 3}
set2 = {2, 3, 4}

# Union — all elements from both sets
print(set1.union(set2))              # {1, 2, 3, 4}
print(set1 | set2)                   # {1, 2, 3, 4}

# Intersection — only elements present in both
print(set1.intersection(set2))       # {2, 3}
print(set1 & set2)                   # {2, 3}

# Difference — elements in set1 but not set2
print(set1.difference(set2))         # {1}
print(set1 - set2)                   # {1}

# Symmetric difference — elements in either set, but not both
print(set1.symmetric_difference(set2))  # {1, 4}
print(set1 ^ set2)                      # {1, 4}

Tests de sous-ensemble et de sur-ensemble

Utilisez issubset(), issuperset() ou les opérateurs de comparaison <= / >= pour tester les relations de contenance.

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

print(a.issubset(b))    # True  — every element of a is in b
print(a <= b)           # True

print(b.issuperset(a))  # True  — b contains all elements of a
print(b >= a)           # True

print(a < b)            # True  — proper subset (a != b)
print(a == b)           # False

isdisjoint() retourne True quand deux ensembles ne partagent aucun élément :

x = {1, 2, 3}
y = {4, 5, 6}
print(x.isdisjoint(y))  # True

Consultez Joindre des ensembles pour les variantes de mise à jour en place telles que |=, &=, -= et ^=.

Compréhensions d'ensembles

Comme les compréhensions de listes, vous pouvez construire un ensemble avec une expression compacte en utilisant des accolades et une clause for.

squares = {x ** 2 for x in range(1, 6)}
print(squares)  # {1, 4, 9, 16, 25}

# With a filter condition
even_squares = {x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # {4, 16, 36, 64, 100}

Comme le résultat est un ensemble, les valeurs dupliquées sont automatiquement supprimées :

words = ["apple", "banana", "avocado", "blueberry"]
first_letters = {w[0] for w in words}
print(first_letters)  # {'a', 'b'}

Ensembles figés

Un frozenset est une version immuable d'un ensemble. Une fois créé, les éléments ne peuvent pas être ajoutés ou supprimés. Les ensembles figés sont hachables, ce qui signifie qu'ils peuvent être utilisés comme clés de dictionnaire ou comme éléments d'un autre ensemble.

fs = frozenset([1, 2, 3])
print(fs)               # frozenset({1, 2, 3})

# All read-only operations work
print(2 in fs)          # True
print(fs | {4, 5})      # frozenset({1, 2, 3, 4, 5})

# fs.add(4)             # AttributeError — frozenset has no add()

# Use as a dictionary key
permissions = {
    frozenset(["read", "write"]): "editor",
    frozenset(["read"]):          "viewer",
}
user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # editor

Quand utiliser frozenset : chaque fois que vous avez besoin d'un objet de type ensemble qui ne doit pas changer — comme une configuration constante, une clé de dictionnaire sûre, ou lorsque vous partagez un ensemble entre des threads sans verrou.

Exemples pratiques

Supprimer les doublons d'une liste

La conversion en ensemble et le retour à une liste est la façon la plus simple de dédupliquer une liste. Notez que l'ordre original n'est pas préservé ; si l'ordre est important, utilisez dict.fromkeys() à la place.

Supprimer les doublons d'une liste avec un ensemble en Python

Vérifier si deux listes partagent un élément

Vérifier si deux listes ont des éléments en commun en Python avec des ensembles

isdisjoint() est une alternative plus directe pour cette vérification :

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(not set(list1).isdisjoint(set(list2)))  # False — no common elements

Trouver les tags uniques parmi des articles

article_a_tags = {"python", "tutorial", "beginner"}
article_b_tags = {"python", "advanced", "data-science"}

all_tags    = article_a_tags | article_b_tags
shared_tags = article_a_tags & article_b_tags
only_in_a   = article_a_tags - article_b_tags

print("All tags:    ", all_tags)
print("Shared tags: ", shared_tags)
print("Only in A:   ", only_in_a)

Résumé

Chapitres connexes : Ajouter des éléments à un ensemble · Supprimer des éléments d'un ensemble · Accéder aux éléments d'un ensemble · Parcourir des ensembles · Joindre des ensembles · Méthodes des ensembles

Pratique