img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Les Sets en Python : Le Guide Complet pour Débutants et Confirmés

Ce tutoriel vous apprendra à manipuler les sets (ensembles) en Python, une structure de données unique qui garantit l'unicité des éléments. Vous découvrirez comment créer des sets, effectuer des opérations mathématiques (union, intersection, différence), et les utiliser efficacement pour résoudre des problèmes courants comme l'élimination de doublons et la recherche ultra-rapide d'éléments.

Sommaire du Chapitre
Introduction aux Sets en Python Qu'est-ce qu'un set (ensemble) ? Caractéristiques principales des sets Quand utiliser un set plutôt qu'une liste ou un tuple ? Créer un Set en Python Syntaxe de base avec les accolades Utiliser la fonction set() Créer un set vide : attention au piège ! Convertir d'autres structures en set Manipuler les Éléments d'un Set Ajouter des éléments (add, update) Supprimer des éléments (remove, discard, pop, clear) Vérifier l'appartenance d'un élément Parcourir un set avec une boucle Opérations Mathématiques sur les Sets Union de sets (|, union) Intersection de sets (&, intersection) Différence de sets (-, difference) Différence symétrique (^, symmetric_difference) Sous-ensembles et sur-ensembles (issubset, issuperset) Méthodes Avancées des Sets Les méthodes avec mise à jour (update, intersection_update, etc.) Tester les relations entre sets (isdisjoint) Copier un set Sets Immutables : Les Frozensets Qu'est-ce qu'un frozenset ? Créer et utiliser un frozenset Différences entre set et frozenset Cas d'Usage Pratiques Éliminer les doublons d'une liste Trouver les éléments communs entre deux listes Filtrer des données uniques Vérifier rapidement la présence d'éléments Performance et Optimisation Complexité temporelle des opérations Sets vs Listes : comparaison de performance Quand éviter les sets ? Pièges et Erreurs Courantes Sets ne conservent pas l'ordre (avant Python 3.7) Impossibilité de stocker des éléments mutables Confusion entre {} et set() Exercices Pratiques Exercice 1 : Gestion de listes de participants Exercice 2 : Analyse de données textuelles Exercice 3 : Opérations sur des ensembles de nombres

Introduction aux Sets en Python

Les sets (ensembles) sont une structure de données fondamentale en Python qui permet de stocker des collections d'éléments uniques et non ordonnés. Ils sont particulièrement utiles pour les opérations mathématiques d'ensemble et l'élimination des doublons.

Qu'est-ce qu'un set (ensemble) ?

Un set est une collection non ordonnée d'éléments uniques et immuables. Contrairement aux listes et tuples, les sets ne permettent pas les doublons et ne conservent pas l'ordre d'insertion des éléments.

definition_set.py
# Création d'un set avec des villes marocaines
					villes_maroc = {"Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"}
					print(f"Set de villes: {villes_maroc}")
					print(f"Type: {type(villes_maroc)}")
					
					# Les sets éliminent automatiquement les doublons
					villes_dupliquees = {"Casablanca", "Rabat", "Casablanca", "Marrakech", "Rabat"}
					print(f"Set sans doublons: {villes_dupliquees}")
					
					# Un set ne peut contenir que des éléments immuables (hashables)
					produits_agricoles = {"olives", "agrumes", "dattes", "amandes"}
					# produits_agricoles.add(["légumes"])  # Erreur: les listes sont mutables
					
					# Mais on peut utiliser des tuples (immuables)
					coordonnees_villes = {(33.5731, -7.5898), (34.0209, -6.8416)}  # Casablanca, Rabat
					print(f"Coordonnées: {coordonnees_villes}")

Caractéristiques principales des sets

Les sets possèdent plusieurs propriétés distinctives qui les rendent uniques parmi les structures de données Python :

caracteristiques_sets.py
# CARACTÉRISTIQUE 1: Éléments uniques (pas de doublons)
					plats_marocains = {"tajine", "couscous", "pastilla", "tajine", "harira"}
					print(f"Plats uniques: {plats_marocains}")  # "tajine" n'apparaît qu'une fois
					
					# CARACTÉRISTIQUE 2: Non ordonné (l'ordre peut varier)
					regions_maroc = {"Casablanca-Settat", "Rabat-Salé-Kénitra", "Marrakech-Safi"}
					print(f"Régions (ordre non garanti): {regions_maroc}")
					
					# CARACTÉRISTIQUE 3: Mutabilité (on peut ajouter/supprimer)
					sites_touristiques = {"Jamaa El Fna", "Hassan II", "Chellah"}
					sites_touristiques.add("Ouzoud")
					sites_touristiques.discard("Chellah")
					print(f"Sites mis à jour: {sites_touristiques}")
					
					# CARACTÉRISTIQUE 4: Opérations mathématiques natives
					villes_cotieres = {"Casablanca", "Tanger", "Agadir", "Essaouira"}
					villes_interieures = {"Marrakech", "Fès", "Meknès", "Casablanca"}
					
					union_villes = villes_cotieres | villes_interieures  # Union
					intersection_villes = villes_cotieres & villes_interieures  # Intersection
					
					print(f"Toutes les villes: {union_villes}")
					print(f"Villes communes: {intersection_villes}")  # Casablanca seulement
					
					# CARACTÉRISTIQUE 5: Tests d'appartenance très rapides
					universites_maroc = {"UM5", "UH1", "UIr", "ENSIAS"}
					print(f"UM5 dans l'ensemble: {"UM5" in universites_maroc}")  # Très rapide même pour de grands sets
					print(f"EMI dans l'ensemble: {"EMI" in universites_maroc}")

Quand utiliser un set plutôt qu'une liste ou un tuple ?

Le choix entre set, liste et tuple dépend du contexte d'utilisation et des opérations que vous souhaitez effectuer :

choix_structure.py
# CAS 1: Quand vous avez besoin d'éléments uniques
					# Liste - permet les doublons
					participants_liste = ["Ahmed", "Fatima", "Ahmed", "Karim", "Fatima"]
					print(f"Liste avec doublons: {participants_liste}")
					
					# Set - élimine automatiquement les doublons
					participants_set = {"Ahmed", "Fatima", "Ahmed", "Karim", "Fatima"}
					print(f"Set sans doublons: {participants_set}")
					
					# CAS 2: Quand vous avez besoin de tests d'appartenance rapides
					marques_voitures = {"Dacia", "Renault", "Peugeot", "Hyundai"}
					
					# Test rapide avec set (complexité O(1) en moyenne)
					if "Dacia" in marques_voitures:
					    print("Dacia est une marque populaire au Maroc")
					
					# Comparaison avec liste (complexité O(n) dans le pire cas)
					marques_liste = ["Dacia", "Renault", "Peugeot", "Hyundai"]
					if "Dacia" in marques_liste:
					    print("Trouvé dans la liste (plus lent pour de grandes listes)")
					
					# CAS 3: Quand vous avez besoin d'opérations mathématiques
					specialites_nord = {"poisson", "huile d'olive", "amandes"}
					specialites_sud = {"dattes", "amandes", "safran"}
					
					# Opérations naturelles avec les sets
					specialites_communes = specialites_nord & specialites_sud
					toutes_specialites = specialites_nord | specialites_sud
					specialites_uniques_nord = specialites_nord - specialites_sud
					
					print(f"Spécialités communes: {specialites_communes}")
					print(f"Toutes les spécialités: {toutes_specialites}")
					print(f"Spécialités uniquement du nord: {specialites_uniques_nord}")
					
					# CAS 4: Quand l'ordre n'a pas d'importance
					# Liste - conserve l'ordre
					villes_visitees_liste = ["Marrakech", "Fès", "Chefchaouen", "Essaouira"]
					print(f"Ordre de visite: {villes_visitees_liste}")
					
					# Set - ordre non garanti
					villes_visitees_set = {"Marrakech", "Fès", "Chefchaouen", "Essaouira"}
					print(f"Villes visitées (ordre quelconque): {villes_visitees_set}")
					
					# RÉSUMÉ DES CHOIX:
					# - Liste: ordre important, doublons autorisés, modifications fréquentes
					# - Tuple: ordre important, immuable, données fixes
					# - Set: ordre sans importance, éléments uniques, tests rapides, opérations mathématiques

Créer un Set en Python

Python offre plusieurs méthodes pour créer des sets, chacune avec ses spécificités. La compréhension des différentes syntaxes est essentielle pour éviter les erreurs courantes et utiliser efficacement cette structure de données.

Syntaxe de base avec les accolades

La manière la plus directe de créer un set est d'utiliser les accolades {} avec des éléments séparés par des virgules. Cette syntaxe est similaire à celle des dictionnaires, mais sans les paires clé-valeur.

syntaxe_accolades.py
# Création d'un set avec des villes marocaines
					villes_imperiales = {"Marrakech", "Fès", "Meknès", "Rabat"}
					print(f"Villes impériales: {villes_imperiales}")
					print(f"Type: {type(villes_imperiales)}")
					
					# Les sets éliminent automatiquement les doublons
					specialites_culinaires = {"tajine", "couscous", "pastilla", "tajine", "harira"}
					print(f"Spécialités uniques: {specialites_culinaires}")  # Un seul "tajine"
					
					# Set avec différents types de données (mais tous immuables)
					elements_divers = {"Casablanca", 2024, (33.5731, -7.5898), True}
					print(f"Éléments divers: {elements_divers}")
					
					# ATTENTION: Les éléments doivent être hashables (immuables)
					# set_impossible = {{"liste"}, "valeur"}  # ERREUR: les listes sont mutables
					
					# Mais les tuples sont autorisés car immuables
					coordonnees = {(31.6295, -7.9811), (34.0209, -6.8416)}  # Marrakech, Rabat
					print(f"Coordonnées géographiques: {coordonnees}")

Utiliser la fonction set()

La fonction set() permet de créer des sets à partir d'itérables existants comme des listes, des tuples ou des chaînes de caractères. C'est particulièrement utile pour convertir d'autres structures de données.

fonction_set.py
# Création à partir d'une liste (élimination des doublons)
					liste_villes = ["Tanger", "Casablanca", "Tanger", "Agadir", "Casablanca"]
					set_villes = set(liste_villes)
					print(f"Liste originale: {liste_villes}")
					print(f"Set sans doublons: {set_villes}")
					
					# Création à partir d'un tuple
					tuple_regions = ("Oriental", "Souss-Massa", "Casablanca-Settat", "Oriental")
					set_regions = set(tuple_regions)
					print(f"Régions uniques: {set_regions}")
					
					# Création à partir d'une chaîne de caractères
					nom_maroc = "Maroc"
					set_lettres = set(nom_maroc)
					print(f"Lettres uniques dans 'Maroc': {set_lettres}")
					
					# Création à partir d'un dictionnaire (prend les clés)
					dialectes_maroc = {
					    "darija": "arabe marocain",
					    "tachelhit": "berbère du Sud",
					    "tarifit": "berbère du Nord",
					    "tamazight": "berbère du Centre"
					}
					set_dialectes = set(dialectes_maroc)
					print(f"Noms des dialectes: {set_dialectes}")
					
					# Création d'un set vide (méthode correcte)
					set_vide = set()
					print(f"Set vide: {set_vide}")
					print(f"Type: {type(set_vide)}")

Créer un set vide : attention au piège !

Un piège courant en Python est la confusion entre la création d'un set vide et d'un dictionnaire vide, car les deux utilisent les accolades {}.

set_vide_piege.py
# PIÈGE: {} crée un dictionnaire vide, pas un set !
					variable_accolades = {}
					print(f"Type de {{}}: {type(variable_accolades)}")  # dict, pas set!
					
					# CORRECTION: Utiliser set() pour créer un set vide
					set_vide_correct = set()
					print(f"Type de set(): {type(set_vide_correct)}")  # set
					
					# Démonstration pratique du problème
					try:
					    variable_accolades.add("Casablanca")  # Erreur: les dict n'ont pas de méthode add()
					except AttributeError as e:
					    print(f"ERREUR avec {{}}: {e}")
					
					# Méthode correcte
					set_vide_correct.add("Rabat")
					set_vide_correct.add("Marrakech")
					print(f"Set après ajouts: {set_vide_correct}")
					
					# Comment distinguer visuellement
					dict_exemple = {"Maroc": "Rabat", "Algérie": "Alger"}
					set_exemple = {"Rabat", "Casablanca", "Marrakech"}
					
					print(f"\nDictionnaire (avec clés-valeurs): {dict_exemple}")
					print(f"Set (valeurs uniquement): {set_exemple}")
					
					# RÈGLE MNÉMOTECHNIQUE:
					# - {} = dict vide (comme un dictionnaire sans mots)
					# - {éléments} = set avec éléments
					# - set() = set vide (toujours sûr)

Convertir d'autres structures en set

La conversion vers les sets est une opération très utile pour éliminer les doublons et bénéficier des opérations d'ensemble. Voyons les conversions les plus courantes.

