Ce tutoriel vous guide dans la compréhension et l'utilisation des dictionnaires Python, une structure de données clé-valeur puissante et flexible. Vous apprendrez à créer, manipuler et optimiser vos dictionnaires, découvrirez les méthodes essentielles (.get(), .update(), .items()...) et explorerez des cas d'usage pratiques pour stocker et organiser efficacement vos données dans vos projets Python.
Les dictionnaires sont une structure de données fondamentale en Python qui permettent de stocker des données sous forme de paires clé-valeur. Ils sont extrêmement flexibles et optimisés pour les recherches rapides.
Un dictionnaire Python est une collection non ordonnée (avant Python 3.7) d'éléments accessibles par une clé unique. Chaque élément est constitué d'une paire clé-valeur, où la clé sert d'index pour accéder à la valeur correspondante.
# Création d'un dictionnaire simple # Structure: {clé1: valeur1, clé2: valeur2, ...} villes_maroc = { "Casablanca": "Grande métropole économique", "Rabat": "Capitale administrative", "Marrakech": "Cité impériale touristique", "Fès": "Ville historique et culturelle" } # Accès aux valeurs par clé print("Description de Casablanca:", villes_maroc["Casablanca"]) print("Description de Rabat:", villes_maroc.get("Rabat")) # Caractéristiques importantes des dictionnaires : # - Les clés doivent être uniques et immuables (strings, nombres, tuples) # - Les valeurs peuvent être de n'importe quel type # - Pas d'ordre garanti avant Python 3.7 # Exemple avec différents types de clés regions_maroc = { "Tanger-Tétouan-Al Hoceïma": 3.5, # Population en millions 1: "Region de l'Oriental", (32, -6): "Coordonnées de Marrakech" } print(f"Population de Tanger: {regions_maroc['Tanger-Tétouan-Al Hoceïma']} millions") print(f"Region 1: {regions_maroc[1]}")
Les dictionnaires offrent plusieurs avantages qui les rendent indispensables pour de nombreux cas d'usage en programmation Python :
# AVANTAGE 1: Accès rapide aux données par clé # Parfait pour les recherches et les indexations annuaire_entreprises = { "Maroc Telecom": {"secteur": "Télécommunications", "ville": "Rabat"}, "OCP Group": {"secteur": "Industrie minière", "ville": "Casablanca"}, "Attijariwafa Bank": {"secteur": "Banque", "ville": "Casablanca"} } # Recherche ultra-rapide entreprise = "OCP Group" if entreprise in annuaire_entreprises: info = annuaire_entreprises[entreprise] print(f"{entreprise} - Secteur: {info['secteur']}, Ville: {info['ville']}") # AVANTAGE 2: Flexibilité des données # Stockage de données hétérogènes et structurées produit_marocain = { "nom": "Huile d'Argan", "prix": 150, # en DH "origine": "Essaouira", "caracteristiques": ["Bio", "100% naturel", "Certifié"], "en_stock": True, "fournisseurs": {"cooperative1": 50, "cooperative2": 30} } print(f"Produit: {produit_marocain['nom']}") print(f"Prix: {produit_marocain['prix']} DH") print(f"Caractéristiques: {', '.join(produit_marocain['caracteristiques'])}") # AVANTAGE 3: Facilité de mise à jour # Ajout, modification et suppression simples inventaire_souk = {} # Ajout dynamique inventaire_souk["tapis"] = 15 inventaire_souk["poterie"] = 42 inventaire_souk["lanternes"] = 8 # Mise à jour inventaire_souk["tapis"] = 12 # Vente de 3 tapis # Suppression del inventaire_souk["lanternes"] # Rupture de stock print(f"Inventaire final: {inventaire_souk}")
Chaque structure de données en Python a ses spécificités et cas d'usage privilégiés. Voici les principales différences :
# EXEMPLE PRATIQUE: Gestion d'une école marocaine # LISTE - Pour des collections ordonnées d'éléments similaires # Accès par index numérique eleves_classe = ["Ahmed", "Fatima", "Mehdi", "Zineb"] print("Premier élève:", eleves_classe[0]) # Ahmed print("Dernier élève:", eleves_classe[-1]) # Zineb # TUPLE - Pour des collections immuables et ordonnées # Parfait pour les données constantes informations_ecole = ("Lycée Mohammed V", "Casablanca", 1950) nom, ville, annee_creation = informations_ecole print(f"École: {nom}, située à {ville}") # DICTIONNAIRE - Pour des données structurées avec accès par clé # Idéal pour les enregistrements complexes eleve_detaille = { "nom": "Ahmed Alami", "age": 16, "classe": "2nde A", "notes": {"Maths": 15.5, "Physique": 14, "Arabe": 17}, "adresse": { "rue": "123 Avenue Hassan II", "ville": "Casablanca", "quartier": "Maârif" } } # Accès direct aux informations par clé descriptive print(f"Élève: {eleve_detaille['nom']}") print(f"Note en Maths: {eleve_detaille['notes']['Maths']}/20") print(f"Habite à: {eleve_detaille['adresse']['ville']}") # TABLEAU COMPARATIF print("\n" + "="*50) print("COMPARAISON DES STRUCTURES DE DONNÉES") print("="*50) comparaison = { "Listes": [ "✓ Collection ordonnée et mutable", "✓ Accès par index numérique", "✓ Éléments de même type recommandé", "✗ Recherche lente (O(n))" ], "Tuples": [ "✓ Collection ordonnée et immuable", "✓ Accès par index numérique", "✓ Plus rapide que les listes", "✗ Impossible de modifier après création" ], "Dictionnaires": [ "✓ Collection de paires clé-valeur", "✓ Accès rapide par clé (O(1))", "✓ Clés uniques et immuables", "✗ Pas d'ordre garanti avant Python 3.7" ] } for structure, caracteristiques in comparaison.items(): print(f"\n{structure}:") for carac in caracteristiques: print(f" {carac}")
Python offre plusieurs méthodes flexibles pour créer des dictionnaires, chacune adaptée à des situations spécifiques. La compréhension de ces différentes approches est essentielle pour une utilisation optimale des dictionnaires.
La méthode la plus courante pour créer un dictionnaire en Python est d'utiliser les accolades {} avec des paires clé:valeur séparées par des virgules.
# Syntaxe de base: {clé1: valeur1, clé2: valeur2, ...} # Dictionnaire des villes marocaines et leurs populations villes_maroc = { "Casablanca": 3.4, # Population en millions "Rabat": 0.6, "Fès": 1.1, "Marrakech": 0.9, "Tanger": 1.0 } print("Population de Casablanca:", villes_maroc["Casablanca"], "millions") print("Villes dans le dictionnaire:", list(villes_maroc.keys())) # Dictionnaire avec des informations plus complexes universites_maroc = { "Université Mohammed V": { "ville": "Rabat", "fondation": 1957, "etudiants": 45000 }, "Université Hassan II": { "ville": "Casablanca", "fondation": 1975, "etudiants": 62000 } } # Accès aux données imbriquées universite = "Université Mohammed V" info = universites_maroc[universite] print(f"\n{universite}:") print(f" Ville: {info['ville']}") print(f" Fondation: {info['fondation']}") print(f" Étudiants: {info['etudiants']:,}") # Syntaxe sur une seule ligne (pour les petits dictionnaires) produits_souk = {"tapis": 1500, "poterie": 300, "cuir": 800} print(f"\nPrix des produits: {produits_souk}")
La fonction built-in dict() permet de créer des dictionnaires de différentes manières, particulièrement utile pour les créations dynamiques ou à partir d'autres structures de données.
# Méthode 1: Avec des arguments nommés region_maroc = dict( nom="Casablanca-Settat", population=6.8, capitale="Casablanca", superficie=20166 ) print("Région créée avec arguments nommés:", region_maroc) # Méthode 2: À partir d'une liste de tuples (clé, valeur) villes_provinces = [ ("Casablanca", "Grand Casablanca"), ("Rabat", "Rabat-Salé-Kénitra"), ("Fès", "Fès-Meknès"), ("Marrakech", "Marrakech-Safi") ] mapping_villes = dict(villes_provinces) print("\nMapping villes → régions:", mapping_villes) # Méthode 3: À partir d'une liste de listes entreprises_maroc = [ ["Maroc Telecom", "Télécommunications"], ["OCP Group", "Industrie minière"], ["Attijariwafa Bank", "Banque"] ] secteurs_entreprises = dict(entreprises_maroc) print("\nSecteurs des entreprises:", secteurs_entreprises) # Méthode 4: Avec zip() pour combiner deux listes produits = ["Argan", "Safran", "Dattes", "Olives"] prix_dh = [150, 800, 60, 40] prix_produits = dict(zip(produits, prix_dh)) print("\nPrix des produits marocains:", prix_produits) # Méthode 5: Copie d'un dictionnaire existant original = {"ville": "Chefchaouen", "couleur": "bleu"} copie = dict(original) copie["region"] = "Tanger-Tétouan-Al Hoceïma" print(f"\nOriginal: {original}") print(f"Copie modifiée: {copie}")
La création de dictionnaires vides est essentielle pour initialiser des structures de données qui seront remplies dynamiquement pendant l'exécution du programme.
# Méthode 1: Avec les accolades (recommandée) inventaire_souk = {} print("Dictionnaire vide avec {}:", inventaire_souk) print("Type:", type(inventaire_souk)) # Méthode 2: Avec la fonction dict() carnet_adresses = dict() print("\nDictionnaire vide avec dict():", carnet_adresses) # CAS PRATIQUE: Remplissage progressif d'un dictionnaire vide print("\n" + "="*50) print("EXEMPLE PRATIQUE: Gestion d'un inventaire") print("="*50) # Initialisation d'un inventaire vide inventaire_cooperative = {} # Ajout progressif des produits inventaire_cooperative["huile_argan"] = { "quantite": 50, "prix_unitaire": 150, "origine": "Essaouira" } inventaire_cooperative["safran"] = { "quantite": 20, "prix_unitaire": 800, "origine": "Taliouine" } inventaire_cooperative["dattes"] = { "quantite": 100, "prix_unitaire": 60, "origine": "Erfoud" } # Affichage de l'inventaire complet print("\nInventaire final de la coopérative:") for produit, details in inventaire_cooperative.items(): valeur_stock = details["quantite"] * details["prix_unitaire"] print(f"- {produit.replace('_', ' ').title()}: {details['quantite']} unités" f" (Origine: {details['origine']}, Valeur: {valeur_stock} DH)") # Vérification si le dictionnaire est vide dictionnaire_test = {} print(f"\nLe dictionnaire est-il vide? {len(dictionnaire_test) == 0}") print(f"Vérification avec bool(): {bool(dictionnaire_test)}")
La flexibilité des dictionnaires Python permet de stocker n'importe quel type de données comme valeurs, ce qui les rend extrêmement polyvalents pour modéliser des structures complexes.
# Dictionnaire avec différents types de valeurs projet_maroc = { # Chaîne de caractères "nom": "Station Noor Ouarzazate", # Nombre (entier) "capacite_mw": 580, # Nombre (flottant) "superficie_km2": 30.5, # Booléen "operationnel": True, # Liste "technologies": ["CSP", "Photovoltaïque", "Stockage thermique"], # Tuple "coordonnees": (30.9333, -6.9167), # Dictionnaire imbriqué "impact": { "reduction_co2": 760000, # tonnes/an "emplois_crees": 2000, "villages_alimentes": 1.1 # millions }, # Aucune valeur (None) "prochaine_phase": None, # Ensemble (set) "partenaires": {"MASEN", "ACWA Power", "Banque Mondiale"} } # Affichage des différents types de valeurs print("PROJET SOLAIRE MAROCAIN") print("="*30) for cle, valeur in projet_maroc.items(): print(f"{cle.replace('_', ' ').title()}: {valeur} (Type: {type(valeur).__name__})") # Accès aux valeurs complexes print(f"\nTechnologies utilisées: {', '.join(projet_maroc['technologies'])}") print(f"Réduction CO2: {projet_maroc['impact']['reduction_co2']:,} tonnes/an") print(f"Partenaires: {', '.join(sorted(projet_maroc['partenaires']))}") # EXEMPLE AVANCÉ: Structure de données complexe print("\n" + "="*50) print("STRUCTURE COMPLEXE: Système éducatif marocain") print("="*50) systeme_educatif = { "universites": [ {"nom": "UM5 Rabat", "etudiants": 45000, "facultes": ["Droit", "Médecine", "Sciences"]}, {"nom": "UH2 Casablanca", "etudiants": 62000, "facultes": ["Économie", "Ingénierie"]} ], "statistiques": { "taux_scolarisation": 0.95, "budget_education": 65000000000, # 65 milliards DH "enseignants": 250000 }, "reforme_en_cours": True } # Navigation dans la structure complexe premiere_universite = systeme_educatif["universites"][0] print(f"\nPremière université: {premiere_universite['nom']}") print(f"Facultés: {', '.join(premiere_universite['facultes'])}") print(f"Budget éducation: {systeme_educatif['statistiques']['budget_education']:,} DH")
Python offre plusieurs méthodes pour accéder aux valeurs d'un dictionnaire, chacune avec ses avantages et cas d'usage spécifiques. La compréhension de ces différentes approches est cruciale pour écrire du code robuste et sécurisé.
L'opérateur [] est la méthode la plus directe pour accéder aux valeurs d'un dictionnaire. Cependant, il génère une erreur si la clé n'existe pas, ce qui nécessite une gestion appropriée.
# Dictionnaire des monuments historiques marocains monuments_maroc = { "Hassan II": {"ville": "Casablanca", "type": "Mosquée", "annee": 1993}, "Koutoubia": {"ville": "Marrakech", "type": "Mosquée", "annee": 1158}, "Chellah": {"ville": "Rabat", "type": "Site archéologique", "annee": 1339} } # Accès direct avec [] - méthode standard mosquee_hassan = monuments_maroc["Hassan II"] print("Mosquée Hassan II:", mosquee_hassan) # Accès aux valeurs imbriquées ville_koutoubia = monuments_maroc["Koutoubia"]["ville"] annee_chellah = monuments_maroc["Chellah"]["annee"] print(f"La mosquée Koutoubia se trouve à {ville_koutoubia}") print(f"Le site de Chellah date de {annee_chellah}") # DANGER: Accès à une clé qui n'existe pas print("\n--- Tentative d'accès à une clé inexistante ---") try: monument_inexistant = monuments_maroc["Tour Eiffel"] # KeyError! except KeyError as e: print(f"ERREUR: La clé '{e}' n'existe pas dans le dictionnaire") # CAS PRATIQUE: Système de réservation d'hôtels print("\n" + "="*50) print("SYSTÈME DE RÉSERVATION D'HÔTELS AU MAROC") print("="*50) hotels_maroc = { "La Mamounia": { "ville": "Marrakech", "etoiles": 5, "prix_nuit": 2500, "disponible": True }, "Sofitel Rabat": { "ville": "Rabat", "etoiles": 5, "prix_nuit": 1800, "disponible": False } } # Accès sécurisé avec vérification préalable hotel_recherche = "La Mamounia" if hotel_recherche in hotels_maroc: info_hotel = hotels_maroc[hotel_recherche] print(f"\n{hotel_recherche} - {info_hotel['ville']}") print(f"⭐ Étoiles: {info_hotel['etoiles']}") print(f"? Prix par nuit: {info_hotel['prix_nuit']} DH") print(f"? Disponible: {'Oui' if info_hotel['disponible'] else 'Non'}") else: print(f"\nL'hôtel '{hotel_recherche}' n'existe pas dans notre base de données")
La méthode .get() offre une alternative sécurisée à l'opérateur [], en retournant None ou une valeur par défaut spécifiée lorsque la clé n'existe pas.
# Dictionnaire des spécialités culinaires marocaines specialites_maroc = { "Tajine": "Plat mijoté avec viande et légumes", "Couscous": "Semoule avec légumes et viande", "Pastilla": "Feuilleté sucré-salé au pigeon", "Harira": "Soupe traditionnelle du Ramadan" } # Utilisation de .get() sans valeur par défaut description_tajine = specialites_maroc.get("Tajine") description_inexistante = specialites_maroc.get("Pizza") # Retourne None print("Description du Tajine:", description_tajine) print("Description d'un plat inexistant:", description_inexistante) # Utilisation de .get() avec valeur par défaut plat_recherche = "Sushi" description = specialites_maroc.get(plat_recherche, "Plat non répertorié") print(f"\n{plat_recherche}: {description}") # AVANTAGE: Code plus concis et sécurisé print("\n--- Comparaison [] vs .get() ---") # Méthode risquée avec [] print("Avec [] (risqué):") try: # Risque de KeyError si la clé n'existe pas valeur_risquee = specialites_maroc["Plat Inconnu"] print("Valeur:", valeur_risquee) except KeyError: print("❌ KeyError: La clé n'existe pas!") # Méthode sécurisée avec .get() print("\nAvec .get() (sécurisé):") valeur_securisee = specialites_maroc.get("Plat Inconnu", "Non disponible") print("Valeur:", valeur_securisee) # CAS PRATIQUE: Système de gestion de bibliothèque print("\n" + "="*50) print("SYSTÈME DE GESTION DE BIBLIOTHÈQUE") print("="*50) bibliotheque = { "9789954103524": {"titre": "Le Pain nu", "auteur": "Mohamed Choukri", "disponible": False}, "9789954103517": {"titre": "Mémoire d'une femme", "auteur": "Fatima Mernissi", "disponible": True}, "9789954103531": {"titre": "L'Enfant de sable", "auteur": "Tahar Ben Jelloun", "disponible": True} } # Recherche sécurisée avec .get() def rechercher_livre(isbn): livre = bibliotheque.get(isbn) if livre is None: return f"❌ Le livre avec ISBN {isbn} n'existe pas dans la bibliothèque" statut = "✅ Disponible" if livre["disponible"] else "❌ Emprunté" return (f"? {livre['titre']} par {livre['auteur']} - {statut}") # Tests de recherche isbns_a_chercher = ["9789954103524", "9789954103599", "9789954103531"] print("\nRésultats de recherche:") for isbn in isbns_a_chercher: resultat = rechercher_livre(isbn) print(f"- {resultat}")
L'opérateur in permet de vérifier efficacement si une clé existe dans un dictionnaire avant d'effectuer des opérations, évitant ainsi les erreurs potentielles.
# Dictionnaire des festivals marocains festivals_maroc = { "Mawazine": {"ville": "Rabat", "mois": "Mai", "type": "Musique"}, "FIFM": {"ville": "Marrakech", "mois": "Novembre", "type": "Cinéma"}, "Gnaoua": {"ville": "Essaouira", "mois": "Juin", "type": "Musique"} } # Vérification simple avec 'in' print("Le festival Mawazine existe-t-il?", "Mawazine" in festivals_maroc) print("Le festival Jazz existe-t-il?", "Jazz" in festivals_maroc) # Vérification avec 'not in' festival_a_verifier = "FIFM" if festival_a_verifier not in festivals_maroc: print(f"Le festival '{festival_a_verifier}' n'est pas répertorié") else: print(f"Le festival '{festival_a_verifier}' est bien répertorié") # PATTERN: Vérification avant accès (méthode recommandée) print("\n--- Pattern recommandé: vérifier avant d'accéder ---") def obtenir_info_festival(nom_festival): if nom_festival in festivals_maroc: info = festivals_maroc[nom_festival] return (f"? {nom_festival} - {info['ville']} ({info['mois']}) - {info['type']}") else: return f"❌ Le festival '{nom_festival}' n'est pas répertorié" # Tests festivals_test = ["Gnaoua", "Jazz", "Mawazine"] for festival in festivals_test: print(obtenir_info_festival(festival)) # CAS PRATIQUE AVANCÉ: Système de gestion des étudiants print("\n" + "="*50) print("SYSTÈME UNIVERSITAIRE MAROCAIN") print("="*50) universite_um5 = { "A12345": { "nom": "Fatima Zahra Alaoui", "filiere": "Médecine", "moyenne": 16.5, "annee": 3 }, "B67890": { "nom": "Mehdi Benjelloun", "filiere": "Informatique", "moyenne": 14.2, "annee": 2 } } # Fonction de recherche sécurisée def rechercher_etudiant(matricule): # Vérification d'existence avec 'in' if matricule in universite_um5: etudiant = universite_um5[matricule] mention = "Très Bien" if etudiant["moyenne"] >= 16 else "Bien" if etudiant["moyenne"] >= 14 else "Assez Bien" return (f"? {etudiant['nom']}\n" f" ? Filière: {etudiant['filiere']}\n" f" ? Moyenne: {etudiant['moyenne']}/20 ({mention})\n" f" ? Année: {etudiant['annee']}") else: return f"❌ Aucun étudiant trouvé avec le matricule {matricule}" # Interface utilisateur simple print("\nRecherche d'étudiants:") matricules_recherche = ["A12345", "C99999", "B67890"] for matricule in matricules_recherche: print(f"\nMatricule: {matricule}") print("-" * 30) print(rechercher_etudiant(matricule))
Python offre plusieurs méthodes flexibles pour modifier et mettre à jour les dictionnaires, permettant d'ajouter, modifier, supprimer ou fusionner des éléments de manière efficace et intuitive.
L'ajout de nouvelles entrées dans un dictionnaire se fait simplement en assignant une valeur à une nouvelle clé. Cette opération est très performante et constitue l'une des forces des dictionnaires Python.
# Création d'un dictionnaire vide pour un projet touristique marocain projet_touristique = {} print("Dictionnaire initial:", projet_touristique) # Ajout progressif d'éléments avec l'opérateur d'assignation projet_touristique["nom"] = "Circuit Impériales" projet_touristique["duree_jours"] = 7 projet_touristique["prix_dh"] = 4500 print("\nAprès ajout des informations de base:") print(f"Nom: {projet_touristique['nom']}") print(f"Durée: {projet_touristique['duree_jours']} jours") print(f"Prix: {projet_touristique['prix_dh']} DH") # Ajout d'une liste de villes visitées projet_touristique["villes"] = ["Rabat", "Fès", "Meknès", "Marrakech"] # Ajout d'un dictionnaire imbriqué pour les détails d'hébergement projet_touristique["hebergement"] = { "type": "Hôtels 4 étoiles", "petit_dejeuner": True, "nuits": 6 } # CAS PRATIQUE: Construction dynamique d'un inventaire de produits artisanaux print("\n" + "="*50) print("INVENTAIRE ARTISANAL MAROCAIN - AJOUT DYNAMIQUE") print("="*50) inventaire_artisanal = {} # Fonction pour ajouter un produit artisanal def ajouter_produit(nom, type_artisanat, ville_origine, prix, stock=0): inventaire_artisanal[nom] = { "type": type_artisanat, "origine": ville_origine, "prix_dh": prix, "stock": stock, "valeur_stock": prix * stock } print(f"✅ Produit ajouté: {nom}") # Ajout de plusieurs produits artisanaux ajouter_produit("Tapis Beni Ouarain", "Textile", "Midelt", 2500, 5) ajouter_produit("Poterie Bleue", "Céramique", "Chefchaouen", 450, 12) ajouter_produit("Cuir Maroquinerie", "Cuir", "Fès", 800, 8) ajouter_produit("Bijoux Berbère", "Bijouterie", "Tiznit", 1200, 3) # Affichage de l'inventaire complet print("\n? INVENTAIRE COMPLET:") valeur_totale = 0 for produit, details in inventaire_artisanal.items(): print(f"\n?️ {produit}") print(f" Type: {details['type']}") print(f" Origine: {details['origine']}") print(f" Prix: {details['prix_dh']} DH") print(f" Stock: {details['stock']} unités") print(f" Valeur: {details['valeur_stock']} DH") valeur_totale += details["valeur_stock"] print(f"\n? VALEUR TOTALE DE L'INVENTAIRE: {valeur_totale} DH")
La modification de valeurs existantes dans un dictionnaire se fait en réassignant une nouvelle valeur à une clé existante. Cette opération est immédiate et très efficace.
# Dictionnaire des prévisions météo pour les villes marocaines meteo_maroc = { "Casablanca": {"temperature": 22, "conditions": "Ensoleillé", "vent_kmh": 15}, "Marrakech": {"temperature": 28, "conditions": "Nuageux", "vent_kmh": 10}, "Fès": {"temperature": 25, "conditions": "Pluvieux", "vent_kmh": 20} } print("?️ PRÉVISIONS MÉTÉO INITIALES") print("="*40) for ville, meteo in meteo_maroc.items(): print(f"{ville}: {meteo['temperature']}°C, {meteo['conditions']}") # Mise à jour des prévisions météo print("\n? MISES À JOUR DES PRÉVISIONS") print("="*40) # Modification simple d'une valeur meteo_maroc["Casablanca"]["temperature"] = 24 # Réchauffement meteo_maroc["Marrakech"]["conditions"] = "Ensoleillé" # Amélioration meteo_maroc["Fès"]["vent_kmh"] = 25 # Vent plus fort print("✅ Mises à jour appliquées!") # CAS PRATIQUE: Système de gestion de stock en temps réel print("\n" + "="*50) print("? SYSTÈME DE GESTION DE STOCK - COOPÉRATIVE ARGAN") print("="*50) stock_cooperative = { "huile_argan_culinaire": { "quantite": 150, "prix_unitaire": 180, "seuil_alerte": 20, "unite": "bouteilles" }, "huile_argan_cosmetique": { "quantite": 80, "prix_unitaire": 220, "seuil_alerte": 15, "unite": "flacons" }, "amlou": { "quantite": 45, "prix_unitaire": 120, "seuil_alerte": 10, "unite": "pots" } } # Fonction pour mettre à jour le stock après une vente def enregistrer_vente(produit, quantite_vendue): if produit in stock_cooperative: ancien_stock = stock_cooperative[produit]["quantite"] nouveau_stock = ancien_stock - quantite_vendue # Mise à jour de la quantité stock_cooperative[produit]["quantite"] = nouveau_stock # Vérification du seuil d'alerte seuil = stock_cooperative[produit]["seuil_alerte"] if nouveau_stock <= seuil: print(f"⚠️ ALERTE: Stock faible pour {produit} ({nouveau_stock} {stock_cooperative[produit]['unite']})") print(f"✅ Vente enregistrée: {quantite_vendue} {produit}") print(f" Stock passé de {ancien_stock} à {nouveau_stock}") else: print(f"❌ Produit '{produit}' non trouvé") # Simulation de ventes print("\n? SIMULATION DE VENTES:") enregistrer_vente("huile_argan_culinaire", 25) enregistrer_vente("huile_argan_cosmetique", 15) enregistrer_vente("amlou", 8) enregistrer_vente("huile_argan_culinaire", 40) # Déclenchera une alerte # Affichage du stock final print("\n? ÉTAT DU STOCK FINAL:") for produit, details in stock_cooperative.items(): statut = "? CRITIQUE" if details["quantite"] <= details["seuil_alerte"] else "? NORMAL" print(f"{produit}: {details['quantite']} {details['unite']} - {statut}")
La méthode .update() permet de fusionner un dictionnaire avec un autre, en écrasant les clés existantes et en ajoutant les nouvelles clés. C'est une méthode très utile pour combiner des données.
# Dictionnaires représentant différentes sources de données touristiques info_touristiques_base = { "population": 37000000, "langue_officielle": "Arabe", "monnaie": "Dirham marocain (MAD)", "capitale": "Rabat" } info_touristiques_culture = { "religion_principale": "Islam", "fetes_nationales": ["Fête du Trône", "Fête de l'Indépendance"], "specialites_culinaires": ["Tajine", "Couscous", "Pastilla"] } info_touristiques_geographie = { "superficie_km2": 710850, "climat": "Méditerranéen", "points_culminants": "Mont Toubkal (4167m)" } print("?️ FUSION DE DONNÉES TOURISTIQUES") print("="*40) # Fusion progressive avec .update() guide_touristique = info_touristiques_base.copy() # Création d'une copie print("1. Données de base:", list(guide_touristique.keys())) guide_touristique.update(info_touristiques_culture) print("2. Après ajout culture:", list(guide_touristique.keys())) guide_touristique.update(info_touristiques_geographie) print("3. Après ajout géographie:", list(guide_touristique.keys())) # CAS PRATIQUE: Fusion de bases de données d'entreprises print("\n" + "="*50) print("? FUSION DE BASES DE DONNÉES ENTREPRISES") print("="*50) # Base de données régionale Casablanca-Settat entreprises_casablanca = { "Maroc Telecom": { "secteur": "Télécoms", "employes": 12000, "chiffre_affaires_mdh": 35000 }, "OCP Group": { "secteur": "Industrie", "employes": 21000, "chiffre_affaires_mdh": 75000 } } # Base de données régionale Rabat-Salé-Kénitra entreprises_rabat = { "BMCE Bank": { "secteur": "Banque", "employes": 8000, "chiffre_affaires_mdh": 18000 }, "Royal Air Maroc": { "secteur": "Transport", "employes": 3500, "chiffre_affaires_mdh": 22000 } } # Fusion des deux bases de données annuaire_national = {} annuaire_national.update(entreprises_casablanca) annuaire_national.update(entreprises_rabat) # Ajout d'une entreprise présente dans les deux régions (écrasement) entreprises_rabat["Maroc Telecom"] = { "secteur": "Télécoms", "employes": 1500, # Employés dans la région Rabat "chiffre_affaires_mdh": 5000 # CA dans la région Rabat } # Mise à jour avec écrasement des données existantes annuaire_national.update(entreprises_rabat) print("? ANNUAIRE NATIONAL DES ENTREPRISES") print("-"*40) for entreprise, details in annuaire_national.items(): print(f"\n? {entreprise}") print(f" Secteur: {details['secteur']}") print(f" Employés: {details['employes']:,}") print(f" Chiffre d'affaires: {details['chiffre_affaires_mdh']:,} MDH") print(f"\n? TOTAL ENTREPRISES: {len(annuaire_national)}")
À partir de Python 3.9, l'opérateur | permet de fusionner des dictionnaires de manière plus intuitive et lisible, créant un nouveau dictionnaire sans modifier les originaux.
# Nécessite Python 3.9+ # Dictionnaires des programmes de développement régional programme_nord = { "Tanger-Med": {"budget_mdh": 5000, "type": "Infrastructure"}, "Tourisme Chefchaouen": {"budget_mdh": 800, "type": "Tourisme"} } programme_sud = { "Noor Ouarzazate": {"budget_mdh": 25000, "type": "Énergie"}, "Station Taghazout": {"budget_mdh": 1200, "type": "Tourisme"} } programme_centre = { "LGV Casablanca": {"budget_mdh": 20000, "type": "Transport"}, "Technopark Rabat": {"budget_mdh": 1500, "type": "Technologie"} } print("?️ FUSION AVEC L'OPÉRATEUR | (Python 3.9+)") print("="*50) # Fusion simple avec | programmes_combines = programme_nord | programme_sud print("1. Nord + Sud:", list(programmes_combines.keys())) # Fusion multiple tous_programmes = programme_nord | programme_sud | programme_centre print("2. Nord + Sud + Centre:", list(tous_programmes.keys())) # Opérateur |= pour mise à jour en place programmes_nationaux = programme_nord.copy() programmes_nationaux |= programme_sud # Équivalent à .update() programmes_nationaux |= programme_centre print("3. Avec |= :", list(programmes_nationaux.keys())) # AVANTAGE: Les dictionnaires originaux restent inchangés print(f"\n✅ Programme Nord original: {len(programme_nord)} projets") print(f"✅ Programme Sud original: {len(programme_sud)} projets") print(f"✅ Programme Centre original: {len(programme_centre)} projets") print(f"? Programmes combinés: {len(tous_programmes)} projets") # CAS PRATIQUE: Consolidation de données de recensement print("\n" + "="*50) print("? RECENSEMENT ÉCONOMIQUE RÉGIONAL") print("="*50) # Données économiques par région (chiffres fictifs) economie_oriental = { "agriculture": {"poids": 0.35, "croissance": 0.04}, "tourisme": {"poids": 0.15, "croissance": 0.08}, "industrie": {"poids": 0.25, "croissance": 0.06} } economie_souss = { "agriculture": {"poids": 0.40, "croissance": 0.05}, "agroalimentaire": {"poids": 0.20, "croissance": 0.07}, "tourisme": {"poids": 0.25, "croissance": 0.09} } # Fusion avec gestion des conflits (les dernières valeurs écrasent les premières) economie_combinee = economie_oriental | economie_souss print("? SECTEURS ÉCONOMIQUES COMBINÉS:") for secteur, data in economie_combinee.items(): print(f"\n? {secteur.title()}") print(f" Poids dans l'économie: {data['poids']*100}%") print(f" Taux de croissance: {data['croissance']*100}%") # Comparaison | vs .update() print("\n" + "-"*40) print("? COMPARAISON | vs .update()") print("-"*40) # Avec | (création d'un nouveau dictionnaire) nouveau_dict = economie_oriental | economie_souss print(f"Avec | : Original inchangé ({len(economie_oriental)} secteurs)") # Avec .update() (modification du dictionnaire original) economie_copie = economie_oriental.copy() economie_copie.update(economie_souss) print(f"Avec .update(): Copie modifiée ({len(economie_copie)} secteurs)") print(f"\n✅ Original toujours intact: {len(economie_oriental)} secteurs")
Python offre plusieurs méthodes pour supprimer des éléments d'un dictionnaire, chacune adaptée à des besoins spécifiques. La maîtrise de ces techniques est essentielle pour une gestion efficace des données.
L'instruction del permet de supprimer une paire clé-valeur spécifique d'un dictionnaire. C'est une méthode directe mais qui peut générer une erreur si la clé n'existe pas.
# Dictionnaire des monuments historiques marocains monuments_maroc = { "Hassan II": "Casablanca", "Koutoubia": "Marrakech", "Chellah": "Rabat", "Mansour": "Meknès", "Badii": "Marrakech" } print("?️ MONUMENTS INITIAUX:") for monument, ville in monuments_maroc.items(): print(f" - {monument} à {ville}") # Suppression avec del print("\n?️ SUPPRESSION AVEC DEL:") print("-"*30) # Suppression d'un élément existant del monuments_maroc["Mansour"] print("✅ Monument 'Mansour' supprimé") # Tentative de suppression d'un élément inexistant (DANGER) print("\n⚠️ Tentative de suppression d'un monument inexistant:") try: del monuments_maroc["Tour Eiffel"] except KeyError as e: print(f"❌ KeyError: Le monument '{e}' n'existe pas") # Bonne pratique: vérifier avant de supprimer monument_a_supprimer = "Badii" if monument_a_supprimer in monuments_maroc: del monuments_maroc[monument_a_supprimer] print(f"✅ Monument '{monument_a_supprimer}' supprimé avec vérification") else: print(f"ℹ️ Le monument '{monument_a_supprimer}' n'existe pas") print(f"\n? Monuments restants: {len(monuments_maroc)}") for monument, ville in monuments_maroc.items(): print(f" - {monument} à {ville}") # CAS PRATIQUE: Gestion des participants à un événement print("\n" + "="*50) print("? GESTION DES PARTICIPANTS - FESTIVAL GNAOUA") print("="*50) participants_festival = { "P001": {"nom": "Karim Bensalah", "type": "Artiste", "statut": "Confirmé"}, "P002": {"nom": "Fatima Zahra", "type": "Bénévole", "statut": "En attente"}, "P003": {"nom": "Mehdi Alaoui", "type": "Sponsor", "statut": "Confirmé"}, "P004": {"nom": "Zineb Benjelloun", "type": "Artiste", "statut": "Annulé"} } # Fonction pour supprimer un participant def supprimer_participant(id_participant): if id_participant in participants_festival: participant = participants_festival[id_participant] del participants_festival[id_participant] print(f"✅ Participant supprimé: {participant['nom']} ({id_participant})") else: print(f"❌ Participant {id_participant} non trouvé") # Suppression de participants print(f"? Participants initiaux: {len(participants_festival)}") supprimer_participant("P004") # Participant annulé supprimer_participant("P005") # ID inexistant print(f"? Participants restants: {len(participants_festival)}")
La méthode .pop() supprime une clé et retourne sa valeur correspondante. Elle permet de spécifier une valeur par défaut si la clé n'existe pas, évitant ainsi les erreurs.
# Dictionnaire des produits d'une coopérative d'argan produits_cooperative = { "ARG001": {"nom": "Huile d'Argan Culinaire", "prix": 180, "stock": 45}, "ARG002": {"nom": "Huile d'Argan Cosmétique", "prix": 220, "stock": 32}, "ARG003": {"nom": "Amlou Traditionnel", "prix": 120, "stock": 18}, "ARG004": {"nom": "Savon à l'Argan", "prix": 45, "stock": 0} # Rupture de stock } print("? PRODUITS INITIAUX DE LA COOPÉRATIVE:") for code, produit in produits_cooperative.items(): print(f" {code}: {produit['nom']} - Stock: {produit['stock']}") # Utilisation de .pop() avec valeur de retour print("\n?️ SUPPRESSION AVEC .pop():") print("-"*30) # Suppression d'un produit en rupture de stock produit_supprime = produits_cooperative.pop("ARG004") print(f"✅ Produit supprimé: {produit_supprime['nom']}") print(f" Prix: {produit_supprime['prix']} DH") print(f" Stock final: {produit_supprime['stock']}") # .pop() avec valeur par défaut (sécurisé) code_inexistant = "ARG999" produit_inexistant = produits_cooperative.pop(code_inexistant, None) if produit_inexistant is None: print(f"ℹ️ Le produit {code_inexistant} n'existe pas (valeur par défaut retournée)") else: print(f"✅ Produit {code_inexistant} supprimé") # .pop() avec valeur par défaut personnalisée produit_par_defaut = produits_cooperative.pop("ARG005", "PRODUIT_INTROUVABLE") print(f"ℹ️ Résultat pour produit inexistant: {produit_par_defaut}") print(f"\n? Produits restants: {len(produits_cooperative)}") # CAS PRATIQUE: Système de réservation d'hôtels print("\n" + "="*50) print("? SYSTÈME DE RÉSERVATION - HÔTEL MAMOUNIA") print("="*50) reservations = { "RES001": {"client": "Ahmed Alami", "chambre": "Suite Royale", "nuits": 3, "statut": "Confirmée"}, "RES002": {"client": "Sophie Martin", "chambre": "Chambre Deluxe", "nuits": 5, "statut": "Annulée"}, "RES003": {"client": "Karim Bennis", "chambre": "Suite Junior", "nuits": 2, "statut": "Confirmée"} } # Fonction pour annuler une réservation def annuler_reservation(numero_reservation): reservation = reservations.pop(numero_reservation, None) if reservation: print(f"✅ Réservation annulée: {reservation['client']}") print(f" Chambre: {reservation['chambre']}") print(f" Nuits: {reservation['nuits']}") return reservation else: print(f"❌ Réservation {numero_reservation} non trouvée") return None # Annulation de réservations print(f"? Réservations initiales: {len(reservations)}") reservation_annulee = annuler_reservation("RES002") annuler_reservation("RES999") # Numéro inexistant print(f"? Réservations restantes: {len(reservations)}")
La méthode .popitem() supprime et retourne la dernière paire clé-valeur ajoutée au dictionnaire. Elle est utile pour traiter les éléments dans l'ordre LIFO (Last-In, First-Out).
# File d'attente pour des visas de tourisme file_attente_visas = {} # Ajout de demandes de visas dans l'ordre file_attente_visas["V001"] = {"nom": "Jean Dupont", "nationalite": "Française", "duree": 30} file_attente_visas["V002"] = {"nom": "Maria Silva", "nationalite": "Portugaise", "duree": 15} file_attente_visas["V003"] = {"nom": "John Smith", "nationalite": "Britannique", "duree": 90} file_attente_visas["V004"] = {"nom": "Fatima Chen", "nationalite": "Chinoise", "duree": 60} print("? FILE D'ATTENTE DES VISAS (ordre d'arrivée):") for visa, details in file_attente_visas.items(): print(f" {visa}: {details['nom']} ({details['nationalite']}) - {details['duree']} jours") # Traitement LIFO (Last-In, First-Out) avec .popitem() print("\n? TRAITEMENT LIFO AVEC .popitem():") print("-"*35) while file_attente_visas: visa_id, details_visa = file_attente_visas.popitem() print(f"✅ Visa traité: {details_visa['nom']} ({visa_id})") print(f" Nationalité: {details_visa['nationalite']}") print(f" Durée approuvée: {details_visa['duree']} jours") print(f" ? Visas restants: {len(file_attente_visas)}\n") print("? Tous les visas ont été traités!") # CAS PRATIQUE: Système de gestion des commandes print("\n" + "="*50) print("? SYSTÈME DE GESTION DES COMMANDES - SOUK ELECTRONIQUE") print("="*50) commandes_pending = { "CMD2024001": {"client": "Boutique Atlas", "montant": 4500, "urgence": "Normale"}, "CMD2024002": {"client": "Électronique Marhaba", "montant": 3200, "urgence": "Haute"}, "CMD2024003": {"client": "TechStore Rabat", "montant": 7800, "urgence": "Normale"}, "CMD2024004": {"client": "Digital Casa", "montant": 1500, "urgence": "Basse"} } # Simulation de traitement des commandes (ordre LIFO) print("? TRAITEMENT DES COMMANDES (LIFO):") commandes_traitees = [] while commandes_pending: cmd_id, details_cmd = commandes_pending.popitem() commandes_traitees.append((cmd_id, details_cmd)) print(f"\n? Commande traitée: {cmd_id}") print(f" Client: {details_cmd['client']}") print(f" Montant: {details_cmd['montant']} DH") print(f" Urgence: {details_cmd['urgence']}") print(f" ? Commandes en attente: {len(commandes_pending)}") print(f"\n✅ TOTAL COMMANDES TRAITÉES: {len(commandes_traitees)}") print("? Ordre de traitement (du plus récent au plus ancien):") for i, (cmd_id, details) in enumerate(commandes_traitees, 1): print(f" {i}. {cmd_id} - {details['client']}")
La méthode .clear() supprime tous les éléments d'un dictionnaire, le laissant vide. C'est une opération rapide et efficace pour réinitialiser complètement un dictionnaire.
# Dictionnaire des sessions d'une conférence tech à Casablanca sessions_conference = { "IA001": { "titre": "L'IA au service du développement", "intervenant": "Dr. Leila Benali", "duree": 45, "salle": "Amphithéâtre Principal", "participants": 120 }, "WEB001": { "titre": "Les nouvelles tendances du Web", "intervenant": "Mehdi El Fassi", "duree": 60, "salle": "Salle B", "participants": 85 }, "DATA001": { "titre": "Big Data et Analytics", "intervenant": "Youssef Amrani", "duree": 90, "salle": "Salle C", "participants": 65 } } print("? CONFÉRENCE TECH CASABLANCA - SESSIONS PROGRAMMÉES:") print(f"? Nombre de sessions: {len(sessions_conference)}") for session_id, session in sessions_conference.items(): print(f"\n ? {session_id}") print(f" ? {session['titre']}") print(f" ?? Intervenant: {session['intervenant']}") print(f" ⏱️ Durée: {session['duree']} min") print(f" ? Salle: {session['salle']}") print(f" ? Participants: {session['participants']}") # Annulation de toute la conférence print("\n? ANNONCE IMPORTANTE: Conférence annulée pour cause de grève!") print("-"*55) # Vider complètement le dictionnaire avec .clear() sessions_conference.clear() print(f"✅ Toutes les sessions ont été annulées") print(f"? Sessions restantes: {len(sessions_conference)}") print(f"? Le dictionnaire est vide: {len(sessions_conference) == 0}") print(f"? Contenu: {sessions_conference}") # CAS PRATIQUE: Réinitialisation d'un système de monitoring print("\n" + "="*50) print("? SYSTÈME DE MONITORING - STATION NOOR OUARZAZATE") print("="*50) # Données de monitoring de la centrale solaire donnees_monitoring = { "temperature_panneaux": 42.5, "production_mw": 480.3, "efficacite": 0.78, "alertes_actives": ["sur_température", "vent_fort"], "maintenance_prevue": "2024-06-15", "techniciens_presents": 8 } print("? DONNÉES DE MONITORING EN TEMPS RÉEL:") print(f"? Nombre de métriques: {len(donnees_monitoring)}") for metrique, valeur in donnees_monitoring.items(): print(f" ? {metrique}: {valeur}") # Simulation d'une réinitialisation du système print("\n? RÉINITIALISATION DU SYSTÈME DE MONITORING...") # Sauvegarde des données avant réinitialisation sauvegarde = donnees_monitoring.copy() # Réinitialisation complète donnees_monitoring.clear() print(f"✅ Système réinitialisé") print(f"? Métriques après réinitialisation: {len(donnees_monitoring)}") print(f"? Dictionnaire vide: {donnees_monitoring}") # Redémarrage avec nouvelles données print("\n? REDÉMARRAGE DU SYSTÈME...") donnees_monitoring.update(sauvegarde) donnees_monitoring["statut"] = "Système redémarré" donnees_monitoring["timestamp_redemarrage"] = "2024-01-15 08:30:00" print(f"✅ Système redémarré avec succès") print(f"? Métriques après redémarrage: {len(donnees_monitoring)}") for metrique, valeur in donnees_monitoring.items(): print(f" ? {metrique}: {valeur}")
Python offre plusieurs méthodes efficaces pour parcourir les dictionnaires, permettant d'accéder aux clés, aux valeurs ou aux paires clé-valeur selon les besoins. La maîtrise de ces techniques est essentielle pour manipuler efficacement les données.
La méthode .keys() retourne une vue des clés du dictionnaire, permettant de parcourir uniquement les identifiants des éléments. C'est utile quand seules les clés nous intéressent.
# Dictionnaire des universités marocaines et leurs villes universites_maroc = { "Université Mohammed V": "Rabat", "Université Hassan II": "Casablanca", "Université Sidi Mohamed Ben Abdellah": "Fès", "Université Cadi Ayyad": "Marrakech", "Université Abdelmalek Essaâdi": "Tétouan" } print("? PARCOURS DES CLÉS AVEC .keys():") print("="*40) # Méthode 1: Parcours direct avec .keys() (explicite) print("\n1. Parcours explicite avec .keys():") for universite in universites_maroc.keys(): print(f" ? {universite}") # Méthode 2: Parcours implicite (par défaut) print("\n2. Parcours implicite (comportement par défaut):") for universite in universites_maroc: # Équivalent à .keys() print(f" ? {universite}") # Conversion en liste pour manipulation print("\n3. Conversion en liste:") liste_universites = list(universites_maroc.keys()) print(f" ? Liste des universités: {liste_universites}") # CAS PRATIQUE: Système de recherche de monuments print("\n" + "="*50) print("?️ GUIDE DES MONUMENTS HISTORIQUES MAROCAINS") print("="*50) monuments_maroc = { "Hassan II": {"ville": "Casablanca", "type": "Mosquée", "visite": True}, "Koutoubia": {"ville": "Marrakech", "type": "Mosquée", "visite": False}, "Chellah": {"ville": "Rabat", "type": "Site archéologique", "visite": True}, "Mansour": {"ville": "Meknès", "type": "Porte", "visite": True} } # Fonction pour lister tous les monuments def lister_monuments(): print("? LISTE DES MONUMENTS DISPONIBLES:") for i, monument in enumerate(monuments_maroc.keys(), 1): print(f" {i}. {monument}") # Fonction pour vérifier l'existence d'un monument def monument_existe(nom_monument): return nom_monument in monuments_maroc.keys() # Utilisation lister_monuments() print(f"\n? RECHERCHE DE MONUMENTS:") monuments_a_verifier = ["Hassan II", "Tour Eiffel", "Chellah"] for monument in monuments_a_verifier: if monument_existe(monument): print(f" ✅ '{monument}' existe dans notre base") else: print(f" ❌ '{monument}' n'existe pas") # Statistiques print(f"\n? TOTAL MONUMENTS RÉPERTORIÉS: {len(monuments_maroc.keys())}")
La méthode .values() retourne une vue des valeurs du dictionnaire, permettant de parcourir uniquement les données sans se soucier des clés. C'est utile pour des opérations sur les données elles-mêmes.
# Dictionnaire des productions agricoles par région (en tonnes) production_agricole = { "Souss-Massa": {"agrumes": 150000, "primeurs": 80000, "argan": 4000}, "Marrakech-Safi": {"olives": 120000, "agrumes": 90000, "céréales": 200000}, "Rabat-Salé-Kénitra": {"lait": 500000, "volailles": 150000, "céréales": 180000}, "Oriental": {"figues": 30000, "amandes": 25000, "olives": 80000} } print("? PARCOURS DES VALEURS AVEC .values():") print("="*45) # Parcours simple des valeurs print("\n1. Productions par région:") for production_region in production_agricole.values(): print(f" ? {production_region}") # Calcul des totaux par type de production print("\n2. CALCUL DES PRODUCTIONS TOTALES:") totaux = {} for productions in production_agricole.values(): for produit, quantite in productions.items(): totaux[produit] = totaux.get(produit, 0) + quantite for produit, total in sorted(totaux.items()): print(f" ? {produit}: {total:,} tonnes") # CAS PRATIQUE: Analyse des résultats sportifs print("\n" + "="*50) print("⚽ CHAMPIONNAT MAROCAIN DE FOOTBALL - BOTOLA PRO") print("="*50) classement_botola = { "Raja CA": {"points": 65, "buts_marques": 48, "buts_encaisses": 22}, "Wydad AC": {"points": 62, "buts_marques": 45, "buts_encaisses": 25}, "FAR Rabat": {"points": 58, "buts_marques": 40, "buts_encaisses": 28}, "AS FAR": {"points": 55, "buts_marques": 38, "buts_encaisses": 30} } # Analyse statistique des performances print("? STATISTIQUES GÉNÉRALES DU CHAMPIONNAT:") # Calcul des moyennes total_points = 0 total_buts_marques = 0 total_buts_encaisses = 0 nombre_equipes = len(classement_botola) for stats in classement_botola.values(): total_points += stats["points"] total_buts_marques += stats["buts_marques"] total_buts_encaisses += stats["buts_encaisses"] moyenne_points = total_points / nombre_equipes moyenne_buts_marques = total_buts_marques / nombre_equipes moyenne_buts_encaisses = total_buts_encaisses / nombre_equipes print(f"\n? MOYENNES PAR ÉQUIPE:") print(f" ⚡ Points: {moyenne_points:.1f}") print(f" ? Buts marqués: {moyenne_buts_marques:.1f}") print(f" ?️ Buts encaissés: {moyenne_buts_encaisses:.1f}") # Recherche de l'équipe la plus performante meilleure_attaque = max( classement_botola.values(), key=lambda x: x["buts_marques"] ) meilleure_defense = min( classement_botola.values(), key=lambda x: x["buts_encaisses"] ) print(f"\n? PERFORMANCES EXCEPTIONNELLES:") print(f" ⚽ Meilleure attaque: {meilleure_attaque['buts_marques']} buts") print(f" ?️ Meilleure défense: {meilleure_defense['buts_encaisses']} buts encaissés")
La méthode .items() retourne une vue des paires clé-valeur du dictionnaire, permettant d'accéder simultanément aux clés et aux valeurs. C'est la méthode la plus utilisée pour parcourir les dictionnaires.
# Dictionnaire des projets d'énergie renouvelable au Maroc projets_energie = { "Noor Ouarzazate": { "type": "Solaire", "capacite_mw": 580, "investissement_mdh": 25000, "statut": "Opérationnel" }, "Noor Midelt": { "type": "Solaire", "capacite_mw": 800, "investissement_mdh": 7500, "statut": "En construction" }, " parc Éolien de Tarfaya": { "type": "Éolien", "capacite_mw": 301, "investissement_mdh": 5000, "statut": "Opérationnel" } } print("? PARCOURS AVEC .items() - PROJETS ÉNERGÉTIQUES:") print("="*55) # Parcours classique avec .items() print("\n1. Liste complète des projets:") for nom_projet, details in projets_energie.items(): print(f"\n ?️ {nom_projet}") print(f" Type: {details['type']}") print(f" Capacité: {details['capacite_mw']} MW") print(f" Investissement: {details['investissement_mdh']} MDH") print(f" Statut: {details['statut']}") # Filtrage avec .items() print("\n2. PROJETS OPÉRATIONNELS:") for nom_projet, details in projets_energie.items(): if details["statut"] == "Opérationnel": print(f" ✅ {nom_projet} - {details['capacite_mw']} MW") # CAS PRATIQUE: Gestion d'une médiathèque print("\n" + "="*50) print("? MÉDIATHÈQUE NATIONALE - CATALOGUE DES ŒUVRES") print("="*50) catalogue_mediatheque = { "9789954103524": { "titre": "Le Pain nu", "auteur": "Mohamed Choukri", "genre": "Autobiographie", "annee": 1982, "disponible": False }, "9789954103517": { "titre": "Mémoire d'une femme", "auteur": "Fatima Mernissi", "genre": "Sociologie", "annee": 1994, "disponible": True }, "9789954103531": { "titre": "L'Enfant de sable", "auteur": "Tahar Ben Jelloun", "genre": "Roman", "annee": 1985, "disponible": True } } # Affichage du catalogue complet print("? CATALOGUE COMPLET:") for isbn, livre in catalogue_mediatheque.items(): statut = "✅ Disponible" if livre["disponible"] else "❌ Emprunté" print(f"\n ? {livre['titre']}") print(f" Auteur: {livre['auteur']}") print(f" Genre: {livre['genre']}") print(f" Année: {livre['annee']}") print(f" Statut: {statut}") print(f" ISBN: {isbn}") # Recherche par auteur print(f"\n? RECHERCHE PAR AUTEUR:") auteur_recherche = "Tahar Ben Jelloun" livres_trouves = [] for isbn, livre in catalogue_mediatheque.items(): if livre["auteur"] == auteur_recherche: livres_trouves.append((isbn, livre["titre"])) if livres_trouves: print(f" ? Œuvres de {auteur_recherche}:") for isbn, titre in livres_trouves: print(f" - {titre} (ISBN: {isbn})") else: print(f" ℹ️ Aucune œuvre trouvée pour {auteur_recherche}")
Les boucles for sur les dictionnaires peuvent être optimisées en utilisant des techniques comme le unpacking, les compréhensions de dictionnaire et l'utilisation judicieuse des vues pour améliorer les performances et la lisibilité.
# Dictionnaire des sites touristiques marocains sites_touristiques = { "Jemaa el-Fna": {"ville": "Marrakech", "type": "Place publique", "affluence": "Élevée"}, "Kasbah des Oudayas": {"ville": "Rabat", "type": "Forteresse", "affluence": "Moyenne"}, "Médina de Fès": {"ville": "Fès", "type": "Vieille ville", "affluence": "Élevée"}, "Plage de Legzira": {"ville": "Sidi Ifni", "type": "Plage", "affluence": "Faible"} } print("�️ BOUCLES FOR OPTIMISÉES:") print("="*30) # TECHNIQUE 1: Unpacking avec des noms de variables significatifs print("\n1. UNPACKING AVEC NOMS SIGNIFICATIFS:") for nom_site, infos_site in sites_touristiques.items(): print(f" ?️ {nom_site} - {infos_site['ville']} ({infos_site['type']})") # TECHNIQUE 2: Filtrage avec compréhension de liste print("\n2. FILTRAGE AVEC COMPRÉHENSION:") sites_frequentés = [ nom for nom, infos in sites_touristiques.items() if infos["affluence"] == "Élevée" ] print(f" ? Sites très fréquentés: {sites_frequentés}") # TECHNIQUE 3: Utilisation de enumerate pour l'indexation print("\n3. AVEC ENUMERATE POUR L'INDEXATION:") for i, (nom_site, infos_site) in enumerate(sites_touristiques.items(), 1): print(f" {i}. {nom_site} ({infos_site['ville']})") # CAS PRATIQUE AVANCÉ: Système de gestion hôtelière print("\n" + "="*50) print("? RÉSEAU HÔTELIER 'RIADS DU MAROC'") print("="*50) hotels_reseau = { "Riad Alam": { "ville": "Marrakech", "chambres": 12, "prix_nuit": 800, "note": 4.7, "services": ["piscine", "spa", "petit-déjeuner"] }, "Riad Zitoun": { "ville": "Fès", "chambres": 8, "prix_nuit": 650, "note": 4.5, "services": ["terrasse", "cours de cuisine"] }, "Riad Andalous": { "ville": "Essaouira", "chambres": 6, "prix_nuit": 550, "note": 4.8, "services": ["plage", "surf", "petit-déjeuner"] } } # OPTIMISATION 1: Calcul du revenu potentiel avec générateur print("? ANALYSE FINANCIÈRE OPTIMISÉE:") revenu_total = sum( infos["chambres"] * infos["prix_nuit"] * 30 # Estimation mensuelle for infos in hotels_reseau.values() ) print(f" ? Revenu mensuel potentiel: {revenu_total:,} DH") # OPTIMISATION 2: Recherche des meilleurs hôtels meilleurs_hotels = sorted( hotels_reseau.items(), key=lambda item: item[1]["note"], reverse=True ) print(f"\n? CLASSEMENT DES HÔTELS PAR NOTE:") for i, (nom_hotel, infos) in enumerate(meilleurs_hotels, 1): print(f" {i}. {nom_hotel} - {infos['ville']} ⭐ {infos['note']}/5") # OPTIMISATION 3: Agrégation des services disponibles tous_services = set() for infos in hotels_reseau.values(): tous_services.update(infos["services"]) print(f"\n? SERVICES DISPONIBLES DANS LE RÉSEAU:") print(f" {', '.join(sorted(tous_services))}") # OPTIMISATION 4: Création d'un index par ville hotels_par_ville = {} for nom_hotel, infos in hotels_reseau.items(): ville = infos["ville"] if ville not in hotels_par_ville: hotels_par_ville[ville] = [] hotels_par_ville[ville].append(nom_hotel) print(f"\n?️ HÔTELS PAR VILLE:") for ville, hotels in hotels_par_ville.items(): print(f" ? {ville}: {', '.join(hotels)}")
Python fournit un ensemble de méthodes puissantes pour manipuler efficacement les dictionnaires. La maîtrise de ces méthodes permet d'écrire du code plus concis, plus lisible et plus performant.
Les dictionnaires Python disposent de nombreuses méthodes intégrées qui facilitent leur manipulation. Voici un aperçu complet des méthodes les plus utilisées avec des exemples concrets.
# Dictionnaire de démonstration : informations sur une ville marocaine ville_marrakech = { "nom": "Marrakech", "population": 928850, "superficie_km2": 230, "fondation": 1070, "altitude_m": 466, "monuments": ["Koutoubia", "Jemaa el-Fna", "Palais Bahia"] } print("? RÉCAPITULATIF DES MÉTHODES PRINCIPALES") print("="*50) # 1. Accès et recherche print("\n1. ? ACCÈS ET RECHERCHE:") print(f" .get('population'): {ville_marrakech.get('population')}") print(f" .get('inexistant', 'Valeur par défaut'): {ville_marrakech.get('inexistant', 'Valeur par défaut')}") print(f" 'nom' in ville_marrakech: {'nom' in ville_marrakech}") print(f" .keys(): {list(ville_marrakech.keys())}") print(f" .values(): {list(ville_marrakech.values())}") # 2. Modification print("\n2. ✏️ MODIFICATION:") ville_copie = ville_marrakech.copy() ville_copie["region"] = "Marrakech-Safi" ville_copie.update({"surnom": "Ville ocre", "climat": "Désertique"}) print(f" .update(): Ajout de surnom et climat") print(f" Nouvelles clés: {list(ville_copie.keys())}") # 3. Suppression print("\n3. ?️ SUPPRESSION:") ville_test = ville_marrakech.copy() valeur_supprimee = ville_test.pop("altitude_m") dernier_element = ville_test.popitem() print(f" .pop('altitude_m'): {valeur_supprimee}") print(f" .popitem(): {dernier_element}") print(f" Clés restantes: {list(ville_test.keys())}") # CAS PRATIQUE: Gestion d'un inventaire de produits artisanaux print("\n" + "="*50) print("?️ SYSTÈME DE GESTION ARTISANAL - COOPÉRATIVE ARGAN") print("="*50) inventaire_artisanal = { "ARG-001": {"produit": "Huile d'Argan Culinaire", "stock": 45, "prix": 180}, "ARG-002": {"produit": "Huile d'Argan Cosmétique", "stock": 32, "prix": 220}, "ARG-003": {"produit": "Amlou Traditionnel", "stock": 18, "prix": 120}, "ARG-004": {"produit": "Savon à l'Argan", "stock": 25, "prix": 45} } # Utilisation combinée des méthodes print("? ANALYSE DE L'INVENTAIRE:") # Vérification des produits disponibles produits_disponibles = [ infos["produit"] for infos in inventaire_artisanal.values() if infos["stock"] > 0 ] print(f" Produits en stock: {', '.join(produits_disponibles)}") # Calcul de la valeur totale valeur_totale = sum( infos["stock"] * infos["prix"] for infos in inventaire_artisanal.values() ) print(f" Valeur totale de l'inventaire: {valeur_totale} DH") # Produit le plus cher produit_plus_cher = max( inventaire_artisanal.items(), key=lambda item: item[1]["prix"] ) print(f" Produit le plus cher: {produit_plus_cher[1]['produit']} ({produit_plus_cher[1]['prix']} DH)") # Tableau récapitulatif des méthodes print("\n" + "-"*60) print("? TABLEAU RÉCAPITULATIF DES MÉTHODES") print("-"*60) methodes_principales = { ".clear()": "Vide le dictionnaire", ".copy()": "Retourne une copie superficielle", ".fromkeys()": "Crée un dict avec des clés et une valeur par défaut", ".get()": "Retourne la valeur ou une valeur par défaut", ".items()": "Retourne les paires clé-valeur", ".keys()": "Retourne les clés", ".pop()": "Supprime et retourne une valeur", ".popitem()": "Supprime et retourne la dernière paire", ".setdefault()": "Retourne la valeur ou l'initialise", ".update()": "Met à jour avec un autre dictionnaire", ".values()": "Retourne les valeurs" } for methode, description in methodes_principales.items(): print(f" {methode:<15} → {description}")
La méthode .copy() crée une copie superficielle du dictionnaire. C'est essentiel pour éviter les modifications accidentelles de l'original lorsqu'on travaille avec des copies.
# Dictionnaire original : informations sur un projet de développement projet_original = { "nom": "Station Noor Ouarzazate", "type": "Centrale solaire", "capacite_mw": 580, "investissement_mdh": 25000, "partenaires": ["MASEN", "ACWA Power", "Banque Mondiale"], "localisation": {"ville": "Ouarzazate", "region": "Drâa-Tafilalet"} } print("? MÉTHODE .copy() - COPIE SUPERFICIELLE") print("="*50) # DANGER : Assignation directe (référence, pas une copie) projet_reference = projet_original # Même objet en mémoire projet_reference["capacite_mw"] = 600 # Modifie l'original aussi! print(f"? Après modification via référence:") print(f" Original: {projet_original['capacite_mw']} MW") print(f" Référence: {projet_reference['capacite_mw']} MW") print(f" → L'original a été modifié!") # SOLUTION : Utilisation de .copy() projet_original["capacite_mw"] = 580 # Rétablir la valeur originale projet_copie = projet_original.copy() # Nouvel objet en mémoire projet_copie["capacite_mw"] = 600 print(f"\n✅ Après modification via .copy():") print(f" Original: {projet_original['capacite_mw']} MW") print(f" Copie: {projet_copie['capacite_mw']} MW") print(f" → L'original est préservé!") # LIMITATION : Copie superficielle (shallow copy) print(f"\n⚠️ LIMITATION - COPIE SUPERFICIELLE:") projet_copie["partenaires"].append("Union Européenne") projet_copie["localisation"]["pays"] = "Maroc" print(f" Partenaires original: {projet_original['partenaires']}") print(f" Partenaires copie: {projet_copie['partenaires']}") print(f" → Les objets imbriqués sont partagés!") # CAS PRATIQUE : Système de sauvegarde de configurations print("\n" + "="*50) print("? SYSTÈME DE SAUVEGARDE - PLATEFORME E-GOUVERNEMENT") print("="*50) configuration_originale = { "plateforme": "E-services Maroc", "version": "2.1.0", "parametres": { "langue": "fr", "timezone": "Africa/Casablanca", "devise": "MAD" }, "modules_actifs": ["authentification", "paiement", "documentation"] } # Création d'une sauvegarde print("? CRÉATION D'UNE SAUVEGARDE:") sauvegarde = configuration_originale.copy() # Modification de la sauvegarde pour tests sauvegarde["version"] = "2.1.0-TEST" sauvegarde["parametres"]["debug"] = True # Affecte l'original! print(f" Version originale: {configuration_originale['version']}") print(f" Version sauvegarde: {sauvegarde['version']}") print(f" Paramètres original: {configuration_originale['parametres']}") print(f" → Les paramètres imbriqués sont modifiés dans l'original!") # SOLUTION : Copie profonde (deep copy) import copy configuration_originale["parametres"].pop("debug", None) # Nettoyer sauvegarde_profonde = copy.deepcopy(configuration_originale) sauvegarde_profonde["parametres"]["debug"] = True print(f"\n✅ AVEC COPIE PROFONDE:") print(f" Paramètres original: {configuration_originale['parametres']}") print(f" Paramètres sauvegarde: {sauvegarde_profonde['parametres']}") print(f" → L'original est complètement préservé!")
La méthode .setdefault() est un outil puissant pour gérer les valeurs par défaut dans les dictionnaires. Elle retourne la valeur d'une clé si elle existe, sinon elle initialise la clé avec une valeur par défaut.
# Dictionnaire pour le suivi des ventes d'une coopérative ventes_cooperative = { "janvier": {"huile_argan": 150, "amlou": 45}, "février": {"huile_argan": 120, "savon": 30} } print("? MÉTHODE .setdefault() - VALEURS PAR DÉFAUT") print("="*50) # APPROCHE TRADITIONNELLE (verbose) print("\n1. APPROCHE TRADITIONNELLE:") if "mars" not in ventes_cooperative: ventes_cooperative["mars"] = {} ventes_mars = ventes_cooperative["mars"] if "huile_argan" not in ventes_mars: ventes_mars["huile_argan"] = 0 ventes_mars["huile_argan"] += 25 print(f" Ventes mars: {ventes_cooperative['mars']}") # APPROCHE AVEC .setdefault() (concise) print("\n2. APPROCHE AVEC .setdefault():") ventes_avril = ventes_cooperative.setdefault("avril", {}) ventes_avril.setdefault("huile_argan", 0) ventes_avril["huile_argan"] += 40 print(f" Ventes avril: {ventes_cooperative['avril']}") # APPROCHE ENCHAÎNÉE (très concise) print("\n3. APPROCHE ENCHAÎNÉE:") ventes_cooperative.setdefault("mai", {}).setdefault("huile_argan", 0) ventes_cooperative["mai"]["huile_argan"] += 35 print(f" Ventes mai: {ventes_cooperative['mai']}") # CAS PRATIQUE : Système de gestion des compétences print("\n" + "="*50) print("?? PLATEFORME DE COMPÉTENCES - TECHNOPARK MAROC") print("="*50) competences_employes = {} # Fonction pour ajouter une compétence à un employé def ajouter_competence(employe, competence, niveau=1): # Crée l'employé s'il n'existe pas, avec un dict vide competences_employe = competences_employes.setdefault(employe, {}) # Crée la compétence avec niveau 0 si elle n'existe pas, sinon garde l'ancienne valeur ancien_niveau = competences_employe.setdefault(competence, 0) # Met à jour seulement si le nouveau niveau est supérieur if niveau > ancien_niveau: competences_employe[competence] = niveau print(f" ✅ {employe} - {competence}: niveau {niveau}") else: print(f" ℹ️ {employe} - {competence}: niveau {ancien_niveau} (déjà supérieur)") # Ajout de compétences print("? AJOUT DE COMPÉTENCES:") ajouter_competence("Karim Alami", "Python", 3) ajouter_competence("Fatima Zahra", "JavaScript", 2) ajouter_competence("Karim Alami", "Data Science", 2) ajouter_competence("Fatima Zahra", "Python", 1) ajouter_competence("Karim Alami", "Python", 4) # Mise à jour ajouter_competence("Karim Alami", "Python", 2) # Niveau inférieur - ignoré # Affichage final print(f"\n? COMPÉTENCES FINALES:") for employe, competences in competences_employes.items(): print(f" ?? {employe}:") for competence, niveau in competences.items(): print(f" - {competence}: niveau {niveau}") # COMPARAISON : .setdefault() vs .get() print("\n" + "-"*40) print("? COMPARAISON .setdefault() vs .get()") print("-"*40) test_dict = {"existant": "valeur"} # Avec .get() - lecture seule valeur_get = test_dict.get("inexistant", "défaut") print(f" .get(): {valeur_get}") print(f" Dict après .get(): {test_dict}") # Avec .setdefault() - lecture/écriture valeur_setdefault = test_dict.setdefault("inexistant", "défaut") print(f" .setdefault(): {valeur_setdefault}") print(f" Dict après .setdefault(): {test_dict}")
La méthode de classe dict.fromkeys() permet de créer rapidement un nouveau dictionnaire à partir d'une séquence de clés, avec une valeur par défaut optionnelle pour toutes les clés.
# Création d'un dictionnaire pour le suivi des régions marocaines regions_maroc = [ "Casablanca-Settat", "Rabat-Salé-Kénitra", "Fès-Meknès", "Marrakech-Safi", "Tanger-Tétouan-Al Hoceïma", "Souss-Massa", "Beni Mellal-Khénifra", "Oriental", "Drâa-Tafilalet", "Guelmim-Oued Noun", "Laâyoune-Sakia El Hamra", "Dakhla-Oued Ed-Dahab" ] print("?️ MÉTHODE .fromkeys() - INITIALISATION RAPIDE") print("="*50) # APPROCHE MANUELLE (longue et répétitive) print("\n1. APPROCHE MANUELLE:") suivi_manuel = {} for region in regions_maroc: suivi_manuel[region] = {"projets": 0, "investissement": 0} print(f" Régions initialisées: {len(suivi_manuel)}") # APPROCHE AVEC .fromkeys() (concise) print("\n2. APPROCHE AVEC .fromkeys():") suivi_regions = dict.fromkeys(regions_maroc, {"projets": 0, "investissement": 0}) print(f" Régions initialisées: {len(suivi_regions)}") # DANGER : Même objet partagé pour toutes les valeurs! suivi_regions["Casablanca-Settat"]["projets"] = 5 print(f" ? Projets à Casablanca: {suivi_regions['Casablanca-Settat']['projets']}") print(f" ? Projets à Rabat: {suivi_regions['Rabat-Salé-Kénitra']['projets']}") print(f" → Toutes les régions partagent le même objet!") # SOLUTION : Utilisation avec une fonction pour créer de nouveaux objets print("\n3. SOLUTION AVEC FONCTION:") def nouveau_suivi(): return {"projets": 0, "investissement": 0} suivi_correct = {region: nouveau_suivi() for region in regions_maroc} suivi_correct["Casablanca-Settat"]["projets"] = 5 print(f" ✅ Projets à Casablanca: {suivi_correct['Casablanca-Settat']['projets']}") print(f" ✅ Projets à Rabat: {suivi_correct['Rabat-Salé-Kénitra']['projets']}") print(f" → Chaque région a son propre objet!") # CAS PRATIQUE : Système de réservation d'hôtels print("\n" + "="*50) print("? SYSTÈME DE RÉSERVATION - RÉSEAU HÔTELIER MAROCAIN") print("="*50) # Types de chambres disponibles types_chambres = ["Économique", "Standard", "Supérieure", "Suite"] # Initialisation rapide avec .fromkeys() pour les prix prix_chambres = dict.fromkeys(types_chambres, 0) print(f"? PRIX INITIAUX: {prix_chambres}") # Configuration des prix prix_chambres["Économique"] = 300 prix_chambres["Standard"] = 500 prix_chambres["Supérieure"] = 800 prix_chambres["Suite"] = 1200 print(f"? PRIX CONFIGURÉS: {prix_chambres}") # Initialisation des disponibilités pour plusieurs hôtels hotels = ["Mamounia", "Sofitel", "Hyatt", "Ibis"] disponibilites = {hotel: dict.fromkeys(types_chambres, 0) for hotel in hotels} print(f"\n? DISPONIBILITÉS INITIALES:") for hotel, chambres in disponibilites.items(): print(f" {hotel}: {chambres}") # Mise à jour des disponibilités disponibilites["Mamounia"] = {"Économique": 5, "Standard": 3, "Supérieure": 2, "Suite": 1} disponibilites["Sofitel"]["Standard"] = 8 print(f"\n? DISPONIBILITÉS ACTUALISÉES:") for hotel, chambres in disponibilites.items(): print(f" {hotel}: {chambres}") # UTILISATION AVANCÉE : Création de templates print("\n" + "-"*40) print("? CRÉATION DE TEMPLATES AVEC .fromkeys()") print("-"*40) # Template pour un nouveau produit champs_produit = ["nom", "prix", "stock", "categorie", "description"] template_produit = dict.fromkeys(champs_produit, None) print(f" Template produit: {template_produit}") # Remplissage du template nouveau_produit = template_produit.copy() nouveau_produit.update({ "nom": "Tapis Beni Ouarain", "prix": 2500, "stock": 3, "categorie": "Artisanat" }) print(f" Produit créé: {nouveau_produit}")
Les dictionnaires imbriqués permettent de créer des structures de données complexes en stockant des dictionnaires à l'intérieur d'autres dictionnaires. Cette technique est particulièrement utile pour représenter des données hiérarchiques ou des structures relationnelles.
Les dictionnaires imbriqués permettent de modéliser des relations complexes entre différentes entités. Voici comment créer et initialiser ces structures :
# Exemple 1: Structure d'une université marocaine universite_maroc = { "nom": "Université Mohammed V de Rabat", "ville": "Rabat", "facultes": { "droit": { "doyen": "Pr. Ahmed Benani", "etudiants": 2500, "specialites": ["Droit Privé", "Droit Public", "Sciences Politiques"] }, "medecine": { "doyen": "Pr. Leila El Fassi", "etudiants": 1800, "specialites": ["Médecine Générale", "Chirurgie", "Pédiatrie"] } } } # Exemple 2: Structure d'un système de gestion d'hôtels marocains hotels_maroc = { "marrakech": { "Mamounia": { "etoiles": 5, "chambres": 231, "prix_nuit": 2500, "services": ["SPA", "Piscine", "Golf"] }, "La Sultana": { "etoiles": 5, "chambres": 28, "prix_nuit": 1800, "services": ["SPA", "Toit terrasse", "Restaurant gastronomique"] } }, "casablanca": { "Four Seasons": { "etoiles": 5, "chambres": 186, "prix_nuit": 2200, "services": ["SPA", "Centre d'affaires", "Piscine intérieure"] } } } # Exemple 3: Création progressive d'un dictionnaire imbriqué systeme_sante_maroc = {} # Ajout progressif des données systeme_sante_maroc["hopitaux"] = {} systeme_sante_maroc["hopitaux"]["CHU Ibn Sina"] = { "ville": "Rabat", "lits": 850, "specialites": ["Cardiologie", "Neurologie", "Pédiatrie"] } systeme_sante_maroc["hopitaux"]["CHU Hassan II"] = { "ville": "Fès", "lits": 720, "specialites": ["Oncologie", "Chirurgie", "Médecine interne"] } print("Structure de l'université:", universite_maroc["nom"]) print("Nombre d'étudiants en médecine:", universite_maroc["facultes"]["medecine"]["etudiants"])
L'accès aux données dans les dictionnaires imbriqués nécessite une chaîne d'accès qui traverse chaque niveau de la structure. Il est important de gérer les cas où certaines clés pourraient être manquantes.
# Structure d'exemple: système de transport marocain transport_maroc = { "trains": { "ONCF": { "Al Boraq": { "vitesse": "320 km/h", "ligne": "Tanger-Casablanca", "prix_billet": { "premiere": 300, "seconde": 180 } }, "Navette Rapide": { "vitesse": "160 km/h", "ligne": "Casablanca-Rabat" } } }, "bus": { "CTM": { "reseau": "National", "destinations": ["Marrakech", "Agadir", "Fès", "Tanger"] } } } # Méthode 1: Accès direct (risqué si les clés n'existent pas) vitesse_boraq = transport_maroc["trains"]["ONCF"]["Al Boraq"]["vitesse"] print(f"Vitesse d'Al Boraq: {vitesse_boraq}") # Méthode 2: Accès sécurisé avec .get() prix_premiere = transport_maroc.get("trains", {}).get("ONCF", {}).get("Al Boraq", {}).get("prix_billet", {}).get("premiere", "Non disponible") print(f"Prix première classe: {prix_premiere} DH") # Méthode 3: Fonction utilitaire pour accès sécurisé def acces_securise(dictionnaire, *cles): """Accède de manière sécurisée à un élément imbriqué""" resultat = dictionnaire for cle in cles: if isinstance(resultat, dict) and cle in resultat: resultat = resultat[cle] else: return None return resultat # Utilisation de la fonction utilitaire ligne_navette = acces_securise(transport_maroc, "trains", "ONCF", "Navette Rapide", "ligne") print(f"Ligne de la navette: {ligne_navette}") # Modification d'éléments imbriqués transport_maroc["trains"]["ONCF"]["Al Boraq"]["prix_billet"]["premiere"] = 320 # Augmentation de prix # Parcours des éléments imbriqués print("\n--- Tous les trains ONCF ---") for nom_train, infos in transport_maroc["trains"]["ONCF"].items(): print(f"Train: {nom_train}") print(f" Vitesse: {infos.get('vitesse', 'Non spécifiée')}") print(f" Ligne: {infos.get('ligne', 'Non spécifiée')}")
Les dictionnaires imbriqués sont particulièrement utiles dans plusieurs scénarios réels. Voici quelques applications pratiques avec des données marocaines :
# CAS 1: Système de gestion d'étudiants universitaires universite_casablanca = { "etudiants": { "E1001": { "nom": "Youssef Alaoui", "filiere": "Informatique", "notes": { "algorithmique": 16.5, "base_de_donnees": 14.0, "reseaux": 15.5 }, "contact": { "telephone": "0612345678", "email": "y.alaoui@etu.univ-casa.ma" } }, "E1002": { "nom": "Fatima Zahra Benani", "filiere": "Médecine", "notes": { "anatomie": 17.0, "physiologie": 16.0, "biochimie": 15.5 } } } } # Fonction pour calculer la moyenne d'un étudiant def calculer_moyenne(id_etudiant): etudiant = universite_casablanca["etudiants"].get(id_etudiant) if etudiant and "notes" in etudiant: notes = etudiant["notes"].values() return sum(notes) / len(notes) return None # CAS 2: Catalogue de produits d'une entreprise marocaine entreprise_marocaine = { "Maroc Telecom": { "forfaits_mobile": { "Jawal Start": { "prix": 49, "internet": "5 Go", "appels": "Illimités" }, "Jawal Pro": { "prix": 99, "internet": "20 Go", "appels": "Illimités" } }, "forfaits_internet": { "Fibre 50M": { "prix": 299, "debit": "50 Mbps" } } } } # Fonction pour trouver le forfait le plus économique avec un minimum de données def forfait_economique(min_data=10): forfaits = entreprise_marocaine["Maroc Telecom"]["forfaits_mobile"] forfaits_filtres = {} for nom, details in forfaits.items(): data_go = int(details["internet"].split()[0]) if data_go >= min_data: forfaits_filtres[nom] = details if forfaits_filtres: return min(forfaits_filtres.items(), key=lambda x: x[1]["prix"]) return None # CAS 3: Système de réservation d'hôtels avec disponibilités reservation_hotels = { "hotels": { "Sofitel Marrakech": { "chambres": { "standard": { "prix": 800, "disponibilite": { "2024-01-15": 5, "2024-01-16": 3 } }, "suite": { "prix": 1500, "disponibilite": { "2024-01-15": 2, "2024-01-16": 1 } } } } } } # Utilisation des cas pratiques print("=== Gestion Universitaire ===") print(f"Moyenne de Youssef: {calculer_moyenne('E1001'):.2f}") print("\n=== Forfaits Télécom ===") forfait_eco = forfait_economique(10) if forfait_eco: nom, details = forfait_eco print(f"Forfait économique: {nom} - {details['prix']} DH/mois") print("\n=== Réservation Hôtels ===") dispo_suite = reservation_hotels["hotels"]["Sofitel Marrakech"]["chambres"]["suite"]["disponibilite"]["2024-01-15"] print(f"Suites disponibles le 2024-01-15: {dispo_suite}")
Les compréhensions de dictionnaires permettent de créer des dictionnaires de manière concise et élégante en une seule ligne de code. Elles suivent le même principe que les compréhensions de listes mais produisent des dictionnaires avec des paires clé-valeur.
La syntaxe de base d'une compréhension de dictionnaire est : {clé: valeur for élément in itérable}. Elle permet de transformer et de filtrer des données efficacement.
# EXEMPLE 1: Création simple à partir d'une liste villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] # Créer un dictionnaire avec la ville comme clé et sa longueur comme valeur longueurs_villes = {ville: len(ville) for ville in villes_maroc} print("Longueurs des noms de villes:", longueurs_villes) # EXEMPLE 2: Transformation de données avec calcul produits_maroc = ["huile d'olive", "dattes", "safran", "argan"] prix_base = {"huile d'olive": 50, "dattes": 30, "safran": 200, "argan": 80} # Appliquer une augmentation de 10% sur tous les prix prix_augmentes = {produit: prix * 1.1 for produit, prix in prix_base.items()} print("Prix après augmentation:", prix_augmentes) # EXEMPLE 3: Inversion clé-valeur d'un dictionnaire codes_regions = { "Casablanca-Settat": "06", "Rabat-Salé-Kénitra": "04", "Marrakech-Safi": "07", "Fès-Meknès": "03" } # Inverser les clés et les valeurs regions_par_code = {code: region for region, code in codes_regions.items()} print("Régions par code:", regions_par_code) # EXEMPLE 4: Création à partir de deux listes avec zip universites = ["UM5", "UIZ", "UH2", "UCA"] villes_univ = ["Rabat", "Agadir", "Casablanca", "Marrakech"] # Associer chaque université à sa ville localisation_universites = {univ: ville for univ, ville in zip(universites, villes_univ)} print("Localisation des universités:", localisation_universites) # EXEMPLE 5: Transformation de chaînes de caractères noms_complets = ["Ahmed Alami", "Fatima Zahra", "Karim Bennani", "Leila Mourad"] # Créer un dictionnaire avec prénom comme clé et nom complet comme valeur index_par_prenom = {nom.split()[0]: nom for nom in noms_complets} print("Index par prénom:", index_par_prenom)
Les compréhensions de dictionnaires peuvent inclure des conditions pour filtrer les éléments. On peut utiliser des conditions dans la partie itération et/ou dans l'expression des valeurs.
# EXEMPLE 1: Filtrage avec condition simple temperatures_villes = { "Casablanca": 28, "Ifrane": 15, "Marrakech": 35, "Tanger": 25, "Ouarzazate": 38 } # Filtrer les villes avec température supérieure à 25°C villes_chaudes = {ville: temp for ville, temp in temperatures_villes.items() if temp > 25} print("Villes chaudes (>25°C):", villes_chaudes) # EXEMPLE 2: Condition multiple entreprises_maroc = { "Maroc Telecom": {"secteur": "Télécom", "employes": 12000}, "OCP": {"secteur": "Mines", "employes": 21000}, "Attijariwafa Bank": {"secteur": "Banque", "employes": 15000}, "Cosumar": {"secteur": "Agroalimentaire", "employes": 5000} } # Entreprises avec plus de 10000 employés ET dans certains secteurs grandes_entreprises = { nom: info for nom, info in entreprises_maroc.items() if info["employes"] > 10000 and info["secteur"] in ["Télécom", "Mines", "Banque"] } print("Grandes entreprises filtrées:", grandes_entreprises) # EXEMPLE 3: Condition dans l'expression de valeur produits_stock = { "dattes": 150, "amandes": 45, "figues": 0, "noix": 80, "raisins secs": 0 } # Marquer les produits en rupture de stock statut_stock = { produit: "EN STOCK" if quantite > 0 else "RUPTURE" for produit, quantite in produits_stock.items() } print("Statut du stock:", statut_stock) # EXEMPLE 4: Condition complexe avec opérateur ternaire scores_etudiants = { "Ahmed": 16.5, "Fatima": 12.0, "Karim": 18.0, "Leila": 9.5, "Youssef": 14.5 } # Classer les étudiants avec mention mentions_etudiants = { nom: "Excellent" if score >= 16 else "Bien" if score >= 14 else "Passable" if score >= 10 else "Échec" for nom, score in scores_etudiants.items() } print("Mentions des étudiants:", mentions_etudiants) # EXEMPLE 5: Filtrage par longueur de chaîne quartiers_casablanca = ["Maârif", "Anfa", "Ain Diab", "Hay Hassani", "Sidi Belyout"] # Garder seulement les quartiers avec des noms courts (moins de 8 caractères) quartiers_courts = {quartier: len(quartier) for quartier in quartiers_casablanca if len(quartier) < 8} print("Quartiers aux noms courts:", quartiers_courts)
Les compréhensions de dictionnaires sont particulièrement utiles pour transformer et restructurer des données dans des scénarios réels. Voici des exemples concrets appliqués au contexte marocain.
# EXEMPLE 1: Transformation de données d'étudiants etudiants_maroc = [ {"nom": "Alaoui", "prenom": "Ahmed", "filiere": "Informatique", "moyenne": 15.5}, {"nom": "Benani", "prenom": "Fatima", "filiere": "Médecine", "moyenne": 17.0}, {"nom": "Cherkaoui", "prenom": "Karim", "filiere": "Ingénierie", "moyenne": 14.0}, {"nom": "El Fassi", "prenom": "Leila", "filiere": "Droit", "moyenne": 16.5} ] # Transformer en dictionnaire indexé par nom complet etudiants_par_nom = { f"{etudiant['prenom']} {etudiant['nom']}": { "filiere": etudiant["filiere"], "moyenne": etudiant["moyenne"], "mention": "Admis" if etudiant["moyenne"] >= 10 else "Redouble" } for etudiant in etudiants_maroc } print("Étudiants par nom:", etudiants_par_nom) # EXEMPLE 2: Agrégation de données de ventes ventes_trimestrielles = [ {"produit": "huile d'argan", "trimestre": "Q1", "ventes": 1200}, {"produit": "huile d'argan", "trimestre": "Q2", "ventes": 1500}, {"produit": "dattes", "trimestre": "Q1", "ventes": 800}, {"produit": "dattes", "trimestre": "Q2", "ventes": 950}, {"produit": "safran", "trimestre": "Q1", "ventes": 300}, {"produit": "safran", "trimestre": "Q2", "ventes": 450} ] # Calculer les ventes totales par produit ventes_par_produit = { produit: sum(vente["ventes"] for vente in ventes_trimestrielles if vente["produit"] == produit) for produit in set(vente["produit"] for vente in ventes_trimestrielles) } print("Ventes totales par produit:", ventes_par_produit) # EXEMPLE 3: Normalisation de données géographiques villes_data = [ {"nom": "casablanca", "population": 3350000, "region": "casablanca-settat"}, {"nom": "rabat", "population": 577000, "region": "rabat-sale-kenitra"}, {"nom": "marrakech", "population": 928000, "region": "marrakech-safi"}, {"nom": "fes", "population": 1112000, "region": "fes-meknes"} ] # Normaliser les noms et créer un index structuré villes_normalisees = { ville["nom"].title(): { "population": ville["population"], "region": ville["region"].title().replace("-", " "), "categorie": "Métropole" if ville["population"] > 1000000 else "Grande ville" } for ville in villes_data } print("Villes normalisées:", villes_normalisees) # EXEMPLE 4: Transformation pour analyse statistique donnees_economiques = { "Maroc Telecom": {"chiffre_affaires": 35000, "employes": 12000, "secteur": "Télécom"}, "OCP": {"chiffre_affaires": 85000, "employes": 21000, "secteur": "Mines"}, "Attijariwafa Bank": {"chiffre_affaires": 28000, "employes": 15000, "secteur": "Banque"} } # Calculer des métriques de performance metriques_entreprises = { entreprise: { "CA_par_employe": donnees["chiffre_affaires"] / donnees["employes"], "taille": "Grande" if donnees["employes"] > 15000 else "Moyenne", "performance": "Élevée" if donnees["chiffre_affaires"] / donnees["employes"] > 2 else "Standard" } for entreprise, donnees in donnees_economiques.items() } print("Métriques des entreprises:", metriques_entreprises) # EXEMPLE 5: Préparation de données pour visualisation temperatures_annuelles = { "Casablanca": [18, 19, 20, 22, 24, 26, 28, 28, 26, 24, 21, 19], "Marrakech": [20, 22, 25, 28, 32, 36, 38, 38, 34, 29, 24, 21], "Ifrane": [5, 6, 8, 11, 15, 19, 22, 22, 18, 14, 9, 6] } # Calculer les températures extrêmes par ville extremes_temperature = { ville: { "max": max(temperatures), "min": min(temperatures), "moyenne": sum(temperatures) / len(temperatures), "amplitude": max(temperatures) - min(temperatures) } for ville, temperatures in temperatures_annuelles.items() } print("Extrêmes de température:", extremes_temperature)
Maîtriser les dictionnaires Python va au-delà de la simple syntaxe. Adopter les bonnes pratiques et connaître les astuces avancées permet d'écrire du code plus robuste, efficace et maintenable.
Les KeyError surviennent lorsqu'on tente d'accéder à une clé inexistante dans un dictionnaire. Plusieurs techniques permettent de les éviter proprement.
# Dictionnaire des produits marocains et leurs prix produits_maroc = { "huile d'argan": 150, "dattes": 80, "safran": 250, "couscous": 40 } # MÉTHODE 1: Utilisation de try/except (Pythonique) def get_prix_securise(produit): try: return produits_maroc[produit] except KeyError: return None # MÉTHODE 2: Utilisation de .get() avec valeur par défaut prix_argan = produits_maroc.get("huile d'argan", 0) prix_the = produits_maroc.get("thé à la menthe", "Non disponible") # MÉTHODE 3: Vérification avec 'in' avant accès if "dattes" in produits_maroc: prix_dattes = produits_maroc["dattes"] else: prix_dattes = 0 # MÉTHODE 4: Utilisation de setdefault() # Retourne la valeur si la clé existe, sinon l'ajoute avec la valeur par défaut prix_olives = produits_maroc.setdefault("olives", 25) # MÉTHODE 5: defaultdict pour éviter complètement les KeyError from collections import defaultdict def prix_par_defaut(): return "Prix non défini" produits_default = defaultdict(prix_par_defaut, produits_maroc) prix_inexistant = produits_default["produit_imaginaire"] # Pas d'erreur! # MÉTHODE 6: Gestion avancée avec contexte personnalisé class GestionnaireProduits: def __init__(self, produits): self.produits = produits def obtenir_prix(self, nom_produit, defaut=None): prix = self.produits.get(nom_produit, defaut) if prix is None: print(f"⚠️ Produit '{nom_produit}' non trouvé dans le catalogue") return prix # Utilisation gestionnaire = GestionnaireProduits(produits_maroc) print("Prix safran:", gestionnaire.obtenir_prix("safran")) print("Prix thé:", gestionnaire.obtenir_prix("thé à la menthe")) print("\n=== Résultats des différentes méthodes ===") print(f"Méthode .get(): {prix_the}") print(f"Méthode setdefault(): {prix_olives}") print(f"DefaultDict: {prix_inexistant}")
Depuis Python 3.7, les dictionnaires maintiennent l'ordre d'insertion par défaut. Pour un contrôle plus avancé, on peut utiliser OrderedDict du module collections.
# EXEMPLE 1: Dictionnaires natifs (Python 3.7+) # Les dictionnaires maintiennent l'ordre d'insertion regions_maroc = {} regions_maroc["Casablanca-Settat"] = "Économique" regions_maroc["Rabat-Salé-Kénitra"] = "Administrative" regions_maroc["Marrakech-Safi"] = "Touristique" regions_maroc["Fès-Meknès"] = "Culturelle" print("Régions dans l'ordre d'insertion:") for region, type_region in regions_maroc.items(): print(f" - {region}: {type_region}") # EXEMPLE 2: Utilisation de OrderedDict pour des opérations spécifiques from collections import OrderedDict # Création d'un chronogramme des événements au Maroc evenements_maroc = OrderedDict() evenements_maroc["Fête du Trône"] = "30 Juillet" evenements_maroc["Anniversaire du Roi"] = "21 Août" evenements_maroc["Fête de la Révolution"] = "20 Août" evenements_maroc["Aïd al-Fitr"] = "Variable (Lunaire)" print("\nÉvénements dans l'ordre:") for i, (evenement, date) in enumerate(evenements_maroc.items(), 1): print(f" {i}. {evenement}: {date}") # EXEMPLE 3: Réorganisation avec OrderedDict # Recréer l'OrderedDict dans un ordre différent evenements_ordonnes = OrderedDict( sorted(evenements_maroc.items(), key=lambda x: x[1]) # Trier par date ) print("\nÉvénements triés par date:") for evenement, date in evenements_ordonnes.items(): print(f" - {evenement}: {date}") # EXEMPLE 4: Fonctionnalités spécifiques à OrderedDict plan_development = OrderedDict() plan_development["Phase 1"] = "Infrastructure" plan_development["Phase 2"] = "Éducation" plan_development["Phase 3"] = "Santé" plan_development["Phase 4"] = "Environnement" # Déplacer un élément à la fin plan_development.move_to_end("Phase 1") # Obtenir le premier et dernier élément premiere_phase = next(iter(plan_development)) derniere_phase = next(reversed(plan_development)) print(f"\nPlan de développement - Première: {premiere_phase}, Dernière: {derniere_phase}") # EXEMPLE 5: Comparaison avec les dictionnaires natifs dict_natif = {"a": 1, "b": 2, "c": 3} ordered_dict = OrderedDict([("a", 1), ("b", 2), ("c", 3)]) # Les deux maintiennent l'ordre, mais OrderedDict offre plus de contrôle print("\nComparaison:") print(f"Dict natif garde l'ordre: {{k: v for k, v in dict_natif.items()}}") print(f"OrderedDict: {dict(ordered_dict)}")
La performance des dictionnaires est cruciale pour les applications à grande échelle. Voici les meilleures pratiques pour optimiser leur utilisation.
# EXEMPLE 1: Choix des clés pour optimiser le hachage import time # Mauvais: tuples complexes comme clés mauvaises_cles = { ("Maroc", "Casablanca", "Derb Sultan", "Rue 45", "Appt 12"): "Client A", ("Maroc", "Rabat", "Agdal", "Avenue Hassan II", "Villa 8"): "Client B" } # Bon: identifiants simples comme clés bonnes_cles = { "CLI001": {"nom": "Client A", "ville": "Casablanca", "adresse": "Derb Sultan, Rue 45, Appt 12"}, "CLI002": {"nom": "Client B", "ville": "Rabat", "adresse": "Agdal, Avenue Hassan II, Villa 8"} } # Test de performance debut = time.time() for _ in range(10000): _ = mauvaises_cles.get(("Maroc", "Casablanca", "Derb Sultan", "Rue 45", "Appt 12")) temps_mauvais = time.time() - debut debut = time.time() for _ in range(10000): _ = bonnes_cles.get("CLI001") temps_bon = time.time() - début print(f"Temps avec clés complexes: {temps_mauvais:.4f}s") print(f"Temps avec clés simples: {temps_bon:.4f}s") print(f"Ratio: {temps_mauvais/temps_bon:.1f}x plus rapide avec clés simples") # EXEMPLE 2: Pré-allocation de mémoire pour les grands dictionnaires # Mauvais: ajout séquentiel dans un petit dictionnaire villes_maroc_petit = {} for i in range(1000): villes_maroc_petit[f"ville_{i}"] = i * 1000 # Bon: pré-allocation avec la taille estimée villes_maroc_grand = {f"ville_{i}": i * 1000 for i in range(1000)} # EXEMPLE 3: Utilisation de frozenset pour les clés complexes # Pour représenter des ensembles de villes comme clés region_cotiere = frozenset(["Casablanca", "Rabat", "Tanger", "Agadir"]) region_interieure = frozenset(["Fès", "Meknès", "Marrakech", "Oujda"]) statistiques_regions = { region_cotiere: {"population": 8500000, "PIB": 450}, region_interieure: {"population": 6200000, "PIB": 280} } # EXEMPLE 4: Optimisation des recherches avec des dictionnaires multiples # Structure pour recherche rapide multi-critères entreprises_index = { "par_nom": { "Maroc Telecom": {"id": 1, "secteur": "Télécom"}, "OCP": {"id": 2, "secteur": "Mines"} }, "par_secteur": { "Télécom": [1], "Mines": [2] }, "par_id": { 1: "Maroc Telecom", 2: "OCP" } } # Recherche ultra-rapide dans toutes les dimensions def recherche_entreprise(nom=None, secteur=None, id_ent=None): if nom and nom in entreprises_index["par_nom"]: return entreprises_index["par_nom"][nom] elif secteur and secteur in entreprises_index["par_secteur"]: ids = entreprises_index["par_secteur"][secteur] return [entreprises_index["par_nom"][entreprises_index["par_id"][id_ent]] for id_ent in ids] elif id_ent and id_ent in entreprises_index["par_id"]: nom_ent = entreprises_index["par_id"][id_ent] return entreprises_index["par_nom"][nom_ent] return None # EXEMPLE 5: Utilisation de __slots__ pour les objets dictionnaire-like class VilleMarocaine: __slots__ = ['nom', 'population', 'region', 'altitude'] def __init__(self, nom, population, region, altitude=0): self.nom = nom self.population = population self.region = region self.altitude = altitude def to_dict(self): return {attr: getattr(self, attr) for attr in self.__slots__} # Moins de mémoire utilisée que pour un dictionnaire classique casablanca = VilleMarocaine("Casablanca", 3350000, "Casablanca-Settat") print(f"\nVille avec __slots__: {casablanca.to_dict()}")
Bien que les dictionnaires soient polyvalents, ils ne sont pas toujours la meilleure solution. Voici les cas où d'autres structures de données sont plus appropriées.
# CAS 1: Données séquentielles avec accès par index # MAUVAIS: Utiliser un dictionnaire avec des clés numériques jours_mauvais = {0: "Lundi", 1: "Mardi", 2: "Mercredi"} # BON: Utiliser une liste jours_bon = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"] # CAS 2: Besoin de maintenir l'ordre ET des opérations complexes # MAUVAIS: Dictionnaire pour une file d'attente file_attente_mauvaise = { "client1": "Ahmed", "client2": "Fatima", "client3": "Karim" } # BON: Utiliser deque depuis collections from collections import deque file_attente_bonne = deque(["Ahmed", "Fatima", "Karim"]) file_attente_bonne.append("Leila") # Ajout efficace prochain_client = file_attente_bonne.popleft() # Retrait efficace # CAS 3: Stockage de données avec beaucoup de doublons # MAUVAIS: Dictionnaire pour compter les occurrences ventes_mauvais = { "Casablanca": 150, "Rabat": 89, "Marrakech": 120, "Fès": 75, "Tanger": 95, "Agadir": 110 } # BON: Utiliser Counter pour les comptages from collections import Counter ventes = ["Casablanca", "Rabat", "Marrakech", "Casablanca", "Fès"] * 100 compteur_ventes = Counter(ventes) print("Ventes par ville:", compteur_ventes) # CAS 4: Structures de données imbriquées complexes # MAUVAIS: Dictionnaires trop profondément imbriqués structure_mauvaise = { "Maroc": { "Casablanca": { "habitants": { "2020": 3350000, "2021": { "estimation": 3400000, "officiel": 3380000 } } } } } # BON: Utiliser des classes ou dataclasses from dataclasses import dataclass @dataclass class Population: annee: int estimation: int officiel: int = None @dataclass class Ville: nom: str populations: list casablanca = Ville( nom="Casablanca", populations=[ Population(annee=2020, estimation=3350000, officiel=3350000), Population(annee=2021, estimation=3400000, officiel=3380000) ] ) # CAS 5: Données avec relations complexes (graphes) # MAUVAIS: Représenter un graphe avec des dictionnaires imbriqués reseau_routier_mauvais = { "Casablanca": {"Rabat": 90, "Marrakech": 240}, "Rabat": {"Casablanca": 90, "Fès": 200}, "Marrakech": {"Casablanca": 240, "Agadir": 230} } # BON: Utiliser une bibliothèque spécialisée comme networkx import networkx as nx G = nx.Graph() G.add_edge("Casablanca", "Rabat", weight=90) G.add_edge("Casablanca", "Marrakech", weight=240) G.add_edge("Rabat", "Fès", weight=200) G.add_edge("Marrakech", "Agadir", weight=230) # Algorithmes de graphe disponibles chemin_court = nx.shortest_path(G, "Casablanca", "Agadir", weight='weight') print(f"Chemin le plus court: {chemin_court}") # CAS 6: Données tabulaires simples # MAUVAIS: Liste de dictionnaires pour des données tabulaires employes_mauvais = [ {"nom": "Alaoui", "prenom": "Ahmed", "salaire": 15000}, {"nom": "Benani", "prenom": "Fatima", "salaire": 18000} ] # BON: Utiliser pandas pour l'analyse de données import pandas as pd employes_bon = pd.DataFrame([ {"nom": "Alaoui", "prenom": "Ahmed", "salaire": 15000}, {"nom": "Benani", "prenom": "Fatima", "salaire": 18000} ]) print(f"\nDataFrame des employés:\n{employes_bon}") print(f"Salaire moyen: {employes_bon['salaire'].mean()} DH")
Ces exercices vous permettront de mettre en pratique toutes les notions vues sur les dictionnaires Python. Chaque exercice est inspiré de situations réelles que vous pourrez rencontrer dans vos projets.
Créez un système de gestion de carnet d'adresses pour une entreprise marocaine. Vous devrez implémenter des fonctionnalités d'ajout, de recherche, de modification et de suppression de contacts.
# EXERCICE 1: GESTION D'UN CARNET D'ADRESSES # Créez un système de gestion de contacts pour une entreprise marocaine # DONNÉES DE DÉPART carnet_adresses = { "C001": { "nom": "Alaoui", "prenom": "Ahmed", "telephone": "0612345678", "email": "a.alaoui@entreprise.ma", "ville": "Casablanca", "entreprise": "Maroc Telecom" }, "C002": { "nom": "Benani", "prenom": "Fatima", "telephone": "0623456789", "email": "f.benani@ocpgroup.ma", "ville": "Rabat", "entreprise": "OCP" } } # FONCTIONS À IMPLÉMENTER def ajouter_contact(carnet, contact_id, nom, prenom, telephone, email, ville, entreprise): """ Ajoute un nouveau contact au carnet d'adresses. Retourne True si l'ajout est réussi, False si l'ID existe déjà. """ # VOTRE CODE ICI if contact_id in carnet: print(f"Erreur: L'ID {contact_id} existe déjà.") return False carnet[contact_id] = { "nom": nom, "prenom": prenom, "telephone": telephone, "email": email, "ville": ville, "entreprise": entreprise } print(f"Contact {prenom} {nom} ajouté avec succès.") return True def rechercher_contact(carnet, **criteria): """ Recherche des contacts selon différents critères. Retourne un dictionnaire des contacts correspondants. """ # VOTRE CODE ICI resultats = {} for contact_id, infos in carnet.items(): correspond = True for critere, valeur in criteria.items(): if infos.get(critere) != valeur: correspond = False break if correspond: resultats[contact_id] = infos return resultats def modifier_contact(carnet, contact_id, **modifications): """ Modifie les informations d'un contact existant. Retourne True si la modification est réussie, False si le contact n'existe pas. """ # VOTRE CODE ICI if contact_id not in carnet: print(f"Erreur: Contact {contact_id} non trouvé.") return False for champ, nouvelle_valeur in modifications.items(): if champ in carnet[contact_id]: carnet[contact_id][champ] = nouvelle_valeur print(f"Contact {contact_id} modifié avec succès.") return True def supprimer_contact(carnet, contact_id): """ Supprime un contact du carnet d'adresses. Retourne True si la suppression est réussie, False si le contact n'existe pas. """ # VOTRE CODE ICI if contact_id not in carnet: print(f"Erreur: Contact {contact_id} non trouvé.") return False nom_supprime = carnet[contact_id]["prenom"] + " " + carnet[contact_id]["nom"] del carnet[contact_id] print(f"Contact {nom_supprime} supprimé avec succès.") return True def statistiques_carnet(carnet): """ Affiche des statistiques sur le carnet d'adresses. - Nombre total de contacts - Nombre de contacts par ville - Nombre de contacts par entreprise """ # VOTRE CODE ICI stats = { "total": len(carnet), "par_ville": {}, "par_entreprise": {} } for contact in carnet.values(): ville = contact["ville"] entreprise = contact["entreprise"] stats["par_ville"][ville] = stats["par_ville"].get(ville, 0) + 1 stats["par_entreprise"][entreprise] = stats["par_entreprise"].get(entreprise, 0) + 1 return stats # TESTS ET VALIDATION print("=== TEST EXERCICE 1 ===") # Test d'ajout ajouter_contact(carnet_adresses, "C003", "Cherkaoui", "Karim", "0634567890", "k.cherkaoui@attijari.ma", "Casablanca", "Attijariwafa Bank") # Test de recherche contacts_casablanca = rechercher_contact(carnet_adresses, ville="Casablanca") print(f"Contacts à Casablanca: {{k: v['prenom'] for k, v in contacts_casablanca.items()}}") # Test de modification modifier_contact(carnet_adresses, "C001", telephone="0611223344", email="ahmed.alaoui@maroctelecom.ma") # Test de statistiques stats = statistiques_carnet(carnet_adresses) print(f"Statistiques: {stats}") # Affichage final print(f"\nCarnet final ({len(carnet_adresses)} contacts):") for contact_id, infos in carnet_adresses.items(): print(f" {contact_id}: {infos['prenom']} {infos['nom']} - {infos['ville']}")
Analysez différents jeux de données pour compter les occurrences d'éléments. Cet exercice vous permettra de maîtriser les techniques de comptage et d'analyse de fréquence.
# EXERCICE 2: COMPTAGE DE FRÉQUENCE # Analysez différents jeux de données pour compter les occurrences # DONNÉES DE DÉPART ventes_produits = [ "huile d'argan", "dattes", "safran", "huile d'argan", "couscous", "dattes", "thé à la menthe", "huile d'argan", "safran", "dattes", "huile d'argan", "couscous", "dattes", "thé à la menthe", "safran" ] notes_etudiants = [ {"nom": "Alaoui", "prenom": "Ahmed", "note": 16}, {"nom": "Benani", "prenom": "Fatima", "note": 14}, {"nom": "Cherkaoui", "prenom": "Karim", "note": 18}, {"nom": "El Fassi", "prenom": "Leila", "note": 12}, {"nom": "Mourad", "prenom": "Youssef", "note": 16}, {"nom": "Zahra", "prenom": "Nadia", "note": 14}, {"nom": "Bennani", "prenom": "Mehdi", "note": 10} ] texte_marocain = """ Le Maroc est un pays magnifique avec une culture riche et diverse. Les villes comme Marrakech, Fès et Casablanca attirent des touristes du monde entier. La cuisine marocaine est réputée pour ses saveurs uniques et ses épices comme le safran et le cumin. """ # FONCTIONS À IMPLÉMENTER def compter_occurrences_liste(liste): """ Compte les occurrences de chaque élément dans une liste. Retourne un dictionnaire {élément: nombre_d_occurrences}. """ # VOTRE CODE ICI compteur = {} for element in liste: compteur[element] = compteur.get(element, 0) + 1 return compteur def compter_occurrences_texte(texte): """ Compte les occurrences de chaque mot dans un texte. Ignore la casse et la ponctuation. Retourne un dictionnaire {mot: nombre_d_occurrences}. """ # VOTRE CODE ICI # Nettoyer le texte ponctuation = ".,!?;:" texte_propre = texte.lower() for p in ponctuation: texte_propre = texte_propre.replace(p, "") mots = texte_propre.split() return compter_occurrences_liste(mots) def analyser_notes_etudiants(etudiants): """ Analyse les notes des étudiants et retourne un dictionnaire avec: - moyenne de la classe - note maximale et minimale - nombre d'étudiants par mention (Échec, Passable, Bien, Excellent) """ # VOTRE CODE ICI notes = [etudiant["note"] for etudiant in etudiants] analyse = { "moyenne": sum(notes) / len(notes), "max": max(notes), "min": min(notes), "mentions": { "Échec": 0, "Passable": 0, "Bien": 0, "Excellent": 0 } } for note in notes: if note < 10: analyse["mentions"]["Échec"] += 1 elif note < 12: analyse["mentions"]["Passable"] += 1 elif note < 16: analyse["mentions"]["Bien"] += 1 else: analyse["mentions"]["Excellent"] += 1 return analyse def trouver_plus_frequent(compteur): """ Trouve l'élément le plus fréquent dans un dictionnaire de comptage. Retourne un tuple (élément, nombre_d_occurrences). """ # VOTRE CODE ICI if not compteur: return (None, 0) element_max = max(compteur, key=compteur.get) return (element_max, compteur[element_max]) def filtrer_occurrences(compteur, seuil_min=1): """ Filtre un dictionnaire de comptage pour ne garder que les éléments ayant un nombre d'occurrences >= seuil_min. """ # VOTRE CODE ICI return {element: count for element, count in compteur.items() if count >= seuil_min} # TESTS ET VALIDATION print("=== TEST EXERCICE 2 ===") # Test comptage produits compteur_produits = compter_occurrences_liste(ventes_produits) print(f"Ventes par produit: {compteur_produits}") # Test comptage texte compteur_mots = compter_occurrences_texte(texte_marocain) print(f"Occurrences des mots: {compteur_mots}") # Test analyse notes analyse_notes = analyser_notes_etudiants(notes_etudiants) print(f"Analyse des notes: {analyse_notes}") # Test élément le plus fréquent produit_plus_vendu, quantite = trouver_plus_frequent(compteur_produits) print(f"Produit le plus vendu: {produit_plus_vendu} ({quantite} ventes)") # Test filtre produits_frequents = filtrer_occurrences(compteur_produits, seuil_min=3) print(f"Produits avec au moins 3 ventes: {produits_frequents}")
Fusionnez et transformez des données provenant de différentes sources pour créer des vues consolidées et des analyses croisées.
# EXERCICE 3: FUSION DE DONNÉES # Fusionnez des données provenant de différentes sources # DONNÉES DE DÉPART clients = { "CL001": {"nom": "Alaoui", "prenom": "Ahmed", "ville": "Casablanca", "segment": "Premium"}, "CL002": {"nom": "Benani", "prenom": "Fatima", "ville": "Rabat", "segment": "Standard"}, "CL003": {"nom": "Cherkaoui", "prenom": "Karim", "ville": "Marrakech", "segment": "Premium"} } commandes = [ {"commande_id": "CMD001", "client_id": "CL001", "produit": "huile d'argan", "quantite": 2, "montant": 300}, {"commande_id": "CMD002", "client_id": "CL002", "produit": "dattes", "quantite": 5, "montant": 400}, {"commande_id": "CMD003", "client_id": "CL001", "produit": "safran", "quantite": 1, "montant": 250}, {"commande_id": "CMD004", "client_id": "CL003", "produit": "huile d'argan", "quantite": 3, "montant": 450}, {"commande_id": "CMD005", "client_id": "CL002", "produit": "couscous", "quantite": 2, "montant": 80} ] produits_info = { "huile d'argan": {"categorie": "Beauté", "fournisseur": "Coopérative Argana", "prix_unitaire": 150}, "dattes": {"categorie": "Alimentation", "fournisseur": "Palmeraie Zagora", "prix_unitaire": 80}, "safran": {"categorie": "Épice", "fournisseur": "Taliouine Coop", "prix_unitaire": 250}, "couscous": {"categorie": "Alimentation", "fournisseur": "Moulins Atlas", "prix_unitaire": 40} } # FONCTIONS À IMPLÉMENTER def fusionner_commandes_clients(clients_dict, commandes_list): """ Fusionne les données clients et commandes. Retourne un dictionnaire avec les commandes enrichies des infos clients. """ # VOTRE CODE ICI commandes_fusionnees = {} for commande in commandes_list: client_id = commande["client_id"] if client_id in clients_dict: commande_fusionnee = commande.copy() commande_fusionnee.update(clients_dict[client_id]) commandes_fusionnees[commande["commande_id"]] = commande_fusionnee return commandes_fusionnees def calculer_chiffre_affaires_par_client(commandes_fusionnees): """ Calcule le chiffre d'affaires par client. Retourne un dictionnaire {client_id: total_ca}. """ # VOTRE CODE ICI ca_par_client = {} for commande in commandes_fusionnees.values(): client_id = commande["client_id"] ca_par_client[client_id] = ca_par_client.get(client_id, 0) + commande["montant"] return ca_par_client def analyser_ventes_par_categorie(commandes_list, produits_dict): """ Analyse les ventes par catégorie de produit. Retourne un dictionnaire avec le CA et les quantités par catégorie. """ # VOTRE CODE ICI ventes_par_categorie = {} for commande in commandes_list: produit = commande["produit"] if produit in produits_dict: categorie = produits_dict[produit]["categorie"] if categorie not in ventes_par_categorie: ventes_par_categorie[categorie] = {"ca_total": 0, "quantite_totale": 0} ventes_par_categorie[categorie]["ca_total"] += commande["montant"] ventes_par_categorie[categorie]["quantite_totale"] += commande["quantite"] return ventes_par_categorie def creer_rapport_complet(clients_dict, commandes_list, produits_dict): """ Crée un rapport complet consolidant toutes les données. Retourne un dictionnaire structuré avec toutes les analyses. """ # VOTRE CODE ICI commandes_fusionnees = fusionner_commandes_clients(clients_dict, commandes_list) ca_par_client = calculer_chiffre_affaires_par_client(commandes_fusionnees) ventes_par_categorie = analyser_ventes_par_categorie(commandes_list, produits_dict) rapport = { "resume": { "total_clients": len(clients_dict), "total_commandes": len(commandes_list), "chiffre_affaires_total": sum(commande["montant"] for commande in commandes_list) }, "clients": { "chiffre_affaires_par_client": ca_par_client, "meilleur_client": max(ca_par_client, key=ca_par_client.get) if ca_par_client else None }, "produits": { "ventes_par_categorie": ventes_par_categorie, "categorie_plus_rentable": max(ventes_par_categorie, key=lambda x: ventes_par_categorie[x]["ca_total"]) if ventes_par_categorie else None } } return rapport def filtrer_commandes_par_ville(commandes_fusionnees, ville): """ Filtre les commandes fusionnées pour une ville spécifique. Retourne un dictionnaire des commandes de cette ville. """ # VOTRE CODE ICI return {cmd_id: cmd for cmd_id, cmd in commandes_fusionnees.items() if cmd.get("ville") == ville} # TESTS ET VALIDATION print("=== TEST EXERCICE 3 ===") # Test fusion commandes-clients commandes_fusionnees = fusionner_commandes_clients(clients, commandes) print(f"Commandes fusionnées: {{k: f\"{v['prenom']} {v['nom']} - {v['produit']}\" for k, v in commandes_fusionnees.items()}}") # Test CA par client ca_clients = calculer_chiffre_affaires_par_client(commandes_fusionnees) print(f"CA par client: {ca_clients}") # Test ventes par catégorie ventes_categories = analyser_ventes_par_categorie(commandes, produits_info) print(f"Ventes par catégorie: {ventes_categories}") # Test rapport complet rapport = creer_rapport_complet(clients, commandes, produits_info) print(f"Rapport complet: {rapport}") # Test filtre par ville commandes_casablanca = filtrer_commandes_par_ville(commandes_fusionnees, "Casablanca") print(f"Commandes Casablanca: {{k: v['produit'] for k, v in commandes_casablanca.items()}}")
Félicitations ! Vous avez maintenant une solide compréhension des dictionnaires Python et de leur utilisation dans des contextes pratiques. Cette section vous aidera à consolider vos connaissances et à poursuivre votre apprentissage.
Voici un résumé des concepts les plus importants abordés dans ce chapitre, illustrés par des exemples concrets du contexte marocain.
# RÉCAPITULATIF DES POINTS CLÉS SUR LES DICTIONNAIRES PYTHON # 1. CRÉATION ET ACCÈS DE BASE # Création avec accolades ville_maroc = {"nom": "Casablanca", "population": 3350000, "region": "Casablanca-Settat"} # Accès sécurisé avec .get() population = ville_maroc.get("population", "Inconnue") superficie = ville_maroc.get("superficie", "Non spécifiée") # 2. MÉTHODES ESSENTIELLES universites = { "UM5": "Rabat", "UH2": "Casablanca", "UIZ": "Agadir" } # Parcours avec .items(), .keys(), .values() print("Universités et leurs villes:") for sigle, ville in universites.items(): print(f" - {sigle}: {ville}") # 3. DICTIONNAIRES IMBRIQUÉS systeme_educatif = { "universites": { "publiques": { "UM5": {"ville": "Rabat", "etudiants": 25000}, "UH2": {"ville": "Casablanca", "etudiants": 30000} } } } # Accès aux éléments imbriqués etudiants_um5 = systeme_educatif["universites"]["publiques"]["UM5"]["etudiants"] # 4. COMPRÉHENSIONS DE DICTIONNAIRES villes = ["Casablanca", "Rabat", "Marrakech", "Fès"] populations = [3350000, 577000, 928000, 1112000] # Création avec compréhension populations_villes = {ville: population for ville, population in zip(villes, populations)} # 5. BONNES PRATIQUES # Utilisation de defaultdict from collections import defaultdict ventes_par_ville = defaultdict(int) ventes = ["Casablanca", "Rabat", "Casablanca", "Marrakech"] for ville in ventes: ventes_par_ville[ville] += 1 # 6. FUSION DE DICTIONNAIRES (Python 3.9+) info_casablanca = {"population": 3350000, "superficie": 387} info_economique = {"PIB": 450, "entreprises": 85000} # Fusion avec | info_complete = info_casablanca | info_economique # AFFICHAGE DES RÉSULTATS print("=== RÉCAPITULATIF ===") print(f"1. Population de Casablanca: {population}") print(f"2. Étudiants à UM5: {etudiants_um5}") print(f"3. Populations des villes: {populations_villes}") print(f"4. Ventes par ville: {dict(ventes_par_ville)}") print(f"5. Info complète Casablanca: {info_complete}") # TABLEAU RÉCAPITULATIF DES MÉTHODES PRINCIPALES methodes_principales = { "Accès": [".get()", ".setdefault()", "in"], "Modification": [".update()", "| (fusion)", "del"], "Parcours": [".items()", ".keys()", ".values()"], "Copie": [".copy()", "dict()"], "Suppression": [".pop()", ".popitem()", ".clear()"] } print("\n? MÉTHODES PRINCIPALES:") for categorie, methodes in methodes_principales.items(): print(f" {categorie}: {', '.join(methodes)}")
Votre apprentissage des dictionnaires ne fait que commencer. Voici des ressources et pistes pour approfondir vos connaissances et les appliquer dans des projets concrets.
# PROJETS AVANCÉS POUR APPROFONDIR LES DICTIONNAIRES # PROJET 1: SYSTÈME DE GESTION DE BIBLIOTHÈQUE MAROCAINE class BibliothequeMarocaine: def __init__(self): self.livres = { "ISBN001": { "titre": "Le Pain Nu", "auteur": "Mohamed Choukri", "annee": 1973, "genre": "Autobiographie", "disponible": True, "emprunteur": None } } self.membres = {} def ajouter_livre(self, isbn, **infos_livre): # Implémentez l'ajout de livre avec validation pass def rechercher_livres(self, **criteria): # Implémentez la recherche multi-critères pass def generer_statistiques(self): # Générer des stats par genre, auteur, etc. pass # PROJET 2: ANALYSE DE DONNÉES TOURISTIQUES AU MAROC def analyser_tourisme_maroc(): # Données touristiques des villes marocaines donnees_touristiques = { "Marrakech": { "visiteurs_annuels": 2500000, "hotels": 850, "attractions": ["Jamaa El Fna", "Ménara", "Palais Bahia"], "saison_haute": ["Mars", "Avril", "Octobre"] }, "Fès": { "visiteurs_annuels": 1200000, "hotels": 320, "attractions": ["Médina", "Université Al Quaraouiyine", "Tanneries"] } } # À implémenter: # - Calcul du revenu touristique estimé # - Analyse saisonnière # - Recommandations de développement pass # PROJET 3: SYSTÈME DE RECOMMANDATION DE PRODUITS MAROCAINS class SystemeRecommandation: def __init__(self): self.produits = { "P001": { "nom": "Huile d'Argan Biologique", "categorie": "Beauté", "prix": 150, "tags": ["bio", "cosmétique", "naturel"] } } self.historique_achats = {} def recommander_produits(self, client_id, max_recommandations=5): # Implémentez un système de recommandation basé sur: # - Historique d'achats # - Similarité entre produits # - Préférences utilisateur pass # RESSOURCES POUR APPROFONDIR ressources_aprentissage = { "Documentation Officielle": { "Python Dict Documentation": "https://docs.python.org/3/library/stdtypes.html#mapping-types-dict", "Collections Module": "https://docs.python.org/3/library/collections.html" }, "Tutoriels Avancés": { "Real Python - Dictionaries": "https://realpython.com/python-dicts/", "DataCamp - Python Dictionaries": "https://www.datacamp.com/tutorial/python-dictionary-tutorial" }, "Projets Pratiques": { "Gestion de Stock": "Développer un système pour une entreprise marocaine", "Analyse de Données": "Utiliser des dicts pour analyser des données économiques du Maroc", "API REST": "Créer une API utilisant des dictionnaires pour structurer les réponses" } } # EXEMPLE DE CODE AVANCÉ: TRAITEMENT DE DONNÉES COMPLEXES def analyser_eco_maroc(): # Données économiques structurées economie_maroc = { "secteurs": { "agriculture": { "contribution_pib": 12.5, "emplois": 38, "sous_secteurs": { "céréales": {"production": "85M quintaux", "export": "2.5M tonnes"}, "agrumes": {"production": "2.4M tonnes", "export": "650k tonnes"} } }, "tourisme": { "contribution_pib": 7.1, "visiteurs": 13000000, "recettes": "80M MDH" } } } # Analyse avancée avec compréhensions imbriquées analyse_secteurs = { secteur: { "contribution": infos["contribution_pib"], "sous_secteurs_cles": list(infos.get("sous_secteurs", {}).keys()) } for secteur, infos in economie_maroc["secteurs"].items() } return analyse_secteurs # AFFICHAGE DES RESSOURCES ET PROJETS print("? POUR ALLER PLUS LOIN") print("\n? RESSOURCES D'APPRENTISSAGE:") for categorie, ressources in ressources_aprentissage.items(): print(f"\n {categorie}:") for nom, url in ressources.items(): print(f" • {nom}: {url}") print("\n? PROJETS RECOMMANDÉS:") print(" 1. Système de gestion de bibliothèque") print(" 2. Analyse de données touristiques") print(" 3. Système de recommandation de produits") print(" 4. Gestion de stock d'entreprise") print(" 5. Analyse économique du Maroc") print("\n? CONSEILS POUR LA SUITE:") conseils = [ "Pratiquez régulièrement avec des projets concrets", "Explorez les modules collections et itertools", "Apprenez à utiliser les dictionnaires avec pandas", "Participez à des projets open source", "Rejoignez des communautés Python marocaines" ] for i, conseil in enumerate(conseils, 1): print(f" {i}. {conseil}") # Analyse économique en action analyse = analyser_eco_maroc() print(f"\n? ANALYSE ÉCONOMIQUE: {analyse}")
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!