Niveau : Intermédiaire

Chapitre 14 : Les Ensembles (`set`)

Unicité, Union, Intersection, Différence, set

1. Quoi : Les Ensembles

Un ensemble (set) est une collection non ordonnée et muable d'éléments uniques.

Non ordonnée : Les éléments n'ont pas de position ou d'index. L'ordre d'insertion n'est pas garanti.
Muable : Vous pouvez ajouter ou supprimer des éléments.
Uniques : Un ensemble ne peut pas contenir de doublons. Si vous ajoutez un élément qui existe déjà, l'ensemble ne change pas.

2. Pourquoi : Unicité et Opérations Mathématiques

Les ensembles sont extrêmement utiles pour deux raisons principales :

Garantir l'unicité : Le cas d'usage le plus courant est de supprimer les doublons d'une liste.
Opérations mathématiques sur les ensembles : Les ensembles en Python implémentent les opérations de la théorie des ensembles (union, intersection, différence), ce qui est très puissant pour comparer des collections de données.

3. Comment : Création et Manipulation

A. Création

Avec la fonction set() à partir d'un itérable (comme une liste).
Avec des accolades {} pour définir les éléments directement.

# Créer un ensemble à partir d'une liste (supprime les doublons)
my_list = [1, 2, 2, 3, 4, 3]
my_set = set(my_list)
print(my_set)  # {1, 2, 3, 4}

# Créer un ensemble directement avec des accolades
fruits = {"apple", "banana", "cherry"}

# ⚠️ Attention : Pour créer un ensemble vide, vous DEVEZ utiliser set().
# {} crée un dictionnaire vide !
empty_set = set()
empty_dict = {}

B. Ajout et Suppression

.add(element) : Ajoute un élément. Ne fait rien si l'élément est déjà présent.
.remove(element) : Supprime un élément. Lève une KeyError si l'élément n'existe pas.
.discard(element) : Supprime un élément. Ne lève pas d'erreur si l'élément n'existe pas (plus sûr).
.pop() : Supprime et retourne un élément arbitraire (car les ensembles ne sont pas ordonnés).

colors = {"red", "green", "blue"}

# Ajout
colors.add("yellow")
colors.add("red") # Ne fait rien, "red" est déjà là
print(colors) # {'red', 'green', 'blue', 'yellow'}

# Suppression
colors.remove("green")
# colors.remove("purple") # ❌ Lèverait une KeyError

colors.discard("blue")
colors.discard("purple") # Ne fait rien, pas d'erreur
print(colors) # {'red', 'yellow'}

C. Opérations sur les Ensembles

C'est là que les ensembles montrent toute leur puissance.

Soient deux ensembles :

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

Union (| ou .union()) : Tous les éléments qui sont dans A, ou dans B, ou dans les deux.

union_set = set_a | set_b
# ou set_a.union(set_b)
print(union_set) # {1, 2, 3, 4, 5, 6}

Intersection (& ou .intersection()) : Les éléments qui sont à la fois dans A et dans B.

intersection_set = set_a & set_b
# ou set_a.intersection(set_b)
print(intersection_set) # {3, 4}

Différence (- ou .difference()) : Les éléments qui sont dans A mais pas dans B.

difference_set = set_a - set_b
# ou set_a.difference(set_b)
print(difference_set) # {1, 2}

Différence Symétrique (^ ou .symmetric_difference()) : Les éléments qui sont dans A ou dans B, mais pas dans les deux.
```
sym_diff_set = set_a ^ set_b
# ou set_a.symmetric_difference(set_b)
print(sym_diff_set) # {1, 2, 5, 6}
```

D. Itération et Appartenance

On peut itérer sur un ensemble avec une boucle for.
On peut vérifier l'appartenance d'un élément avec l'opérateur in. C'est une opération très rapide sur les ensembles.

my_set = {10, 20, 30}

for item in my_set:
    print(item)

print(20 in my_set) # True
print(50 in my_set) # False

4. Cas d'usage typique : Trouver les éléments uniques

Le cas d'usage le plus fréquent est la déduplication d'une liste.