conversion_structures.py
# CONVERSION 1: Liste → Set (élimination des doublons)
					participants_dupliques = ["Ahmed", "Fatima", "Karim", "Ahmed", "Leila", "Fatima"]
					participants_uniques = set(participants_dupliques)
					print(f"Participants dupliqués: {participants_dupliques}")
					print(f"Participants uniques: {participants_uniques}")
					
					# CONVERSION 2: Tuple → Set
					produits_tuple = ("huile d'olive", "dattes", "amandes", "huile d'olive")
					produits_set = set(produits_tuple)
					print(f"Produits agricoles uniques: {produits_set}")
					
					# CONVERSION 3: Chaîne → Set (caractères uniques)
					ville = "Casablanca"
					lettres_uniques = set(ville)
					print(f"Lettres uniques dans '{ville}': {lettres_uniques}")
					print(f"Nombre de lettres uniques: {len(lettres_uniques)}")
					
					# CONVERSION 4: Dictionnaire → Set (clés uniquement)
					festivals_maroc = {
					    "Mawazine": "Rabat",
					    "FESPAC": "Casablanca",
					    "Festival des Roses": "Kelaa M'Gouna",
					    "Gnaoua": "Essaouira"
					}
					noms_festivals = set(festivals_maroc)
					print(f"Festivals marocains: {noms_festivals}")
					
					# CONVERSION 5: Range → Set
					codes_postaux = set(range(10000, 10010))
					print(f"Codes postaux exemple: {codes_postaux}")
					
					# CONVERSION AVEC COMPRÉHENSION DE SET
					noms_complets = ["Ahmed Alami", "Fatima Zahra", "Karim Bennani", "Leila Alaoui"]
					prenoms = {nom.split()[0] for nom in noms_complets}
					print(f"Prénoms extraits: {prenoms}")
					
					# RECONVERSION: Set → Liste (pour récupérer l'ordre)
					villes_desordonnees = {"Tanger", "Casablanca", "Agadir", "Rabat"}
					villes_ordonnees = sorted(villes_desordonnees)  # Retourne une liste triée
					print(f"Villes triées: {villes_ordonnees}")
					
					# APPLICATION PRATIQUE: Nettoyage de données avec doublons
					clients_brut = ["Ahmed", "fatima", "AHMED", "Karim", "Fatima", "ahmed"]
					clients_propres = {nom.strip().title() for nom in clients_brut}
					print(f"Clients nettoyés: {clients_propres}")

Manipuler les Éléments d'un Set

La manipulation des éléments dans un set inclut l'ajout, la suppression, la vérification d'appartenance et le parcours. Les sets offrent des méthodes spécifiques pour ces opérations, optimisées pour les collections d'éléments uniques.

Ajouter des éléments (add, update)

Python propose deux méthodes principales pour ajouter des éléments à un set : add() pour un seul élément et update() pour plusieurs éléments à la fois.

ajouter_elements.py
# Création d'un set initial de villes marocaines
					villes_maroc = {"Casablanca", "Rabat", "Marrakech"}
					print(f"Set initial: {villes_maroc}")
					
					# MÉTHODE 1: add() - Ajouter un seul élément
					villes_maroc.add("Fès")
					print(f"Après add('Fès'): {villes_maroc}")
					
					# add() ignore les doublons silencieusement
					villes_maroc.add("Casablanca")  # Déjà présent - aucun effet
					print(f"Après add('Casablanca') doublon: {villes_maroc}")
					
					# MÉTHODE 2: update() - Ajouter plusieurs éléments
					nouvelles_villes = ["Tanger", "Agadir", "Meknès"]
					villes_maroc.update(nouvelles_villes)
					print(f"Après update avec liste: {villes_maroc}")
					
					# update() fonctionne avec différents itérables
					villes_maroc.update(("Oujda", "Tetouan"))  # Tuple
					villes_maroc.update("Safi")  # Chaîne (ajoute chaque caractère!)
					print(f"Après divers update: {villes_maroc}")
					
					# Exemple pratique: Gestion d'inscriptions à un événement
					participants = {"Ahmed Alami", "Fatima Zahra"}
					nouveaux_inscrits = ["Karim Bennani", "Leila Alaoui", "Ahmed Alami"]
					
					print(f"\nParticipants initiaux: {participants}")
					participants.update(nouveaux_inscrits)
					print(f"Participants après nouvelles inscriptions: {participants}")
					
					# Ajout avec opérateur union (création d'un nouveau set)
					villes_nord = {"Tanger", "Tetouan", "Chefchaouen"}
					villes_sud = {"Agadir", "Marrakech", "Ouarzazate"}
					toutes_villes = villes_nord | villes_sud  # Union crée un nouveau set
					print(f"Union des villes: {toutes_villes}")

Supprimer des éléments (remove, discard, pop, clear)

Plusieurs méthodes permettent de supprimer des éléments d'un set, chacune avec un comportement différent selon que l'élément existe ou non.

supprimer_elements.py
# Set de départ avec des spécialités marocaines
					specialites = {"tajine", "couscous", "pastilla", "harira", "rfissa", "bissara"}
					print(f"Spécialités initiales: {specialites}")
					
					# MÉTHODE 1: remove() - Supprime un élément spécifique (erreur si absent)
					specialites.remove("rfissa")
					print(f"Après remove('rfissa'): {specialites}")
					
					try:
					    specialites.remove("tanjia")  # Élément absent → KeyError
					except KeyError:
					    print("Erreur: 'tanjia' n'est pas dans le set")
					
					# MÉTHODE 2: discard() - Supprime un élément (pas d'erreur si absent)
					specialites.discard("bissara")
					specialites.discard("tanjia")  # Aucune erreur même si absent
					print(f"Après discard: {specialites}")
					
					# MÉTHODE 3: pop() - Supprime et retourne un élément arbitraire
					element_supprime = specialites.pop()
					print(f"Élément supprimé par pop(): '{element_supprime}'")
					print(f"Set après pop(): {specialites}")
					
					# pop() sur un set vide génère une erreur
					set_vide = set()
					try:
					    set_vide.pop()
					except KeyError:
					    print("Erreur: pop() sur un set vide")
					
					# MÉTHODE 4: clear() - Vide complètement le set
					specialites.clear()
					print(f"Après clear(): {specialites}")
					
					# Exemple pratique: Gestion d'inventaire
					produits_disponibles = {"huile d'olive", "dattes", "amandes", "miel", "safran"}
					produits_vendus = ["dattes", "amandes"]
					
					print(f"\nInventaire initial: {produits_disponibles}")
					for produit in produits_vendus:
					    produits_disponibles.discard(produit)  # Pas d'erreur si produit déjà vendu
					print(f"Inventaire après vente: {produits_disponibles}")
					
					# RÉCAPITULATIF:
					# - remove(x): supprime x, erreur si absent
					# - discard(x): supprime x, silencieux si absent
					# - pop(): supprime un élément arbitraire
					# - clear(): vide tout le set

Vérifier l'appartenance d'un élément

La vérification d'appartenance est une opération très rapide avec les sets, ce qui les rend idéaux pour les tests de présence.

verifier_appartenance.py
# Set de villes marocaines touristiques
					villes_touristiques = {"Marrakech", "Fès", "Casablanca", "Chefchaouen", "Essaouira"}
					
					# Vérification avec l'opérateur 'in' (très rapide)
					print(f"Marrakech est touristique: {"Marrakech" in villes_touristiques}")
					print(f"Rabat est touristique: {"Rabat" in villes_touristiques}")
					
					# Vérification avec 'not in'
					print(f"Tanger n'est pas touristique: {"Tanger" not in villes_touristiques}")
					
					# Utilisation dans des conditions
					ville_a_visiter = "Fès"
					if ville_a_visiter in villes_touristiques:
					    print(f"✅ {ville_a_visiter} est une destination touristique recommandée!")
					else:
					    print(f"❌ {ville_a_visiter} n'est pas dans nos recommandations touristiques")
					
					# Exemple pratique: Système d'autorisation
					utilisateurs_autorises = {"admin", "moderateur", "editeur"}
					utilisateur_courant = "visiteur"
					
					if utilisateur_courant in utilisateurs_autorises:
					    print("Accès autorisé au panneau d'administration")
					else:
					    print("Accès refusé: privilèges insuffisants")
					
					# Comparaison de performance avec les listes
					import time
					
					# Grand set
					grand_set = set(range(1000000))
					# Grande liste
					grande_liste = list(range(1000000))
					
					# Test avec set (très rapide)
					debut = time.time()
					trouve_set = 999999 in grand_set
					temps_set = time.time() - debut
					
					# Test avec liste (beaucoup plus lent)
					debut = time.time()
					trouve_liste = 999999 in grande_liste
					temps_liste = time.time() - début
					
					print(f"\nComparaison de performance:")
					print(f"Set: {temps_set:.6f} secondes")
					print(f"Liste: {temps_liste:.6f} secondes")
					print(f"Le set est {temps_liste/temps_set:.0f}x plus rapide!")

Parcourir un set avec une boucle

Le parcours d'un set se fait avec une boucle for, mais l'ordre des éléments n'est pas garanti. Les sets sont itérables comme les autres collections Python.

parcourir_set.py
# Set de monuments historiques marocains
					monuments = {
					    "Hassan II",
					    "Koutoubia",
					    "Chellah",
					    "Kasbah des Oudaias",
					    "Mausolée Mohammed V"
					}
					
					# Parcours simple avec for
					print("Monuments à visiter:")
					for monument in monuments:
					    print(f" - {monument}")
					
					# L'ordre peut varier à chaque exécution
					print(f"\nOrdre actuel: {list(monuments)}")
					
					# Parcours avec enumerate (pour avoir un index)
					print("\nMonuments avec numérotation:")
					for i, monument in enumerate(monuments, 1):
					    print(f"{i}. {monument}")
					
					# Parcours avec condition
					print("\nMonuments contenant 'II':")
					for monument in monuments:
					    if "II" in monument:
					        print(f" - {monument}")
					
					# Transformation pendant le parcours (création d'un nouveau set)
					monuments_majuscules = {monument.upper() for monument in monuments}
					print(f"\nMonuments en majuscules: {monuments_majuscules}")
					
					# Exemple pratique: Gestion de stocks
					produits_stock = {"dattes", "amandes", "huile d'olive", "miel", "safran"}
					produits_a_verifier = {"dattes", "figues", "miel"}
					
					print("\nVérification du stock:")
					for produit in produits_a_verifier:
					    statut = "✅ EN STOCK" if produit in produits_stock else "❌ RUPTURE"
					    print(f"{statut} - {produit}")
					
					# IMPORTANT: Ne pas modifier un set pendant son parcours
					produits = {"dattes", "amandes", "huile"}
					print(f"\nSet avant modification: {produits}")
					
					# Créer une copie pour modification pendant le parcours
					for produit in produits.copy():  # Parcours de la copie
					    if produit == "amandes":
					        produits.add("noix")  # Modification safe
					
					print(f"Set après modification: {produits}")

Opérations Mathématiques sur les Sets

Les sets en Python supportent les opérations mathématiques classiques sur les ensembles : union, intersection, différence et différence symétrique. Ces opérations sont disponibles sous forme d'opérateurs ou de méthodes, et permettent de manipuler efficacement les collections d'éléments uniques.

Union de sets (|, union)

L'union de deux sets combine tous les éléments des deux ensembles, en éliminant automatiquement les doublons. Elle peut être réalisée avec l'opérateur | ou la méthode union().

union_sets.py
# Sets de villes marocaines par région
					villes_nord = {"Tanger", "Tetouan", "Chefchaouen", "Larache"}
					villes_sud = {"Agadir", "Marrakech", "Ouarzazate", "Tiznit"}
					villes_centre = {"Casablanca", "Rabat", "Fès", "Meknès"}
					
					# Union avec l'opérateur |
					villes_nord_centre = villes_nord | villes_centre
					print(f"Villes du Nord | Centre: {villes_nord_centre}")
					
					# Union avec la méthode union()
					toutes_villes = villes_nord.union(villes_centre, villes_sud)
					print(f"Toutes les villes: {toutes_villes}")
					
					# Union avec plusieurs sets
					villes_cotieres = {"Tanger", "Casablanca", "Agadir", "Essaouira"}
					villes_interieures = {"Marrakech", "Fès", "Meknès", "Oujda"}
					union_multiple = villes_cotieres | villes_interieures | {"Rabat"}
					print(f"Union multiple: {union_multiple}")
					
					# Exemple pratique: Consolidation de listes d'étudiants
					etudiants_filiere_a = {"Ahmed Alami", "Fatima Zahra", "Karim Bennani"}
					etudiants_filiere_b = {"Leila Alaoui", "Mehdi Chraibi", "Ahmed Alami"}
					etudiants_filiere_c = {"Youssef Kamil", "Nora Sefrioui", "Fatima Zahra"}
					
					tous_etudiants = etudiants_filiere_a.union(etudiants_filiere_b, etudiants_filiere_c)
					print(f"\nTous les étudiants (sans doublons): {tous_etudiants}")
					print(f"Nombre total d'étudiants uniques: {len(tous_etudiants)}")
					
					# Comparaison union vs update
					set_original = {"A", "B"}
					nouveau_set = set_original | {"C", "D"}  # Crée un nouveau set
					set_original.update({"E", "F"})  # Modifie le set original
					
					print(f"\nUnion (nouveau set): {nouveau_set}")
					print(f"Update (original modifié): {set_original}")

