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.
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.
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.
# 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}")
Les sets possèdent plusieurs propriétés distinctives qui les rendent uniques parmi les structures de données Python :
# 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}")
Le choix entre set, liste et tuple dépend du contexte d'utilisation et des opérations que vous souhaitez effectuer :
# 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
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.
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.
# 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}")
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.
# 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)}")
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 {}.
# 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)
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 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}")
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.
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.
# 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}")
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.
# 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
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.
# 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!")
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.
# 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}")
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.
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().
# 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}")
L'intersection retourne les éléments communs à tous les sets. Utilisez l'opérateur & ou la méthode intersection().
# 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}")
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().
# 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}")
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().
# 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}")
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.
# 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)}")
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 "_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.
# 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
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.
# 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)}")
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.
# 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
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.
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.
# 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
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.
# 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]}")
Bien que similaires dans leur structure, les sets et frozensets présentent des différences cruciales qui déterminent leurs cas d'usage respectifs.
# 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")
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.
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.
# 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
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.
# 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
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.
# 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
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.
# 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
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.
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.
# 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é")
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.
# 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")
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.
# 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")
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.
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.
# 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}")
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.
# 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}")
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.
# 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}")
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.
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.
# 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()
Analysez des textes en arabe marocain (darija) et français pour extraire le vocabulaire unique, trouver les mots communs et calculer la diversité lexicale.
# 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)
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.
# 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()
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!