email_list = ["a@a.com", "b@b.com", "a@a.com", "c@c.com"]

# 1. Convertir la liste en ensemble pour supprimer les doublons
unique_emails_set = set(email_list)

# 2. Si besoin, reconvertir en liste
unique_emails_list = list(unique_emails_set)

print(unique_emails_list) # ['c@c.com', 'b@b.com', 'a@a.com'] (l'ordre peut varier)

Exercices :

Exercice 14 - Gestion des Compétences des Employés

Objectif

Cet exercice a pour but de vous faire utiliser les ensembles et leurs opérations (intersection, différence) pour comparer les compétences de deux employés.

Contexte

Vous travaillez pour un service RH et vous devez analyser les compétences des employés pour un projet. Vous avez les compétences de deux employés, et vous voulez savoir :

Quelles compétences ils ont en commun.
Quelles compétences sont uniques à chaque employé.

Énoncé

Créez un nouveau fichier Python nommé skill_analyzer.py.

Définissez les compétences de deux employés en utilisant des ensembles :

employee_a_skills = {"Python", "Git", "SQL", "HTML", "CSS"}
employee_b_skills = {"Python", "JavaScript", "HTML", "React", "SQL"}

Trouvez les compétences communes :
- Calculez l'intersection des deux ensembles pour trouver les compétences que les deux employés possèdent.
- Stockez le résultat dans un ensemble common_skills.
- Affichez le résultat.
Trouvez les compétences uniques à chaque employé :
- Calculez la différence entre les compétences de l'employé A et celles de l'employé B pour trouver ce que seul l'employé A sait faire. Stockez le résultat dans unique_to_a.
- Faites l'inverse pour trouver les compétences uniques à l'employé B. Stockez le résultat dans unique_to_b.
- Affichez ces deux résultats.
Listez toutes les compétences requises pour le projet :
- Calculez l'union des deux ensembles pour obtenir un ensemble de toutes les compétences disponibles.
- Stockez le résultat dans total_skills.
- Affichez le résultat.

Résultat Attendu

La sortie de votre script doit ressembler à ceci (l'ordre des éléments dans les ensembles n'a pas d'importance) :

Common skills: {'Python', 'SQL', 'HTML'}
Skills unique to Employee A: {'CSS', 'Git'}
Skills unique to Employee B: {'JavaScript', 'React'}
All skills required for the project: {'CSS', 'Python', 'JavaScript', 'Git', 'React', 'SQL', 'HTML'}

Cliquez ici pour voir un exemple de code de solution

# skill_analyzer.py

# 1. Définition des compétences
employee_a_skills = {"Python", "Git", "SQL", "HTML", "CSS"}
employee_b_skills = {"Python", "JavaScript", "HTML", "React", "SQL"}

# 2. Compétences communes (Intersection)
common_skills = employee_a_skills.intersection(employee_b_skills)
# Alternative : common_skills = employee_a_skills & employee_b_skills
print(f"Common skills: {common_skills}")

# 3. Compétences uniques (Différence)
unique_to_a = employee_a_skills.difference(employee_b_skills)
# Alternative : unique_to_a = employee_a_skills - employee_b_skills
print(f"Skills unique to Employee A: {unique_to_a}")

unique_to_b = employee_b_skills.difference(employee_a_skills)
# Alternative : unique_to_b = employee_b_skills - employee_a_skills
print(f"Skills unique to Employee B: {unique_to_b}")

# 4. Toutes les compétences (Union)
total_skills = employee_a_skills.union(employee_b_skills)
# Alternative : total_skills = employee_a_skills | employee_b_skills
print(f"All skills required for the project: {total_skills}")

1. Quoi : Les Ensembles​

2. Pourquoi : Unicité et Opérations Mathématiques​

3. Comment : Création et Manipulation​

A. Création​

B. Ajout et Suppression​

C. Opérations sur les Ensembles​

D. Itération et Appartenance​

4. Cas d'usage typique : Trouver les éléments uniques​

Exercices :​

Exercice 14 - Gestion des Compétences des Employés​

Objectif​

Contexte​

Énoncé​

Résultat Attendu​