Intersection de sets (&, intersection)

L'intersection retourne les éléments communs à tous les sets. Utilisez l'opérateur & ou la méthode intersection().

intersection_sets.py
# Sets de compétences par département
					competences_tech = {"Python", "JavaScript", "SQL", "Docker"}
					competences_design = {"Figma", "Photoshop", "JavaScript", "UI/UX"}
					competences_marketing = {"SEO", "Analytics", "SQL", "JavaScript"}
					
					# Intersection avec l'opérateur &
					commun_tech_design = competences_tech & competences_design
					print(f"Compétences communes Tech & Design: {commun_tech_design}")
					
					# Intersection avec la méthode intersection()
					competences_toutes_equipes = competences_tech.intersection(competences_design, competences_marketing)
					print(f"Comp communes aux 3 équipes: {competences_toutes_equipes}")
					
					# Exemple pratique: Recherche de profils communs
					candidats_python = {"Ahmed", "Fatima", "Karim", "Leila"}
					candidats_javascript = {"Karim", "Mehdi", "Youssef", "Fatima"}
					candidats_sql = {"Fatima", "Nora", "Ahmed", "Karim"}
					
					# Candidats maîtrisant Python ET JavaScript
					fullstack = candidats_python & candidats_javascript
					print(f"\nCandidats Fullstack: {fullstack}")
					
					# Candidats maîtrisant les 3 technologies
					expert_technique = candidats_python & candidats_javascript & candidats_sql
					print(f"Experts techniques: {expert_technique}")
					
					# Intersection avec des sets vides
					set_a = {"A", "B"}
					set_b = set()
					intersection_vide = set_a & set_b
					print(f"Intersection avec set vide: {intersection_vide}")
					
					# Application: Filtrage de produits disponibles
					produits_boutique_a = {"huile d'olive", "dattes", "amandes", "miel"}
					produits_boutique_b = {"dattes", "safran", "amandes", "thé"}
					produits_communs = produits_boutique_a & produits_boutique_b
					print(f"\nProduits disponibles dans les deux boutiques: {produits_communs}")

Différence de sets (-, difference)

La différence retourne les éléments présents dans le premier set mais absents du second. Utilisez l'opérateur - ou la méthode difference().

difference_sets.py
# Sets de villes visitées par deux touristes
					villes_visitees_ahmed = {"Marrakech", "Fès", "Casablanca", "Chefchaouen"}
					villes_visitees_fatima = {"Marrakech", "Agadir", "Essaouira", "Tanger"}
					
					# Différence avec l'opérateur -
					villes_uniques_ahmed = villes_visitees_ahmed - villes_visitees_fatima
					print(f"Villes visitées seulement par Ahmed: {villes_uniques_ahmed}")
					
					villes_uniques_fatima = villes_visitees_fatima - villes_visitees_ahmed
					print(f"Villes visitées seulement par Fatima: {villes_uniques_fatima}")
					
					# Différence avec la méthode difference()
					villes_communes = villes_visitees_ahmed & villes_visitees_fatima
					print(f"Villes visitées par les deux: {villes_communes}")
					
					# Différence multiple
					toutes_villes = {"Marrakech", "Fès", "Casablanca", "Agadir", "Tanger", "Rabat"}
					villes_non_visitees = toutes_villes - villes_visitees_ahmed - villes_visitees_fatima
					print(f"Villes non visitées: {villes_non_visitees}")
					
					# Exemple pratique: Gestion de stocks
					produits_initial = {"huile", "dattes", "amandes", "miel", "safran"}
					produits_vendus = {"dattes", "amandes"}
					produits_restants = produits_initial - produits_vendus
					print(f"\nProduits en stock: {produits_restants}")
					
					# Application: Analyse de compétences manquantes
					competences_requises = {"Python", "SQL", "Docker", "Git"}
					competences_candidat = {"Python", "Git"}
					competences_manquantes = competences_requises - competences_candidat
					print(f"Compétences à acquérir: {competences_manquantes}")
					
					# Différence avec plusieurs sets
					langages_populaires = {"Python", "JavaScript", "Java", "C++"}
					langages_web = {"JavaScript", "Python", "PHP"}
					langages_mobile = {"Java", "Swift", "Kotlin"}
					
					# Langages populaires mais pas pour web ou mobile
					langages_autres = langages_populaires.difference(langages_web, langages_mobile)
					print(f"Langages populaires hors web/mobile: {langages_autres}")

Différence symétrique (^, symmetric_difference)

La différence symétrique retourne les éléments présents dans un seul des deux sets (exclusif à chaque set). Utilisez l'opérateur ^ ou la méthode symmetric_difference().

difference_symetrique.py
# Sets de préférences alimentaires
					plats_karim = {"tajine", "couscous", "pastilla", "harira"}
					plats_leila = {"couscous", "rfissa", "bissara", "harira"}
					
					# Différence symétrique avec l'opérateur ^
					preferences_uniques = plats_karim ^ plats_leila
					print(f"Plats préférés par un seul: {preferences_uniques}")
					
					# Différence symétrique avec la méthode
					preferences_exclusives = plats_karim.symmetric_difference(plats_leila)
					print(f"Plats exclusifs (méthode): {preferences_exclusives}")
					
					# Vérification: même résultat
					print(f"Résultats identiques: {preferences_uniques == preferences_exclusives}")
					
					# Relation avec union et intersection
					union_totale = plats_karim | plats_leila
					intersection_commune = plats_karim & plats_leila
					difference_sym_calculee = union_totale - intersection_commune
					
					print(f"Diff sym calculée (union - inter): {difference_sym_calculee}")
					print(f"Équivalent à ^: {difference_sym_calculee == preferences_uniques}")
					
					# Exemple pratique: Comparaison de listes de courses
					courses_ahmed = {"huile", "dattes", "amandes", "pain"}
					courses_fatima = {"dattes", "lait", "œufs", "pain"}
					
					produits_differents = courses_ahmed ^ courses_fatima
					produits_communs = courses_ahmed & courses_fatima
					
					print(f"\nProduits à acheter par une seule personne: {produits_differents}")
					print(f"Produits à acheter par les deux: {produits_communs}")
					
					# Application: Détection de changements
					anciennes_competences = {"Python", "SQL", "Excel"}
					nouvelles_competences = {"Python", "Docker", "Git"}
					
					changements = anciennes_competences ^ nouvelles_competences
					print(f"\nCompétences ajoutées ou retirées: {changements}")
					
					# Différence symétrique avec elle-même = set vide
					set_identique = {"A", "B"}
					resultat = set_identique ^ set_identique
					print(f"Différence symétrique d'un set avec lui-même: {resultat}")

Sous-ensembles et sur-ensembles (issubset, issuperset)

Ces méthodes permettent de vérifier les relations d'inclusion entre sets. Un set A est un sous-ensemble de B si tous les éléments de A sont dans B.

sous_ensembles.py
# Sets de spécialités culinaires marocaines
					tous_plats = {"tajine", "couscous", "pastilla", "harira", "rfissa", "bissara"}
					plats_festifs = {"couscous", "pastilla", "tajine"}
					plats_quotidiens = {"harira", "bissara"}
					plats_regionaux = {"rfissa", "tajine"}
					
					# Vérification de sous-ensemble avec issubset()
					print(f"Plats festifs ⊆ Tous plats: {plats_festifs.issubset(tous_plats)}")
					print(f"Plats quotidiens ⊆ Tous plats: {plats_quotidiens.issubset(tous_plats)}")
					
					# Vérification de sur-ensemble avec issuperset()
					print(f"Tous plats ⊇ Plats festifs: {tous_plats.issuperset(plats_festifs)}")
					print(f"Tous plats ⊇ Plats quotidiens: {tous_plats.issuperset(plats_quotidiens)}")
					
					# Opérateurs de comparaison (<= pour sous-ensemble, >= pour sur-ensemble)
					print(f"Plats festifs <= Tous plats: {plats_festifs <= tous_plats}")
					print(f"Tous plats >= Plats festifs: {tous_plats >= plats_festifs}")
					
					# Sous-ensemble strict (opérateur <)
					print(f"Plats festifs ⊂ Tous plats (strict): {plats_festifs < tous_plats}")
					print(f"Tous plats ⊂ Tous plats (strict): {tous_plats < tous_plats}")  # False
					
					# Exemple pratique: Vérification de prérequis
					competences_requises = {"Python", "SQL", "Git"}
					competences_candidat_1 = {"Python", "SQL"}
					competences_candidat_2 = {"Python", "SQL", "Git", "Docker"}
					
					print(f"\nCandidat 1 satisfait les prérequis: {competences_requises.issubset(competences_candidat_1)}")
					print(f"Candidat 2 satisfait les prérequis: {competences_requises.issubset(competences_candidat_2)}")
					
					# Application: Validation de configuration
					modules_necessaires = {"auth", "database", "api"}
					modules_actives = {"auth", "database", "api", "cache"}
					modules_incomplets = {"auth", "database"}
					
					print(f"\nConfiguration valide: {modules_necessaires.issubset(modules_actives)}")
					print(f"Configuration incomplète: {modules_necessaires.issubset(modules_incomplets)}")
					
					# Cas particuliers
					set_vide = set()
					print(f"\nSet vide ⊆ Tous plats: {set_vide.issubset(tous_plats)}")
					print(f"Tous plats ⊇ Set vide: {tous_plats.issuperset(set_vide)}")
					print(f"Set vide ⊆ Set vide: {set_vide.issubset(set_vide)}")

Méthodes Avancées des Sets

Au-delà des opérations basiques, Python offre des méthodes avancées pour manipuler les sets de manière plus sophistiquée. Ces méthodes permettent des mises à jour en place, des tests de relations complexes et des opérations de copie sécurisées.

Les méthodes avec mise à jour (update, intersection_update, etc.)

Les méthodes avec "_update" modifient le set original au lieu de créer un nouveau set. Elles sont plus efficaces en mémoire lorsque vous n'avez pas besoin de conserver l'état précédent.

methodes_update.py
# Sets de départ pour les exemples
					villes_visitees = {"Marrakech", "Fès", "Casablanca"}
					villes_souhaitees = {"Chefchaouen", "Essaouira", "Fès"}
					villes_cotieres = {"Essaouira", "Agadir", "Tanger"}
					
					print(f"Set initial: {villes_visitees}")
					
					# MÉTHODE 1: update() - Union en place
					villes_visitees.update(villes_souhaitees)
					print(f"Après update(): {villes_visitees}")
					
					# MÉTHODE 2: intersection_update() - Intersection en place
					villes_visitees.intersection_update(villes_cotieres)
					print(f"Après intersection_update(): {villes_visitees}")
					
					# Réinitialisation pour les exemples suivants
					villes_visitees = {"Marrakech", "Fès", "Casablanca", "Agadir"}
					villes_nord = {"Tanger", "Tetouan", "Fès"}
					villes_sud = {"Agadir", "Marrakech", "Ouarzazate"}
					
					# MÉTHODE 3: difference_update() - Différence en place
					villes_visitees.difference_update(villes_nord)
					print(f"Après difference_update(): {villes_visitees}")
					
					# MÉTHODE 4: symmetric_difference_update() - Différence symétrique en place
					villes_visitees.symmetric_difference_update(villes_sud)
					print(f"Après symmetric_difference_update(): {villes_visitees}")
					
					# Comparaison avec les opérateurs (qui créent de nouveaux sets)
					set_original = {"A", "B"}
					autre_set = {"B", "C"}
					
					# Avec opérateur (nouveau set)
					union_operator = set_original | autre_set
					print(f"\nAvec opérateur | - Original inchangé: {set_original}")
					print(f"Nouveau set créé: {union_operator}")
					
					# Avec méthode _update (modification en place)
					set_original.update(autre_set)
					print(f"Avec update() - Original modifié: {set_original}")
					
					# Exemple pratique: Gestion de préférences utilisateur
					preferences_actuelles = {"tajine", "couscous", "harira"}
					nouvelles_preferences = {"pastilla", "couscous", "rfissa"}
					preferences_a_retirer = {"harira"}
					
					# Mise à jour des préférences
					preferences_actuelles.update(nouvelles_preferences)
					preferences_actuelles.difference_update(preferences_a_retirer)
					
					print(f"\nPréférences finales: {preferences_actuelles}")
					
					# AVANTAGES des méthodes _update:
					# - Plus efficace en mémoire (pas de création de nouveau set)
					# - Plus rapide pour les grands sets
					# - Modification directe de l'objet

