Comment utiliser les ensembles Python (set)

Qu'est-ce qu'un ensemble — pas de doublons, pas d'ordre

Un ensemble (set) est, comme list et tuple, un type qui permet de regrouper plusieurs valeurs. Mais il a deux règles qui le distinguent fortement.

- Chaque valeur n'apparaît qu'une seule fois (les doublons sont supprimés automatiquement)

- L'ordre n'est pas conservé (la position n'a aucune importance)

Déclare un ensemble en entourant les valeurs avec { et }, séparées par des virgules.

Pour un ensemble vide, utilise set() et non {}. Écrire {} te donne un dict vide.

# Les doublons sont supprimés automatiquement
set_a = {"a", "b", "c", "d", "a"}
print(set_a)         # {'a', 'b', 'c', 'd'} (l'ordre dépend de l'environnement)
print(type(set_a))   # <class 'set'>
print(len(set_a))    # 4 (le doublon 'a' se réduit à un seul)

# Mélanger nombres et autres types marche bien
mixed = {1, "apple", 3.14}

# Utilise set() pour un ensemble vide
empty_set  = set()
empty_dict = {}        # ceci devient un "dict vide"
print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

# Utilise in / not in pour vérifier l'appartenance
print("a" in set_a)       # True
print("z" not in set_a)   # True

Pas d'ordre, donc pas d'accès par index

Comme un ensemble n'a pas d'ordre, tu ne peux pas utiliser l'accès par index comme set_a[0] (tu obtiendras une TypeError). Si tu as besoin du Nème élément, convertis d'abord en list ou tuple puis prends-le depuis là. Choisis selon l'usage : list / tuple quand l'ordre compte, set quand il n'a pas d'importance.

Vérifions le comportement d'un ensemble.

① Crée tags = {"python", "web", "python", "ai", "web"}, puis print() le contenu et len(tags). Tu devrais voir les doublons s'effondrer et le compte baisser.

② print() à la fois "python" in tags et "go" in tags pour vérifier l'appartenance avec True / False.

(Si ton code tourne correctement, l'explication apparaîtra.)

Ajout et suppression d'éléments

Un ensemble est un type mutable, donc tu peux ajouter et supprimer des éléments après l'avoir déclaré.

Les cinq méthodes que tu utiliseras le plus sont ci-dessous.

fruits = {"apple", "banana", "lemon"}

# add
fruits.add("grape")
fruits.add("apple")     # déjà présent, ignoré
print(fruits)            # {'apple', 'banana', 'lemon', 'grape'}

# remove (erreur si absent)
fruits.remove("banana")
# fruits.remove("melon") # KeyError

# discard reste silencieux même si absent
fruits.discard("melon")  # rien ne se passe
print(fruits)            # {'apple', 'lemon', 'grape'}

# Supprime et renvoie un élément arbitraire
picked = fruits.pop()
print(picked)            # un élément (varie à chaque exécution)

# Tout supprimer
fruits.clear()
print(fruits)            # set()

Gérons les tags d'intérêts d'un utilisateur.

interests = {"python", "web"} est préparé.

① Utilise add pour ajouter "ai".

② Essaie d'add-er le "python" déjà présent à nouveau, et confirme que l'ensemble ne change pas.

③ discard "go" (un tag absent) et confirme qu'aucune erreur n'est levée.

④ print() le résultat final interests.

Opérations ensemblistes — union, intersection, différence, différence symétrique

La plus grande force de set, ce sont les opérations ensemblistes. Tu peux combiner deux ensembles pour extraire les éléments communs, ou ceux qui apparaissent dans un seul des deux, en une seule ligne. Tu pourrais faire la même chose avec une boucle for sur des listes, mais les ensembles sont bien plus rapides.

• Union — tous les éléments qui apparaissent dans l'un ou l'autre ensemble
• Intersection — uniquement les éléments qui apparaissent dans les deux
• Différence — les éléments dans s mais pas dans t
• Différence symétrique — les éléments qui apparaissent dans exactement un des deux

Le diagramme ci-dessous montre les résultats quand s = {a, b, c, d} et t = {c, d, e, f}.

s = {"a", "b", "c", "d"}
t = {"c", "d", "e", "f"}

# Union
print(s | t)                  # {'a', 'b', 'c', 'd', 'e', 'f'}
print(s.union(t))             # identique

# Intersection
print(s & t)                  # {'c', 'd'}
print(s.intersection(t))      # identique

# Différence (dans s, pas dans t)
print(s - t)                  # {'a', 'b'}
print(s.difference(t))        # identique

# Différence symétrique (dans exactement un)
print(s ^ t)                  # {'a', 'b', 'e', 'f'}
print(s.symmetric_difference(t))  # identique

Vérifications de sous-ensemble (aparté)

a <= b ou a.issubset(b) te dit si tous les éléments de a sont dans b, en renvoyant True / False. L'autre direction est a >= b ou a.issuperset(b).

C'est utilisé pour des vérifications comme « l'ensemble des permissions de l'utilisateur contient-il toutes les permissions requises ? ». Au départ, concentre-toi sur les quatre opérations ensemblistes et utilise celles-ci quand tu en as vraiment besoin.

À partir des listes d'inscription de deux cours, trouve les étudiants inscrits dans les deux et ceux inscrits dans un seul.

math = {"Alice", "Léo", "Chloé", "Hugo"} et english = {"Chloé", "Hugo", "Emma", "Jules"} sont préparés.

① print() les étudiants inscrits dans les deux cours (intersection).

② print() les étudiants inscrits dans un seul cours (différence symétrique).

Motifs concrets — déduplication et vérifications d'appartenance rapides

Pour finir, verrouillons deux motifs incontournables qui reviennent constamment dans le travail réel.

# Motif ①: déduplication
numbers = [1, 2, 2, 2, 3, 4, 4, 5, 6, 6]
unique_numbers = list(set(numbers))
print(unique_numbers)   # [1, 2, 3, 4, 5, 6] (l'ordre peut varier)

# Motif ②: vérification d'appartenance rapide
# x in set est bien plus rapide que x in list
allowed_users = {"alice", "bob", "carol"}
print("alice" in allowed_users)   # True
print("dan"   in allowed_users)   # False

Pourquoi in est rapide sur un ensemble

Un ensemble est soutenu par une table de hachage. Il cherche les valeurs directement via leur hash, donc les recherches prennent un temps à peu près constant quelle que soit la taille.

in sur une liste compare les éléments un par un depuis le début, donc ça ralentit à mesure que la liste grandit. Si tu vas vérifier l'appartenance de nombreuses fois, convertis d'abord en set et tu obtiendras une accélération dramatique.

Déduplique des entrées de log et vérifie rapidement si un utilisateur spécifique apparaît.

logins = ["alice", "bob", "alice", "carol", "bob", "alice"] est préparé.

① Utilise set pour dédupliquer dans unique_logins (en tant que liste), puis print()-le.

② Crée login_set en convertissant unique_logins directement en ensemble, et utilise in pour print() si "carol" et "dan" sont membres.

Dans cet article, tu as vu les traits de set (pas de doublons, pas d'ordre), ses méthodes d'ajout/suppression, les quatre opérations ensemblistes, et les deux motifs concrets — déduplication et vérifications d'appartenance rapides.

« Je me moque de l'ordre, je veux juste les uniques » / « Je vérifie l'appartenance encore et encore » / « J'ai besoin du chevauchement de deux ensembles » — si l'un de ces cas te parle, il est temps d'utiliser set.