En Python, le type de données set (ensemble) est une collection non ordonnée d'éléments uniques. Cette structure est particulièrement utile pour gérer des groupes d'objets où l'ordre n'a pas d'importance et où les doublons doivent être automatiquement exclus.

Création et Caractéristiques Fondamentales

Un ensemble peut être créé en plaçant des éléments séparés par des virgules entre des accolades :

set_numerique = {1, 2, 3}
print(type(set_numerique))
print(set_numerique)
# Output:
# <class>
# {1, 2, 3}
</class>

Il est crucial de noter qu'un littéral d'accolades vide {} ne crée pas un ensemble vide, mais un dictionnaire vide. Pour créer un ensemble vide, il faut utiliser le constructeur set() :

conteneur_vide = {}
print(type(conteneur_vide))
# Output:
# <class>

ensemble_vide = set()
print(type(ensemble_vide))
# Output:
# <class>
</class></class>

Les ensembles sont des collections non ordonnées. Cela signifie que l'ordre dans lequel les éléments sont insérés n'est pas conservé et ne peut pas être garanti lors de l'itération ou de l'affichage :

elements_desordonnes = {5, 2, 8, 1}
print(elements_desordonnes)
# L'ordre de sortie peut varier, par exemple: {8, 1, 2, 5} ou {1, 2, 5, 8}

La propriété la plus distinctive des ensembles est qu'ils ne peuvent contanir que des éléments uniques. Si vous tentez d'ajouter des doublons, ils seront ignorés :

doublons_inclus = {10, 20, 10, 30}
print(doublons_inclus)
# Output:
# {10, 20, 30}

Éléments Hachables

Pour stocker des données dans un ensemble, Python exige que les éléments soient "hachables". Le hachage est un prcoessus de calcul qui génère une valeur numérique unique et constante pour un objet donné. Les objets hachables sont généralement immutables (non modifiables après leur création).

Types hachables (immutables) qui peuvent être des éléments d'un ensemble : int, float, str, tuple, bool.

elements_valides = {100, "un texte", (1, 2), True}
print(elements_valides)
# Output (l'ordre peut varier):
# {True, 100, (1, 2), 'un texte'}

Types non hachables (mutables) qui ne peuvent pas être des éléments d'un ensemble : list, dict, set.

# Exemple d'erreur si un type non hachable est inclus
try:
    elements_invalides = {5, "chaine", [1, 2]} # La liste est non hachable
    print(elements_invalides)
except TypeError as e:
    print(f"Erreur: {e}")
# Output:
# Erreur: unhashable type: 'list'

Opérations Courantes sur les Ensembles

Voici quelques méthodes clés pour manipuler les ensembles :

• Ajouter un élément (add()) :

mon_ensemble = set()
mon_ensemble.add("Article A")
mon_ensemble.add("Article B")
print(mon_ensemble)
# Output (l'ordre peut varier): {'Article B', 'Article A'}

• Supprimer un élément (remove() ou discard()) :
  • remove(element) : Supprime element. Lève une KeyError si l'élément n'est pas présent.
  • discard(element) : Supprime element si présent, ne fait rien sinon.

mon_ensemble.remove("Article B")
print(mon_ensemble)
# Output: {'Article A'}

mon_ensemble.discard("Article C") # 'Article C' n'est pas là, pas d'erreur
print(mon_ensemble)
# Output: {'Article A'}

• Supprimer un élément arbitraire (pop()) : Supprime et retourne un élément arbitraire de l'ensemble. Étant donné que les ensembles sont non ordonnés, il n'y a aucune garantie sur l'élément qui sera supprimé.

mon_ensemble.add("Article D")
mon_ensemble.add("Article E")
print(f"Avant pop: {mon_ensemble}")
element_supprime = mon_ensemble.pop()
print(f"Élément supprimé: {element_supprime}")
print(f"Après pop: {mon_ensemble}")
# L'élément supprimé sera aléatoire parmi ceux présents.

Pour "modifier" un élément, il faut le supprimer et en ajouter un nouveau, car les éléments eux-mêmes sont considérés comme des entités uniques :

ensemble_modifiable = {"pomme", "orange", "banane"}
print(f"Original: {ensemble_modifiable}")
ensemble_modifiable.remove("orange")
ensemble_modifiable.add("pamplemousse")
print(f"Modifié: {ensemble_modifiable}")
# Output (l'ordre peut varier):
# Original: {'banane', 'pomme', 'orange'}
# Modifié: {'pamplemousse', 'banane', 'pomme'}

L'itération est le moyen standard d'accéder à chaque élément d'un ensemble :

for fruit in ensemble_modifiable:
    print(fruit)
# Output (l'ordre peut varier):
# pamplemousse
# banane
# pomme

Opérations Ensemblistes

Les ensembles supportent les opérations mathématiques classiques d'union, d'intersection et de différence :

set_a = {"pomme", "banane", "orange", "kiwi"}
set_b = {"orange", "kiwi", "fraise", "mangue"}

# Intersection (éléments communs aux deux ensembles)
# Opérateur '&' ou méthode intersection()
print(f"Intersection: {set_a & set_b}")
print(f"Intersection (méthode): {set_a.intersection(set_b)}")
# Output: {'kiwi', 'orange'}

# Union (tous les éléments des deux ensembles, sans doublons)
# Opérateur '|' ou méthode union()
print(f"Union: {set_a | set_b}")
print(f"Union (méthode): {set_a.union(set_b)}")
# Output: {'mangue', 'kiwi', 'banane', 'pomme', 'fraise', 'orange'}

# Différence (éléments de set_a qui ne sont pas dans set_b)
# Opérateur '-' ou méthode difference()
print(f"Différence (A - B): {set_a - set_b}")
print(f"Différence (méthode A - B): {set_a.difference(set_b)}")
# Output: {'banane', 'pomme'}

Utilisation Pratique : Suppression des Doublons

La propriété d'unicité des ensembles est fréquemment utilisée pour éliminer les doublons d'autres collections, come les listes. En convertissant une liste en ensemble, tous les éléments en double sont automatiquement supprimés. La conversion inverse en liste permet de récupérer les éléments uniques.

liste_avec_doublons = ["a", "b", "c", "a", "b", "d", "c", "e"]
print(f"Liste originale: {liste_avec_doublons}")

# Convertir en set pour supprimer les doublons, puis reconvertir en list
liste_sans_doublons = list(set(liste_avec_doublons))
print(f"Liste sans doublons (ordre non garanti): {liste_sans_doublons}")
# Output (l'ordre des éléments dans la liste finale peut varier car les sets sont non ordonnés):
# Liste originale: ['a', 'b', 'c', 'a', 'b', 'd', 'c', 'e']
# Liste sans doublons (ordre non garanti): ['e', 'a', 'c', 'b', 'd']

Cette technique est simple et efficace, mais il est important de se souvenir que l'ordre original des éléments n'est pas conservé lors de la conversion via un ensemble.