Tester les relations entre sets (isdisjoint)

La méthode isdisjoint() permet de vérifier si deux sets n'ont aucun élément en commun. C'est particulièrement utile pour détecter des ensembles mutuellement exclusifs.

tester_relations.py
# Sets de spécialités culinaires par région
					specialites_nord = {"bissara", "rfissa", "pastilla"}
					specialites_sud = {"tanjia", "méchoui", "baghrir"}
					specialites_centre = {"tajine", "couscous", "harira"}
					specialites_communes = {"couscous", "tajine"}
					
					# Test de disjointure (aucun élément commun)
					print(f"Nord et Sud disjoints: {specialites_nord.isdisjoint(specialites_sud)}")
					print(f"Nord et Centre disjoints: {specialites_nord.isdisjoint(specialites_centre)}")
					print(f"Sud et Centre disjoints: {specialites_sud.isdisjoint(specialites_centre)}")
					
					# Relation avec l'intersection
					intersection_nord_sud = specialites_nord & specialites_sud
					print(f"Intersection Nord-Sud: {intersection_nord_sud}")
					print(f"isdisjoint équivaut à intersection vide: {len(intersection_nord_sud) == 0}")
					
					# Exemple pratique: Attribution de ressources
					equipe_developpement = {"Ahmed", "Fatima", "Karim"}
					equipe_design = {"Leila", "Youssef", "Nora"}
					equipe_marketing = {"Mehdi", "Karim", "Sara"}
					
					# Vérification d'équipes disjointes
					print(f"\nÉquipes Dev et Design disjointes: {equipe_developpement.isdisjoint(equipe_design)}")
					print(f"Équipes Dev et Marketing disjointes: {equipe_developpement.isdisjoint(equipe_marketing)}")
					
					# Application: Gestion de conflits d'emploi du temps
					creneaux_ahmed = {"09:00", "11:00", "14:00"}
					creneaux_fatima = {"10:00", "15:00", "16:00"}
					creneaux_karim = {"09:00", "13:00"}
					
					print(f"\nAhmed et Fatima peuvent travailler ensemble: {creneaux_ahmed.isdisjoint(creneaux_fatima)}")
					print(f"Ahmed et Karim peuvent travailler ensemble: {creneaux_ahmed.isdisjoint(creneaux_karim)}")
					
					# Cas particuliers avec set vide
					set_vide = set()
					set_quelconque = {"A", "B", "C"}
					
					print(f"\nSet vide disjoint avec n'importe quel set: {set_vide.isdisjoint(set_quelconque)}")
					print(f"Set vide disjoint avec lui-même: {set_vide.isdisjoint(set_vide)}")
					
					# Utilisation dans des conditions
					competences_requises = {"Python", "SQL"}
					competences_candidat = {"JavaScript", "HTML"}
					
					if competences_requises.isdisjoint(competences_candidat):
					    print("\n❌ Candidat ne possède aucune compétence requise")
					else:
					    print("\n✅ Candidat possède au moins une compétence requise")
					
					# Relation avec d'autres tests d'ensemble
					set_a = {"A", "B"}
					set_b = {"C", "D"}
					set_c = {"B", "C"}
					
					print(f"\nA et B disjoints: {set_a.isdisjoint(set_b)}")
					print(f"A et C disjoints: {set_a.isdisjoint(set_c)}")
					print(f"B et C disjoints: {set_b.isdisjoint(set_c)}")

Copier un set

La copie de sets est une opération cruciale pour éviter les modifications accidentelles. Python offre plusieurs méthodes pour copier un set, chacune avec ses spécificités.

copier_set.py
# Set original de villes marocaines
					villes_original = {"Marrakech", "Fès", "Casablanca", "Rabat"}
					print(f"Set original: {villes_original}")
					print(f"ID mémoire original: {id(villes_original)}")
					
					# MÉTHODE 1: copy() - Copie superficielle standard
					villes_copie = villes_original.copy()
					print(f"\nAvec copy(): {villes_copie}")
					print(f"ID mémoire copie: {id(villes_copie)}")
					print(f"Même objet? {villes_original is villes_copie}")
					print(f"Contenu égal? {villes_original == villes_copie}")
					
					# MÉTHODE 2: set() constructor - Crée un nouveau set
					villes_constructor = set(villes_original)
					print(f"\nAvec set(): {villes_constructor}")
					print(f"ID mémoire constructor: {id(villes_constructor)}")
					print(f"Même objet? {villes_original is villes_constructor}")
					
					# MÉTHODE 3: Slicing avec [:] - NE FONCTIONNE PAS pour les sets!
					# villes_slice = villes_original[:]  # TypeError: les sets ne supportent pas le slicing
					print(f"\nSlicing [:]: Non supporté par les sets")
					
					# Démontration de l'indépendance des copies
					villes_original.add("Tanger")
					villes_copie.add("Agadir")
					villes_constructor.discard("Rabat")
					
					print(f"\nAprès modifications:")
					print(f"Original: {villes_original}")
					print(f"Copie: {villes_copie}")
					print(f"Constructor: {villes_constructor}")
					
					# Exemple pratique: Sauvegarde d'état
					participants_actuels = {"Ahmed", "Fatima", "Karim"}
					sauvegarde_participants = participants_actuels.copy()
					
					# Simulation de modifications
					participants_actuels.add("Leila")
					participants_actuels.discard("Karim")
					
					print(f"\nGestion des participants:")
					print(f"État actuel: {participants_actuels}")
					print(f"Sauvegarde: {sauvegarde_participants}")
					
					# Restauration depuis la sauvegarde
					participants_actuels = sauvegarde_participants.copy()
					print(f"Après restauration: {participants_actuels}")
					
					# Cas des sets contenant des objets mutables
					set_avec_tuples = {(1, 2), (3, 4)}
					copie_tuples = set_avec_tuples.copy()
					
					# Les tuples sont immuables, donc pas de problème de copie profonde
					print(f"\nSet avec tuples - copie safe: {copie_tuples}")
					
					# ATTENTION: copy() fait une copie superficielle (shallow copy)
					# Pour les objets complexes, une copie profonde peut être nécessaire
					import copy
					
					# Exemple avec des frozensets (immuables)
					set_complexe = {frozenset([1, 2]), frozenset([3, 4])}
					copie_profonde = copy.deepcopy(set_complexe)
					
					print(f"\nSet complexe original: {set_complexe}")
					print(f"Copie profonde: {copie_profonde}")
					print(f"Même objet? {set_complexe is copie_profonde}")
					
					# RÉCAPITULATIF des méthodes de copie:
					# - copy(): méthode standard, copie superficielle
					# - set(): constructeur, équivalent à copy()
					# - copy.deepcopy(): pour les structures complexes
					# - [:]: NON supporté par les sets

Sets Immutables : Les Frozensets

Les frozensets sont la version immuable des sets en Python. Ils partagent les mêmes caractéristiques que les sets classiques (éléments uniques, non ordonnés) mais ne peuvent pas être modifiés après leur création. Cette immutabilité les rend particulièrement utiles comme clés de dictionnaires ou éléments d'autres sets.

Qu'est-ce qu'un frozenset ?

Un frozenset est une collection immuable d'éléments uniques et non ordonnés. Comme les sets classiques, ils éliminent les doublons, mais contrairement à eux, ils ne peuvent pas être modifiés après leur création.

quest_ce_frozenset.py
# Création d'un frozenset de villes impériales marocaines
					villes_imperiales = frozenset(["Marrakech", "Fès", "Meknès", "Rabat"])
					print(f"Frozenset des villes impériales: {villes_imperiales}")
					print(f"Type: {type(villes_imperiales)}")
					print(f"Taille: {len(villes_imperiales)}")
					
					# Les frozensets éliminent aussi les doublons
					specialites = frozenset(["tajine", "couscous", "tajine", "pastilla"])
					print(f"Spécialités uniques: {specialites}")
					
					# IMMUTABILITÉ: Impossible de modifier un frozenset
					try:
					    villes_imperiales.add("Casablanca")  # Erreur!
					except AttributeError as e:
					    print(f"❌ Impossible d'ajouter: {e}")
					
					try:
					    villes_imperiales.discard("Rabat")  # Erreur!
					except AttributeError as e:
					    print(f"❌ Impossible de supprimer: {e}")
					
					# Mais on peut faire des opérations qui créent de nouveaux frozensets
					nouvelles_villes = villes_imperiales | frozenset(["Casablanca"])
					print(f"Nouveau frozenset: {nouvelles_villes}")
					print(f"Original inchangé: {villes_imperiales}")
					
					# Les frozensets sont hashables (contrairement aux sets normaux)
					print(f"Hash du frozenset: {hash(villes_imperiales)}")
					
					# Comparaison avec un set normal (non hashable)
					set_normal = {"Marrakech", "Fès"}
					try:
					    print(hash(set_normal))  # Erreur!
					except TypeError as e:
					    print(f"❌ Set normal non hashable: {e}")
					
					# CARACTÉRISTIQUES PRINCIPALES des frozensets:
					# - Éléments uniques (comme les sets)
					# - Non ordonné (comme les sets)
					# - IMMUTABLE (contrairement aux sets)
					# - Hashable (peut être clé de dictionnaire)
					# - Peut contenir d'autres frozensets

Créer et utiliser un frozenset

La création d'un frozenset se fait principalement avec la fonction frozenset(). Une fois créé, on peut l'utiliser dans la plupart des opérations disponibles pour les sets classiques.

creer_utiliser_frozenset.py
# DIFFÉRENTES FAÇONS DE CRÉER UN FROZENSET
					
					# 1. À partir d'une liste
					villes_liste = ["Casablanca", "Rabat", "Marrakech", "Casablanca"]
					fs_villes = frozenset(villes_liste)
					print(f"Frozenset depuis liste: {fs_villes}")
					
					# 2. À partir d'un tuple
					specialites_tuple = ("tajine", "couscous", "pastilla", "harira")
					fs_specialites = frozenset(specialites_tuple)
					print(f"Frozenset depuis tuple: {fs_specialites}")
					
					# 3. À partir d'un set normal
					set_normal = {"nord", "sud", "est", "ouest"}
					fs_regions = frozenset(set_normal)
					print(f"Frozenset depuis set: {fs_regions}")
					
					# 4. À partir d'une chaîne de caractères
					fs_lettres = frozenset("Maroc")
					print(f"Frozenset depuis chaîne: {fs_lettres}")
					
					# 5. Frozenset vide
					fs_vide = frozenset()
					print(f"Frozenset vide: {fs_vide}")
					
					# OPÉRATIONS DISPONIBLES SUR LES FROZENSETS
					fs_a = frozenset(["tajine", "couscous", "pastilla"])
					fs_b = frozenset(["couscous", "harira", "rfissa"])
					
					# Opérations mathématiques (retournent de nouveaux frozensets)
					union_fs = fs_a | fs_b
					intersection_fs = fs_a & fs_b
					difference_fs = fs_a - fs_b
					diff_sym_fs = fs_a ^ fs_b
					
					print(f"\nUnion: {union_fs}")
					print(f"Intersection: {intersection_fs}")
					print(f"Différence: {difference_fs}")
					print(f"Différence symétrique: {diff_sym_fs}")
					
					# Tests d'appartenance et relations
					print(f"\n'tajine' dans fs_a: {"tajine" in fs_a}")
					print(f"fs_a ⊆ fs_b: {fs_a.issubset(fs_b)}")
					print(f"fs_a et fs_b disjoints: {fs_a.isdisjoint(fs_b)}")
					
					# Parcours avec boucle for
					print(f"\nÉléments de fs_a:")
					for plat in fs_a:
					    print(f"  - {plat}")
					
					# UTILISATION PRATIQUE: Frozenset comme clé de dictionnaire
					regions_par_pays = {
					    frozenset(["Casablanca-Settat", "Rabat-Salé-Kénitra"]): "Régions centrales",
					    frozenset(["Tanger-Tétouan-Al Hoceïma", "Fès-Meknès"]): "Régions du Nord",
					    frozenset(["Souss-Massa", "Guelmim-Oued Noun"]): "Régions du Sud"
					}
					
					print(f"\nDictionnaire avec frozensets comme clés:")
					for regions, categorie in regions_par_pays.items():
					    print(f"  {list(regions)} → {categorie}")
					
					# Accès via une clé frozenset
					cle_recherche = frozenset(["Casablanca-Settat", "Rabat-Salé-Kénitra"])
					print(f"Catégorie pour {list(cle_recherche)}: {regions_par_pays[cle_recherche]}")

Différences entre set et frozenset

Bien que similaires dans leur structure, les sets et frozensets présentent des différences cruciales qui déterminent leurs cas d'usage respectifs.

differences_set_frozenset.py
# COMPARAISON CÔTE À CÔTE
					set_normal = {"Marrakech", "Fès", "Casablanca"}
					frozenset_immutable = frozenset(["Marrakech", "Fès", "Casablanca"])
					
					print("=== COMPARAISON SET vs FROZENSET ===")
					print(f"Set: {set_normal}")
					print(f"Frozenset: {frozenset_immutable}")
					
					# DIFFÉRENCE 1: Mutabilité
					print(f"\n1. MUTABILITÉ:")
					set_normal.add("Rabat")
					print(f"   Set après add(): {set_normal}")
					
					try:
					    frozenset_immutable.add("Rabat")
					except AttributeError:
					    print("   ❌ Frozenset: Impossible d'ajouter (immutable)")
					
					# DIFFÉRENCE 2: Hashabilité
					print(f"\n2. HASHABILITÉ:")
					try:
					    hash_set = hash(set_normal)
					    print(f"   ✅ Set: hashable")
					except TypeError:
					    print("   ❌ Set: non hashable")
					
					print(f"   ✅ Frozenset: hashable (hash: {hash(frozenset_immutable)})")
					
					# DIFFÉRENCE 3: Utilisation comme clé de dictionnaire
					print(f"\n3. CLÉ DE DICTIONNAIRE:")
					
					try:
					    dict_avec_set = {set_normal: "valeur"}
					    print(f"   ✅ Set: peut être clé")
					except TypeError:
					    print("   ❌ Set: ne peut pas être clé de dictionnaire")
					
					dict_avec_frozenset = {frozenset_immutable: "Villes impériales"}
					print(f"   ✅ Frozenset: peut être clé → {dict_avec_frozenset}")
					
					# DIFFÉRENCE 4: Méthodes disponibles
					print(f"\n4. MÉTHODES DISPONIBLES:")
					methodes_set = set(dir(set_normal))
					methodes_frozenset = set(dir(frozenset_immutable))
					
					methodes_set_only = methodes_set - methodes_frozenset
					methodes_frozenset_only = methodes_frozenset - methodes_set
					
					print(f"   Méthodes uniquement dans set: {methodes_set_only}")
					print(f"   Méthodes uniquement dans frozenset: {methodes_frozenset_only}")
					
					# DIFFÉRENCE 5: Performance mémoire
					print(f"\n5. PERFORMANCE MÉMOIRE:")
					import sys
					
					grand_set = set(range(1000))
					grand_frozenset = frozenset(range(1000))
					
					print(f"   Taille mémoire set: {sys.getsizeof(grand_set)} octets")
					print(f"   Taille mémoire frozenset: {sys.getsizeof(grand_frozenset)} octets")
					
					# TABLEAU RÉCAPITULATIF DES DIFFÉRENCES
					print(f"\n? TABLEAU RÉCAPITULATIF:")
					print(f"┌{'─'*30}┬{'─'*30}┬{'─'*20}┐")
					print(f"│ CARACTÉRISTIQUE{' '*15}│ SET{' '*27}│ FROZENSET{' '*11}│")
					print(f"├{'─'*30}┼{'─'*30}┼{'─'*20}┤")
					print(f"│ Mutabilité{' '*19}│ ✅ Modifiable{' '*18}│ ❌ Immutable{' '*8}│")
					print(f"│ Hashabilité{' '*18}│ ❌ Non hashable{' '*15}│ ✅ Hashable{' '*10}│")
					print(f"│ Clé de dictionnaire{' '*11}│ ❌ Impossible{' '*17}│ ✅ Possible{' '*10}│")
					print(f"│ Élément d'autre set{' '*11}│ ❌ Impossible{' '*17}│ ✅ Possible{' '*10}│")
					print(f"│ Méthodes de modification{' '*7}│ ✅ add(), remove(), etc.│ ❌ Aucune{' '*11}│")
					print(f"│ Opérations mathématiques{' '*6}│ ✅ Union, intersection │ ✅ Idem que set{' '*6}│")
					print(f"└{'─'*30}┴{'─'*30}┴{'─'*20}┘")
					
					# QUAND UTILISER SET vs FROZENSET ?
					print(f"\n? QUAND UTILISER CHACUN ?")
					print(f"→ SET: Quand vous avez besoin de modifier la collection")
					print(f"→ FROZENSET: Quand vous avez besoin d'immutabilité, de hashabilité,")
					print(f"  ou d'utiliser l'ensemble comme clé ou élément d'autre collection")

Cas d'Usage Pratiques

Les sets ne sont pas seulement une structure théorique - ils résolvent des problèmes concrets de manière élégante et performante. Voyons comment les utiliser dans des situations réelles du développement Python.

Éliminer les doublons d'une liste

L'élimination des doublons est l'utilisation la plus courante des sets. Grâce à leur nature d'ensembles d'éléments uniques, ils offrent une solution simple et efficace pour nettoyer des données.

eliminer_doublons.py
# SCÉNARIO: Liste d'inscriptions avec doublons
					inscriptions_brutes = [
					"Ahmed Alami", "Fatima Zahra", "Karim Bennani", "Ahmed Alami",
					"Leila Alaoui", "Fatima Zahra", "Mehdi Chraibi", "Karim Bennani"
					]
					
					print(f"Liste originale ({len(inscriptions_brutes)} éléments):")
					print(inscriptions_brutes)
					
					# MÉTHODE 1: Conversion directe en set
					inscriptions_uniques = set(inscriptions_brutes)
					print(f"\n✅ Avec set() - {len(inscriptions_uniques)} inscriptions uniques:")
					print(inscriptions_uniques)
					
					# MÉTHODE 2: Conserver l'ordre original avec dict.fromkeys()
					inscriptions_ordonnees = list(dict.fromkeys(inscriptions_brutes))
					print(f"\n✅ Avec dict.fromkeys() - ordre conservé:")
					print(inscriptions_ordonnees)
					
					# SCÉNARIO RÉEL: Nettoyage de données clients
					clients_avec_erreurs = [
					"ahmed alami", "Fatima Zahra", "AHMED ALAMI", "karim bennani",
					"Fatima zahra", "Leila Alaoui", "KARIM BENNANI"
					]
					
					# Nettoyage intelligent avec normalisation
					clients_propres = {nom.strip().title() for nom in clients_avec_erreurs}
					print(f"\n? Clients après nettoyage ({len(clients_propres)} uniques):")
					print(sorted(clients_propres))
					
					# COMPARAISON AVEC MÉTHODE MANUELLE
					print(f"\n? COMPARAISON DES MÉTHODES:")
					
					# Méthode manuelle (moins efficace)
					def supprimer_doublons_manuel(liste):
					    resultat = []
					    for element in liste:
					        if element not in resultat:
					            resultat.append(element)
					    return resultat
					
					# Méthode avec set (plus efficace)
					def supprimer_doublons_set(liste):
					    return list(set(liste))
					
					# Test de performance
					import time
					
					donnees_test = ["user" + str(i % 100) for i in range(1000)]
					
					debut = time.time()
					resultat_manuel = supprimer_doublons_manuel(donnees_test)
					temps_manuel = time.time() - debut
					
					debut = time.time()
					resultat_set = supprimer_doublons_set(donnees_test)
					temps_set = time.time() - debut
					
					print(f"Méthode manuelle: {temps_manuel:.6f} secondes")
					print(f"Méthode avec set: {temps_set:.6f} secondes")
					print(f"Le set est {temps_manuel/temps_set:.1f}x plus rapide!")
					
					# AVANTAGES de la méthode set:
					# - Code concis et lisible
					# - Performance excellente
					# - Gestion automatique des doublons

Trouver les éléments communs entre deux listes

L'intersection de sets est parfaite pour identifier les éléments communs entre différentes collections de données, que ce soit pour de la comparaison, de la validation ou de l'analyse.

elements_communs.py
# SCÉNARIO: Analyse de compétences entre équipes
					competences_equipe_a = [
					"Python", "JavaScript", "SQL", "Docker", "Git"
					]
					
					competences_equipe_b = [
					"JavaScript", "React", "Node.js", "Python", "MongoDB"
					]
					
					print("?️  Analyse des compétences par équipe")
					print(f"Équipe A: {competences_equipe_a}")
					print(f"Équipe B: {competences_equipe_b}")
					
					# Trouver les compétences communes
					competences_communes = set(competences_equipe_a) & set(competences_equipe_b)
					print(f"\n✅ Compétences communes: {competences_communes}")
					
					# SCÉNARIO RÉEL: Gestion de disponibilités
					disponibilites_ahmed = ["lundi", "mercredi", "vendredi", "samedi"]
					disponibilites_fatima = ["mardi", "mercredi", "jeudi", "samedi"]
					disponibilites_karim = ["lundi", "mercredi", "vendredi"]
					
					# Trouver les jours où tout le monde est disponible
					jours_reunion = (
					set(disponibilites_ahmed) & 
					set(disponibilites_fatima) & 
					set(disponibilites_karim)
					)
					
					print(f"\n? Jours de réunion possibles: {sorted(jours_reunion)}")
					
					# SCÉNARIO: Validation de prérequis
					competences_requises = {"Python", "SQL", "Git"}
					candidats = {
					"Ahmed": ["Python", "JavaScript", "HTML"],
					"Fatima": ["Python", "SQL", "Git", "Docker"],
					"Karim": ["Java", "C++", "Python"]
					}
					
					print(f"\n? Analyse des candidats pour poste Python/SQL/Git")
					for candidat, competences in candidats.items():
					    competences_candidat = set(competences)
					    competences_manquantes = competences_requises - competences_candidat
					    
					    if not competences_manquantes:
					        print(f"✅ {candidat}: Toutes les compétences requises")
					    else:
					        print(f"❌ {candidat}: Compétences manquantes - {competences_manquantes}")
					
					# APPLICATION: Recommandation de produits
					produits_client_a = {"huile d'olive", "dattes", "amandes", "miel"}
					produits_client_b = {"dattes", "safran", "thé", "amandes"}
					
					# Produits que les deux clients aiment
					produits_similaires = produits_client_a & produits_client_b
					# Produits que A aime mais pas B (recommandations pour B)
					recommandations_pour_b = produits_client_a - produits_client_b
					
					print(f"\n?️  Analyse de similarité clients:")
					print(f"Produits aimés par les deux: {produits_similaires}")
					print(f"Recommandations pour Client B: {recommandations_pour_b}")
					
					# BÉNÉFICES de l'intersection avec sets:
					# - Code clair et expressif
					# - Performance optimale même avec de grandes collections
					# - Élimination automatique des doublons

Filtrer des données uniques

Au-delà de la simple élimination des doublons, les sets permettent de filtrer intelligemment des données basées sur leur caractère unique ou leur appartenance à des ensembles spécifiques.

filtrer_donnees_uniques.py
# SCÉNARIO: Analyse de mots-clés uniques dans des articles
					articles_maroc = [
					"tajine couscous pastilla marrakech fès",
					"casablanca rabat agadir tanger maroc",
					"tajine safran menthe cuisine marocaine",
					"marrakech souk atlas desert agadir"
					]
					
					# Extraire tous les mots-clés uniques
					tous_mots = set()
					for article in articles_maroc:
					    tous_mots.update(article.split())
					
					print(f"? Mots-clés uniques dans tous les articles ({len(tous_mots)}):")
					print(sorted(tous_mots))
					
					# SCÉNARIO RÉEL: Détection de nouvelles compétences
					competences_connues = {"Python", "SQL", "JavaScript", "Git"}
					competences_cv = ["Python", "Docker", "Kubernetes", "SQL", "React"]
					
					# Identifier les Nouvelles compétences (pas dans les compétences connues)
					nouvelles_competences = set(competences_cv) - competences_connues
					print(f"\n? Nouvelles compétences à apprendre: {nouvelles_competences}")
					
					# SCÉNARIO: Filtrage de produits exclusifs
					produits_boutique_a = {"huile d'olive", "dattes", "amandes", "miel"}
					produits_boutique_b = {"dattes", "safran", "thé", "amandes"}
					produits_boutique_c = {"miel", "figues", "huile d'olive", "thé"}
					
					# Produits EXCLUSIFS à chaque boutique
					exclusifs_a = produits_boutique_a - produits_boutique_b - produits_boutique_c
					exclusifs_b = produits_boutique_b - produits_boutique_a - produits_boutique_c
					exclusifs_c = produits_boutique_c - produits_boutique_a - produits_boutique_b
					
					print(f"\n? Produits exclusifs par boutique:")
					print(f"Boutique A (exclusifs): {exclusifs_a}")
					print(f"Boutique B (exclusifs): {exclusifs_b}")
					print(f"Boutique C (exclusifs): {exclusifs_c}")
					
					# SCÉNARIO AVANCÉ: Filtrage avec conditions multiples
					employes = [
					"Ahmed", "Fatima", "Karim", "Leila", "Mehdi", "Nora"
					]
					
					conges = {"Fatima", "Karim"}
					formation = {"Leila", "Mehdi"}
					projet_urgent = {"Ahmed", "Nora", "Karim"}
					
					# Employés disponibles (ni en congés, ni en formation, ni sur projet urgent)
					indisponibles = conges | formation | projet_urgent
					disponibles = set(employes) - indisponibles
					
					print(f"\n? Analyse des disponibilités:")
					print(f"Employés indisponibles: {indisponibles}")
					print(f"Employés disponibles: {disponibles}")
					
					# TECHNIQUE: Filtrage avec compréhension de set
					noms_complets = ["Ahmed Alami", "Fatima Zahra", "Karim Bennani"]
					
					# Extraire les prénoms uniques
					prenoms_uniques = {nom.split()[0] for nom in noms_complets}
					print(f"\n? Prénoms uniques (avec compréhension): {prenoms_uniques}")
					
					# APPLICATION: Détection de valeurs aberrantes
					temperatures_normales = {18, 19, 20, 21, 22, 23, 24}
					temperatures_mesurees = [19, 20, 35, 21, 22, -5, 23, 24]
					
					# Températures anormales (en dehors de la plage normale)
					temperatures_anormales = set(temperatures_mesurees) - temperatures_normales
					print(f"\n?️  Températures anormales détectées: {temperatures_anormales}")
					
					# AVANTAGES du filtrage avec sets:
					# - Opérations complexes en une ligne
					# - Code déclaratif et facile à comprendre
					# - Performance optimisée pour les grandes collections

Vérifier rapidement la présence d'éléments

La vérification d'appartenance est l'opération la plus rapide avec les sets. Cette caractéristique les rend indispensables pour les recherches fréquentes dans de grandes collections de données.

verifier_presence.py
# SCÉNARIO: Système d'authentification rapide
					utilisateurs_autorises = {
					"admin", "moderateur", "editeur", "contributeur", "lecteur"
					}
					
					print("? Vérification des permissions utilisateur")
					
					def verifier_acces(utilisateur, role_requis):
					    if role_requis in utilisateurs_autorises:
					        return True
					    return False
					
					# Tests rapides
					tests_roles = ["admin", "visiteur", "editeur", "superadmin"]
					
					for role in tests_roles:
					    statut = "✅ ACCÈS AUTORISÉ" if verifier_acces("user123", role) else "❌ ACCÈS REFUSÉ"
					    print(f"{role}: {statut}")
					
					# SCÉNARIO RÉEL: Vérification de mots interdits
					mots_interdits = {
					"spam", "publicité", "arnaque", "gratuit", "urgence",
					"important", "immédiat", "secret", "confidentiel"
					}
					
					messages_a_verifier = [
					"Bonjour, je cherche des informations",
					"URGENCE: offre gratuite immédiate",
					"Réunion importante demain",
					"Ceci est une publicité spam"
					]
					
					print(f"\n? Filtrage anti-spam:")
					for message in messages_a_verifier:
					    mots_message = set(message.lower().split())
					    mots_suspects = mots_message & mots_interdits
					    
					    if mots_suspects:
					        print(f"❌ Message suspect: '{message}' (mots détectés: {mots_suspects})")
					    else:
					        print(f"✅ Message valide: '{message}'")
					
					# DÉMONSTRATION DE PERFORMANCE
					print(f"\n⚡ Comparaison de performance: Set vs Liste")
					
					import time
					
					# Création de grandes collections
					grand_set = set(range(1000000))
					grande_liste = list(range(1000000))
					
					# Recherche dans un set (très rapide - O(1))
					debut = time.time()
					for i in range(1000):
					    999999 in grand_set
					temps_set = time.time() - debut
					
					# Recherche dans une liste (lent - O(n))
					debut = time.time()
					for i in range(1000):
					    999999 in grande_liste
					temps_liste = time.time() - debut
					
					print(f"Set: {temps_set:.6f} secondes pour 1000 recherches")
					print(f"Liste: {temps_liste:.6f} secondes pour 1000 recherches")
					print(f"Le set est {temps_liste/temps_set:.0f}x plus rapide!")
					
					# APPLICATION: Cache de validation
					class ValidateurProduits:
					    def __init__(self):
					        self.produits_valides = set()
					        self.produits_invalides = set()
					    
					    def est_valide(self, produit):
					        # Vérification rapide dans le cache
					        if produit in self.produits_valides:
					            return True
					        if produit in self.produits_invalides:
					            return False
					        
					        # Simulation de validation coûteuse
					        est_valide = len(produit) > 3  # Règle métier simplifiée
					        
					        if est_valide:
					            self.produits_valides.add(produit)
					        else:
					            self.produits_invalides.add(produit)
					        
					        return est_valide
					
					validateur = ValidateurProduits()
					produits_test = ["dattes", "thé", "huile d'olive", "oi", "dattes"]
					
					print(f"\n? Validation de produits avec cache:")
					for produit in produits_test:
					    statut = "✅ VALIDE" if validateur.est_valide(produit) else "❌ INVALIDE"
					    print(f"{produit}: {statut}")
					
					print(f"Cache valides: {validateur.produits_valides}")
					print(f"Cache invalides: {validateur.produits_invalides}")
					
					# CAS D'USAGE IDÉAL POUR LES SETS:
					# - Listes noires/blanches
					# - Systèmes de cache
					# - Vérifications d'autorisation
					# - Filtrage en temps réel
					# - Détection de doublons

Performance et Optimisation

Comprendre les performances des sets est crucial pour faire les bons choix d'implémentation. Les sets excellent dans certaines opérations mais peuvent être contre-performants dans d'autres contextes. Analysons en détail leurs caractéristiques de performance.

Complexité temporelle des opérations

La complexité temporelle mesure comment le temps d'exécution d'une opération évolue avec la taille des données. Les sets utilisent des tables de hachage, ce qui leur confère des performances exceptionnelles pour certaines opérations.

complexite_temporelle.py
# TABLEAU DES COMPLEXITÉS TEMPORELLES DES SETS
					print("? COMPLEXITÉ TEMPORELLE DES OPÉRATIONS SUR LES SETS")
					print("=" * 60)
					
					# O(1) - Temps constant (excellent)
					print("\n? OPÉRATIONS O(1) - TEMPS CONSTANT:")
					
					villes_maroc = {"Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"}
					
					# Test d'appartenance - O(1)
					print(f"  'Casablanca' in villes_maroc: {"Casablanca" in villes_maroc}")
					print(f"  'Agadir' in villes_maroc: {"Agadir" in villes_maroc}")
					
					# Ajout d'élément - O(1)
					villes_maroc.add("Agadir")
					print(f"  add('Agadir'): {villes_maroc}")
					
					# Suppression - O(1)
					villes_maroc.discard("Tanger")
					print(f"  discard('Tanger'): {villes_maroc}")
					
					# O(k) - Linéaire par rapport à la taille de l'autre set
					print(f"\n? OPÉRATIONS O(k) - LINÉAIRE:")
					
					villes_nord = {"Tanger", "Tetouan", "Chefchaouen"}
					villes_sud = {"Agadir", "Marrakech", "Ouarzazate"}
					
					# Union - O(len(s) + len(t))
					union_villes = villes_maroc | villes_nord
					print(f"  Union: {len(union_villes)} villes")
					
					# Intersection - O(min(len(s), len(t)))
					intersection_villes = villes_maroc & {"Marrakech", "Fès"}
					print(f"  Intersection: {intersection_villes}")
					
					# DÉMONSTRATION PRATIQUE DES COMPLEXITÉS
					print(f"\n? DÉMONSTRATION DES COMPLEXITÉS:")
					
					import time
					import random
					
					def mesurer_performance(operation, description, taille=100000):
					    # Création d'un grand set
					    grand_set = set(range(taille))
					    
					    debut = time.time()
					    operation(grand_set)
					    temps = time.time() - debut
					    
					    print(f"  {description}: {temps:.6f} secondes")
					    return temps
					
					# Test O(1) - Recherche
					mesurer_performance(lambda s: 99999 in s, "Recherche O(1)")
					
					# Test O(1) - Ajout
					mesurer_performance(lambda s: s.add(100000), "Ajout O(1)")
					
					# Test O(n) - Création depuis liste
					mesurer_performance(lambda s: set(s), "Création O(n)")
					
					# TABLEAU RÉCAPITULATIF DES COMPLEXITÉS
					print(f"\n? TABLEAU RÉCAPITULATIF DES COMPLEXITÉS:")
					print("┌─────────────────────────────┬─────────────────┬─────────────────────────┐")
					print("│ Opération                   │ Complexité      │ Description             │")
					print("├─────────────────────────────┼─────────────────┼─────────────────────────┤")
					print("│ x in s                      │ O(1)            │ Test d'appartenance     │")
					print("│ s.add(x)                    │ O(1)            │ Ajout d'élément         │")
					print("│ s.remove(x) / discard(x)    │ O(1)            │ Suppression             │")
					print("│ s.pop()                     │ O(1)            │ Suppression aléatoire   │")
					print("│ s.copy()                    │ O(n)            │ Copie                   │")
					print("│ len(s)                      │ O(1)            │ Taille                  │")
					print("│ s | t (union)               │ O(len(s)+len(t))│ Union                   │")
					print("│ s & t (intersection)        │ O(min(s,t))     │ Intersection            │")
					print("│ s - t (différence)          │ O(len(s))       │ Différence              │")
					print("│ s <= t (sous-ensemble)      │ O(len(s))       │ Test sous-ensemble      │")
					print("│ for x in s (itération)      │ O(n)            │ Parcours                │")
					print("└─────────────────────────────┴─────────────────┴─────────────────────────┘")
					
					# FACTEURS INFLUENÇANT LA PERFORMANCE
					print(f"\n⚡ FACTEURS INFLUENÇANT LA PERFORMANCE:")
					print("• Taux de collision: Moins de collisions = meilleures performances")
					print("• Fonction de hachage: Doit bien répartir les éléments")
					print("• Taille du set: Les opérations O(1) restent constantes")
					print("• Qualité des hash: Éléments avec hash de bonne qualité")

Sets vs Listes : comparaison de performance

Le choix entre sets et listes dépend fortement des opérations que vous effectuez. Voyons des comparaisons concrètes pour guider vos décisions d'optimisation.

sets_vs_listes.py
# COMPARAISON COMPLÈTE SETS vs LISTES
					print("⚖️  COMPARAISON DE PERFORMANCE: SETS vs LISTES")
					print("=" * 60)
					
					import time
					import random
					import sys
					
					def comparer_performance(test_name, operation_set, operation_list, setup, iterations=1000):
					    # Préparation des données
					    data_set, data_list = setup()
					    
					    # Test avec set
					    debut = time.time()
					    for _ in range(iterations):
					        operation_set(data_set)
					    temps_set = time.time() - debut
					    
					    # Test avec liste
					    debut = time.time()
					    for _ in range(iterations):
					        operation_list(data_list)
					    temps_liste = time.time() - debut
					    
					    ratio = temps_liste / temps_set if temps_set > 0 else float('inf')
					    
					    print(f"  {test_name:25} | Set: {temps_set:7.4f}s | Liste: {temps_liste:7.4f}s | Ratio: {ratio:6.1f}x")
					    
					    return ratio
					
					# SCÉNARIO 1: Recherche d'éléments
					print(f"\n? SCÉNARIO 1 - RECHERCHE D'ÉLÉMENTS (1000 itérations):")
					
					taille_donnees = 10000
					setup_recherche = lambda: (
					    set(range(taille_donnees)),
					    list(range(taille_donnees))
					)
					
					# Recherche au début
					comparer_performance(
					    "Recherche début",
					    lambda s: 0 in s,
					    lambda l: 0 in l,
					    setup_recherche
					)
					
					# Recherche au milieu
					comparer_performance(
					    "Recherche milieu",
					    lambda s: taille_donnees//2 in s,
					    lambda l: taille_donnees//2 in l,
					    setup_recherche
					)
					
					# Recherche à la fin
					comparer_performance(
					    "Recherche fin",
					    lambda s: taille_donnees-1 in s,
					    lambda l: taille_donnees-1 in l,
					    setup_recherche
					)
					
					# Recherche d'élément absent
					comparer_performance(
					    "Recherche absent",
					    lambda s: -1 in s,
					    lambda l: -1 in l,
					    setup_recherche
					)
					
					# SCÉNARIO 2: Ajout d'éléments
					print(f"\n➕ SCÉNARIO 2 - AJOUT D'ÉLÉMENTS (1000 itérations):")
					
					setup_ajout = lambda: (set(), [])
					
					comparer_performance(
					    "Ajout simple",
					    lambda s: s.add(1),
					    lambda l: l.append(1),
					    setup_ajout
					)
					
					# SCÉNARIO 3: Élimination des doublons
					print(f"\n? SCÉNARIO 3 - ÉLIMINATION DES DOUBLONS:")
					
					donnees_avec_doublons = [random.randint(0, 1000) for _ in range(10000)]
					
					debut = time.time()
					set_unique = set(donnees_avec_doublons)
					temps_set = time.time() - debut
					
					debut = time.time()
					liste_unique = []
					for element in donnees_avec_doublons:
					    if element not in liste_unique:
					        liste_unique.append(element)
					temps_liste = time.time() - debut
					
					print(f"  Set:  {temps_set:.4f}s - {len(set_unique)} éléments uniques")
					print(f"  Liste: {temps_liste:.4f}s - {len(liste_unique)} éléments uniques")
					print(f"  Ratio: {temps_liste/temps_set:.1f}x plus rapide avec set!")
					
					# SCÉNARIO 4: Utilisation mémoire
					print(f"\n? SCÉNARIO 4 - UTILISATION MÉMOIRE:")
					
					taille_test = 100000
					grand_set = set(range(taille_test))
					grande_liste = list(range(taille_test))
					
					memoire_set = sys.getsizeof(grand_set)
					memoire_liste = sys.getsizeof(grande_liste)
					
					print(f"  Set:  {memoire_set:,} octets")
					print(f"  Liste: {memoire_liste:,} octets")
					print(f"  Le set utilise {memoire_set/memoire_liste:.1f}x plus de mémoire")
					
					# SCÉNARIO RÉEL: Gestion de cache utilisateur
					print(f"\n? SCÉNARIO RÉEL - CACHE UTILISATEURS CONNECTÉS:")
					
					class CacheUtilisateursSet:
					    def __init__(self):
					        self.utilisateurs = set()
					    
					    def ajouter(self, user_id):
					        self.utilisateurs.add(user_id)
					    
					    def est_connecte(self, user_id):
					        return user_id in self.utilisateurs
					    
					    def supprimer(self, user_id):
					        self.utilisateurs.discard(user_id)
					
					class CacheUtilisateursListe:
					    def __init__(self):
					        self.utilisateurs = []
					    
					    def ajouter(self, user_id):
					        if user_id not in self.utilisateurs:
					            self.utilisateurs.append(user_id)
					    
					    def est_connecte(self, user_id):
					        return user_id in self.utilisateurs
					    
					    def supprimer(self, user_id):
					        if user_id in self.utilisateurs:
					            self.utilisateurs.remove(user_id)
					
					# Test de performance
					cache_set = CacheUtilisateursSet()
					cache_liste = CacheUtilisateursListe()
					
					nombre_utilisateurs = 10000
					utilisateurs_test = [f"user_{i}" for i in range(nombre_utilisateurs)]
					
					# Test d'ajout
					debut = time.time()
					for user in utilisateurs_test:
					    cache_set.ajouter(user)
					temps_ajout_set = time.time() - debut
					
					debut = time.time()
					for user in utilisateurs_test:
					    cache_liste.ajouter(user)
					temps_ajout_liste = time.time() - debut
					
					print(f"  Ajout {nombre_utilisateurs} utilisateurs:")
					print(f"    Set:  {temps_ajout_set:.4f}s")
					print(f"    Liste: {temps_ajout_liste:.4f}s")
					print(f"    Set {temps_ajout_liste/temps_ajout_set:.1f}x plus rapide")

Quand éviter les sets ?

Malgré leurs excellentes performances pour certaines opérations, les sets ne sont pas toujours la meilleure solution. Identifions les situations où d'autres structures de données sont plus appropriées.

quand_eviter_sets.py
# CAS 1: Quand l'ordre des éléments est important
					print("? QUAND ÉVITER LES SETS ?")
					print("=" * 50)
					
					print(f"\n1. ? QUAND L'ORDRE EST IMPORTANT:")
					
					# Scénario: Historique de navigation
					pages_visitees_set = {"accueil", "produits", "contact", "apropos"}
					pages_visitees_liste = ["accueil", "produits", "contact", "apropos"]
					
					print(f"  Set (ordre perdu): {pages_visitees_set}")
					print(f"  Liste (ordre conservé): {pages_visitees_liste}")
					print(f"  → Utiliser une liste ou collections.OrderedDict")
					
					# CAS 2: Quand vous avez besoin d'éléments dupliqués
					print(f"\n2. ? QUAND LES DOUBLONS SONT NÉCESSAIRES:")
					
					# Scénario: Journal des transactions
					transactions = ["dépôt", "retrait", "dépôt", "retrait", "dépôt"]
					
					print(f"  Transactions originales: {transactions}")
					print(f"  Avec set (doublons perdus): {set(transactions)}")
					print(f"  → Utiliser une liste pour conserver toutes les occurrences")
					
					# CAS 3: Quand vous avez besoin d'accéder aux éléments par index
					print(f"\n3. ? QUAND L'ACCÈS PAR INDEX EST NÉCESSAIRE:")
					
					classement_ville = ["Casablanca", "Rabat", "Marrakech", "Fès"]
					villes_set = {"Casablanca", "Rabat", "Marrakech", "Fès"}
					
					print(f"  Liste - 2ème ville: {classement_ville[1]}")
					print(f"  Set - Impossible d'accéder par index")
					print(f"  → Utiliser une liste pour l'accès positionnel")
					
					# CAS 4: Quand vous avez des éléments non-hashables
					print(f"\n4. ? QUAND LES ÉLÉMENTS SONT NON-HASHABLES:")
					
					# Scénario: Collection de listes
					listes_produits = [
					    ["huile", "dattes"],
					    ["thé", "safran"],
					    ["huile", "dattes"]  # Doublon
					]
					
					try:
					    set_listes = set(listes_produits)
					    print(f"  Set de listes: {set_listes}")
					except TypeError as e:
					    print(f"  ❌ Erreur: {e}")
					    print(f"  → Utiliser des tuples ou frozensets pour les éléments mutables")
					
					# Solution: Utiliser des tuples
					tuples_produits = {tuple(liste) for liste in listes_produits}
					print(f"  Solution avec tuples: {tuples_produits}")
					
					# CAS 5: Quand la mémoire est critique
					print(f"\n5. ? QUAND LA MÉMOIRE EST CRITIQUE:")
					
					import sys
					
					donnees = [1, 2, 3, 4, 5]
					liste_memoire = sys.getsizeof(donnees)
					set_memoire = sys.getsizeof(set(donnees))
					
					print(f"  Liste: {liste_memoire} octets")
					print(f"  Set:   {set_memoire} octets")
					print(f"  → Les sets utilisent plus de mémoire que les listes")
					print(f"  → Privilégier les listes pour de petites collections")
					
					# CAS 6: Quand vous avez besoin de slices
					print(f"\n6. ✂️  QUAND VOUS AVEZ BESOIN DE SLICES:")
					
					donnees_ordonnees = ["janvier", "février", "mars", "avril", "mai"]
					donnees_set = {"janvier", "février", "mars", "avril", "mai"}
					
					print(f"  Liste - 3 premiers mois: {donnees_ordonnees[:3]}")
					print(f"  Set - Slicing impossible")
					print(f"  → Utiliser des listes pour les opérations de slicing")
					
					# CAS 7: Quand vous avez besoin de trier fréquemment
					print(f"\n7. ? QUAND LE TRI EST FRÉQUENT:")
					
					villes = {"Casablanca", "Rabat", "Marrakech", "Fès"}
					
					print(f"  Set original: {villes}")
					print(f"  Set trié (nouvelle liste): {sorted(villes)}")
					print(f"  → Le tri crée une nouvelle liste, pas un set")
					print(f"  → Utiliser une liste si vous avez besoin de trier souvent")
					
					# TABLEAU DE DÉCISION
					print(f"\n? TABLEAU DE DÉCISION - SET vs LISTE:")
					print("┌─────────────────────────────┬───────────────┬───────────────┐")
					print("│ Critère                     │ SET           │ LISTE         │")
					print("├─────────────────────────────┼───────────────┼───────────────┤")
					print("│ Test d'appartenance         │ ✅ EXCELLENT  │ ❌ LENT       │")
					print("│ Élimination des doublons    │ ✅ AUTOMATIQUE│ ❌ MANUEL     │")
					print("│ Conservation de l'ordre     │ ❌ NON        │ ✅ OUI        │")
					print("│ Accès par index             │ ❌ NON        │ ✅ OUI        │")
					print("│ Éléments dupliqués          │ ❌ NON        │ ✅ OUI        │")
					print("│ Slicing                     │ ❌ NON        │ ✅ OUI        │")
					print("│ Tri natif                   │ ❌ NON        │ ✅ OUI        │")
					print("│ Utilisation mémoire         │ ❌ ÉLEVÉE     │ ✅ FAIBLE     │")
					print("│ Opérations mathématiques    │ ✅ EXCELLENTES│ ❌ LIMITÉES   │")
					print("└─────────────────────────────┴───────────────┴───────────────┘")
					
					# RECOMMANDATIONS FINALES
					print(f"\n? RECOMMANDATIONS FINALES:")
					print("• ✅ UTILISEZ LES SETS pour: tests d'appartenance, élimination de doublons,")
					print("  opérations mathématiques sur ensembles, caches de recherche")
					print("• ❌ ÉVITEZ LES SETS pour: données ordonnées, accès par index, slicing,")
					print("  quand la mémoire est critique, quand les doublons sont nécessaires")

Pièges et Erreurs Courantes

Les sets en Python sont puissants mais présentent quelques particularités qui peuvent surprendre les développeurs, surtout ceux venant d'autres langages de programmation. Comprendre ces pièges vous évitera des erreurs courantes.

Sets ne conservent pas l'ordre (avant Python 3.7)

Contrairement aux listes et aux tuples, les sets ne garantissaient pas la conservation de l'ordre des éléments avant Python 3.7. Bien que cela ait changé dans les versions récentes, il est important de comprendre cette limitation historique.

ordre_sets.py
# Attention : l'ordre n'est pas garanti dans les anciennes versions
					# Création d'un set avec des villes marocaines
					villes_maroc = {"Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"}
					
					# Affichage - l'ordre peut varier selon l'implémentation Python
					print("Villes du Maroc (set):")
					for ville in villes_maroc:
					    print(f"- {ville}")
					
					# Comparaison avec une liste (ordre préservé)
					villes_liste = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]
					print("\nVilles du Maroc (liste):")
					for ville in villes_liste:
					    print(f"- {ville}")
					
					# Conséquence : impossible d'accéder par index
					try:
					    premiere_ville = villes_maroc[0]  # Erreur !
					except TypeError as e:
					    print(f"\nErreur: {e}")
					    print("Les sets ne supportent pas l'indexation !")
					
					# Solution : convertir en liste si l'ordre est important
					villes_ordonnees = sorted(villes_maroc)  # Tri alphabétique
					print(f"\nVilles triées: {villes_ordonnees}")

Impossibilité de stocker des éléments mutables

Les sets ne peuvent contenir que des éléments hashables (immuables). Les listes, dictionnaires et autres objets mutables ne peuvent pas être stockés dans un set.

elements_mutables.py
# Exemple d'erreur avec des éléments mutables
					# Tentative de créer un set avec des listes (mutables)
					try:
					    regions_maroc = {
					        ["Casablanca", "Mohammedia"],  # Liste - MUTABLE
					        ["Rabat", "Salé"],
					        ["Marrakech", "Safi"]
					    }
					except TypeError as e:
					    print(f"Erreur: {e}")
					    print("Impossible de créer un set avec des listes !")
					
					# Solution : utiliser des tuples (immuables)
					regions_maroc = {
					    ("Casablanca", "Mohammedia"),  # Tuple - IMMUTABLE
					    ("Rabat", "Salé"),
					    ("Marrakech", "Safi")
					}
					print(f"\nRégions du Maroc (avec tuples): {regions_maroc}")
					
					# Autre exemple avec des dictionnaires
					try:
					    villes_dict = {
					        {"nom": "Casablanca", "population": 3500000},  # Dict - MUTABLE
					        {"nom": "Rabat", "population": 2000000}
					    }
					except TypeError as e:
					    print(f"\nErreur avec dictionnaires: {e}")
					
					# Solution alternative : utiliser frozenset pour les ensembles d'ensembles
					specialites_culinaires = {
					    frozenset(["Tajine", "Couscous"]),
					    frozenset(["Pastilla", "Harira"])
					}
					print(f"\nSpécialités culinaires (avec frozenset): {specialites_culinaires}")

Confusion entre {} et set()

Une erreur courante est de confondre la syntaxe des sets avec celle des dictionnaires, car les deux utilisent les accolades {}. Cette confusion peut mener à des bugs subtils.

confusion_syntaxe.py
# Piège : les accolades vides créent un dictionnaire, pas un set !
					collection_vide = {}
					print(f"Type de {{}}: {type(collection_vide)}")  # dict, pas set !
					
					# Pour créer un set vide, il faut utiliser set()
					set_vide = set()
					print(f"Type de set(): {type(set_vide)}")  # set
					
					# Exemple pratique avec des données marocaines
					# Création d'un set de plats marocains
					plats_marocains = {"Tajine", "Couscous", "Pastilla", "Harira"}
					print(f"\nSet de plats: {plats_marocains}")
					print(f"Type: {type(plats_marocains)}")
					
					# Création d'un dictionnaire de plats avec leurs régions
					plats_regions = {
					    "Tajine": "Tout le Maroc",
					    "Couscous": "Fès",
					    "Pastilla": "Fès",
					    "Harira": "Rabat"
					}
					print(f"\nDict plats-régions: {plats_regions}")
					print(f"Type: {type(plats_regions)}")
					
					# Conséquence de la confusion
					def ajouter_plat(collection, plat):
					    # Cette fonction peut avoir un comportement différent selon le type
					    collection.add(plat)  # Fonctionne pour les sets
					
					# Test avec un set (fonctionne)
					mes_plats = {"Tajine", "Couscous"}
					ajouter_plat(mes_plats, "Pastilla")
					print(f"\nAprès ajout (set): {mes_plats}")
					
					# Test avec un dict (erreur)
					mes_plats_dict = {"Tajine": "délicieux", "Couscous": "excellent"}
					try:
					    ajouter_plat(mes_plats_dict, "Pastilla")  # Erreur AttributeError
					except AttributeError as e:
					    print(f"Erreur avec dict: {e}")
					    print("Les dictionnaires n'ont pas de méthode add() !")
					
					# Bonne pratique : toujours vérifier le type si nécessaire
					def ajouter_plat_securise(collection, plat):
					    if isinstance(collection, set):
					        collection.add(plat)
					    elif isinstance(collection, dict):
					        collection[plat] = "à évaluer"  # Comportement adapté pour les dicts
					    else:
					        print(f"Type non supporté: {type(collection)}")
					
					# Test de la fonction sécurisée
					ajouter_plat_securise(mes_plats, "Harira")
					ajouter_plat_securise(mes_plats_dict, "Harira")
					print(f"\nSet après ajout sécurisé: {mes_plats}")
					print(f"Dict après ajout sécurisé: {mes_plats_dict}")

Exercices Pratiques

Ces exercices vous permettront de mettre en pratique les concepts des sets Python dans des situations réelles. Chaque exercice aborde un cas d'usage différent avec des données marocaines.

Exercice 1 : Gestion de listes de participants

Vous gérez les inscriptions à des événements culturels marocains. Utilisez les sets pour gérer efficacement les listes de participants, détecter les doublons et analyser les chevauchements entre événements.

exercice_participants.py
# Données initiales
					participants_festival = {
					    "Ahmed Alami", "Fatima Zahra", "Mehdi Benjelloun", 
					    "Karim Bouzidi", "Samira El Mansouri", "Youssef Alaoui"
					}
					
					participants_conference = {
					    "Mehdi Benjelloun", "Nadia Tazi", "Karim Bouzidi", 
					    "Leila Berrada", "Hassan Chraibi"
					}
					
					# QUESTION 1: Trouver les participants communs aux deux événements
					participants_communs = participants_festival & participants_conference
					print("Participants communs:", participants_communs)
					
					# QUESTION 2: Nouvelle liste d'inscriptions avec des doublons
					nouvelles_inscriptions = [
					    "Amine Kabbaj", "Samira El Mansouri", "Rachida Idrissi",
					    "Amine Kabbaj", "Youssef Alaoui", "Leila Berrada"
					]
					
					# Éliminer les doublons et ajouter au festival
					participants_festival.update(set(nouvelles_inscriptions))
					print("Participants festival après nouvelles inscriptions:", participants_festival)
					
					# QUESTION 3: Participants uniques à chaque événement
					uniques_festival = participants_festival - participants_conference
					uniques_conference = participants_conference - participants_festival
					print("Uniques au festival:", uniques_festival)
					print("Uniques à la conférence:", uniques_conference)
					
					# QUESTION 4: Vérifier si des participants spécifiques sont inscrits
					cherche_participants = {"Ahmed Alami", "Nadia Tazi", "Mohamed Essafi"}
					trouves = participants_festival | participants_conference
					resultats_recherche = cherche_participants & trouves
					print("Participants trouvés:", resultats_recherche)
					
					# SOLUTION COMPLÈTE AVEC FONCTIONS
					def gerer_evenements_maroc():
					    # Initialisation des sets
					    festival = {"Ahmed Alami", "Fatima Zahra", "Mehdi Benjelloun"}
					    conference = {"Mehdi Benjelloun", "Nadia Tazi", "Karim Bouzidi"}
					    
					    print("=== GESTION DES ÉVÉNEMENTS MAROCAINS ===\n")
					    
					    # Participants uniques par événement
					    print("Participants uniques au festival:", festival - conference)
					    print("Participants uniques à la conférence:", conference - festival)
					    
					    # Total des participants uniques
					    total_uniques = festival | conference
					    print(f"Total participants uniques: {len(total_uniques)}")
					    
					    # Participants fréquents
					    frequents = festival & conference
					    print(f"Participants aux deux événements: {frequents}")
					    
					    # Vérification d'inscription
					    if "Nadia Tazi" in conference:
					        print("Nadia Tazi est inscrite à la conférence")
					
					# Exécution
					gerer_evenements_maroc()

Exercice 2 : Analyse de données textuelles

Analysez des textes en arabe marocain (darija) et français pour extraire le vocabulaire unique, trouver les mots communs et calculer la diversité lexicale.

exercice_analyse_textuelle.py
# Textes en darija marocain et français
					texte_darija = """
					salam alikom kayn bzaf dyal nass f casa daba casa hiya mdina kbira w jmila
					f casa kayn bzaf dyal lmaqulat tradionnelles zwina bla bla casa hiya lqalb
					dyal lmaghrib kollachi casa daba hiya mdina jmila bzaf
					""".lower()
					
					texte_francais = """
					casablanca est une ville magnifique et moderne du maroc la ville blanche
					est connue pour son architecture son histoire et sa culture riche casablanca
					est le coeur économique du maroc avec de nombreuses entreprises et industries
					""".lower()
					
					# QUESTION 1: Extraire les mots uniques de chaque texte
					mots_darija = set(texte_darija.split())
					mots_francais = set(texte_francais.split())
					
					print(f"Vocabulaire darija unique: {len(mots_darija)} mots")
					print(f"Vocabulaire français unique: {len(mots_francais)} mots")
					
					# QUESTION 2: Trouver les mots communs aux deux textes
					mots_communs = mots_darija & mots_francais
					print(f"Mots communs: {mots_communs}")
					
					# QUESTION 3: Mots spécifiques à chaque langue
					specifiques_darija = mots_darija - mots_francais
					specifiques_francais = mots_francais - mots_darija
					
					print(f"Mots spécifiques darija: {specifiques_darija}")
					print(f"Mots spécifiques français: {specifiques_francais}")
					
					# QUESTION 4: Analyser la fréquence des mots "casa" et "casablanca"
					mots_cles = {"casa", "casablanca"}
					presence_darija = mots_cles & mots_darija
					presence_francais = mots_cles & mots_francais
					
					print(f"Présence dans darija: {presence_darija}")
					print(f"Présence dans français: {presence_francais}")
					
					# SOLUTION AVANCÉE AVEC FONCTIONS
					def analyser_textes_maroc(texte1, texte2):
					    # Nettoyage et tokenisation
					    mots_texte1 = set(texte1.lower().replace('.', '').replace(',', '').split())
					    mots_texte2 = set(texte2.lower().replace('.', '').replace(',', '').split())
					    
					    print("=== ANALYSE COMPARATIVE DE TEXTES ===\n")
					    
					    # Statistiques de base
					    print(f"Texte 1 - Vocabulaire unique: {len(mots_texte1)} mots")
					    print(f"Texte 2 - Vocabulaire unique: {len(mots_texte2)} mots")
					    
					    # Similarité lexicale
					    communs = mots_texte1 & mots_texte2
					    similarite = len(communs) / len(mots_texte1 | mots_texte2) * 100
					    print(f"Similarité lexicale: {similarite:.1f}%")
					    
					    # Mots exclusifs
					    exclusifs_texte1 = mots_texte1 - mots_texte2
					    exclusifs_texte2 = mots_texte2 - mots_texte1
					    
					    print(f"\nMots exclusifs au texte 1 ({len(exclusifs_texte1)}):")
					    print(sorted(exclusifs_texte1))
					    
					    return {
					        'similarite': similarite,
					        'communs': communs,
					        'exclusifs_texte1': exclusifs_texte1,
					        'exclusifs_texte2': exclusifs_texte2
					    }
					
					# Test avec des textes marocains
					texte1 = "Marrakech la ville ocre est belle et touristique"
					texte2 = "Marrakech est une ville touristique du Maroc"
					resultats = analyser_textes_maroc(texte1, texte2)

Exercice 3 : Opérations sur des ensembles de nombres

Utilisez les opérations mathématiques des sets pour analyser des données numériques liées au développement économique du Maroc, aux codes postaux et aux indicateurs statistiques.

exercice_ensembles_nombres.py
# Données : Codes postaux et indicateurs économiques
					codes_casablanca = {20000, 20200, 20300, 20400, 20500}
					codes_rabat = {10000, 10100, 10200, 10300}
					codes_marrakech = {40000, 40100, 40200, 20300}  # Note: 20300 en commun
					
					# QUESTION 1: Union de tous les codes postaux
					tous_codes = codes_casablanca | codes_rabat | codes_marrakech
					print("Tous les codes postaux:", sorted(tous_codes))
					
					# QUESTION 2: Intersections entre villes
					communs_casa_marrakech = codes_casablanca & codes_marrakech
					print("Codes communs Casa-Marrakech:", communs_casa_marrakech)
					
					# QUESTION 3: Différences symétriques
					diff_sym_casa_rabat = codes_casablanca ^ codes_rabat
					print("Différence symétrique Casa-Rabat:", sorted(diff_sym_casa_rabat))
					
					# Données économiques
					pib_regions_2020 = {120, 85, 45, 78, 92}  # en milliards DH
					pib_regions_2021 = {125, 88, 48, 82, 95}
					pib_regions_2022 = {130, 90, 50, 85, 98}
					
					# QUESTION 4: Croissance constante (présent dans les 3 années)
					croissance_constante = pib_regions_2020 & pib_regions_2021 & pib_regions_2022
					print("Valeurs de PIB présentes sur 3 ans:", croissance_constante)
					
					# QUESTION 5: Nouvelles valeurs apparues en 2022
					nouvelles_2022 = pib_regions_2022 - (pib_regions_2020 | pib_regions_2021)
					print("Nouvelles valeurs en 2022:", nouvelles_2022)
					
					# SOLUTION COMPLÈTE AVEC FONCTIONS
					def analyser_donnees_maroc():
					    # Ensembles de données économiques
					    investissements_publics = {15, 22, 18, 30, 25}  # milliards DH
					    investissements_prives = {20, 25, 15, 35, 28}
					    zones_industrielles = {15, 30, 40, 25, 50}
					    
					    print("=== ANALYSE DES INVESTISSEMENTS AU MAROC ===\n")
					    
					    # Investissements dans les deux secteurs
					    public_et_prive = investissements_publics & investissements_prives
					    print(f"Montants investis dans public et privé: {public_et_prive}")
					    
					    # Investissements uniquement publics
					    seulement_public = investissements_publics - investissements_prives
					    print(f"Investissements uniquement publics: {seulement_public}")
					    
					    # Zones avec investissements mais sans zones industrielles
					    investis_sans_zones = (investissements_publics | investissements_prives) - zones_industrielles
					    print(f"Zones investies sans zones industrielles: {investis_sans_zones}")
					    
					    # Tous les montants d'investissement uniques
					    tous_investissements = investissements_publics | investissements_prives | zones_industrielles
					    print(f"Tous les montants d'investissement: {sorted(tous_investissements)}")
					    
					    # Vérification de sous-ensembles
					    if investissements_publics.issubset(investissements_prives):
					        print("Tous les investissements publics sont aussi privés")
					    else:
					        print("Il y a des investissements publics spécifiques")
					
					# Application à des données réelles
					def analyser_croissance():
					    # Données de croissance régionale
					    regions_croissance_2021 = {"Casablanca", "Rabat", "Tanger", "Marrakech"}
					    regions_croissance_2022 = {"Casablanca", "Tanger", "Agadir", "Fès"}
					    
					    # Régions avec croissance continue
					    croissance_continue = regions_croissance_2021 & regions_croissance_2022
					    print(f"Régions avec croissance continue: {croissance_continue}")
					    
					    # Nouvelles régions en croissance
					    nouvelles_regions = regions_croissance_2022 - regions_croissance_2021
					    print(f"Nouvelles régions en croissance: {nouvelles_regions}")
					
					# Exécution des analyses
					analyser_donnees_maroc()
					print("\n" + "="*50)
					analyser_croissance()
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!