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

Les Dictionnaires en Python : Guide Complet pour Maîtriser cette Structure de Données

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.

Sommaire du Chapitre
Introduction aux Dictionnaires Python Qu'est-ce qu'un dictionnaire ? Pourquoi utiliser des dictionnaires ? Différences entre dictionnaires, listes et tuples Créer un Dictionnaire en Python Syntaxe de base avec des accolades {} Création avec la fonction dict() Créer un dictionnaire vide Dictionnaires avec différents types de valeurs Accéder aux Éléments d'un Dictionnaire Accès par clé avec [] La méthode .get() et sa sécurité Vérifier l'existence d'une clé avec 'in' Modifier et Mettre à Jour un Dictionnaire Ajouter de nouvelles paires clé-valeur Modifier une valeur existante La méthode .update() pour fusionner des dictionnaires Opérateur de fusion | (Python 3.9+) Supprimer des Éléments Supprimer avec del La méthode .pop() avec valeur de retour Supprimer avec .popitem() Vider un dictionnaire avec .clear() Parcourir un Dictionnaire Itérer sur les clés avec .keys() Itérer sur les valeurs avec .values() Itérer sur les paires avec .items() Boucles for optimisées Méthodes Essentielles des Dictionnaires Récapitulatif des méthodes principales .copy() pour dupliquer un dictionnaire .setdefault() pour gérer les valeurs par défaut .fromkeys() pour initialiser plusieurs clés Dictionnaires Imbriqués Créer des structures complexes Accéder aux éléments imbriqués Cas d'usage pratiques Compréhensions de Dictionnaires Syntaxe de base Avec conditions Exemples pratiques de transformation de données Bonnes Pratiques et Astuces Gérer les KeyError Dictionnaires ordonnés (Python 3.7+) Performance et optimisation Quand ne pas utiliser un dictionnaire Exercices Pratiques Exercice 1 : Gestion d'un carnet d'adresses Exercice 2 : Comptage de fréquence Exercice 3 : Fusion de données Conclusion et Ressources Récapitulatif des points clés Pour aller plus loin

Introduction aux Dictionnaires 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.

Qu'est-ce qu'un dictionnaire ?

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.

dictionnaire_base.py
# 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]}")

Pourquoi utiliser des dictionnaires ?

Les dictionnaires offrent plusieurs avantages qui les rendent indispensables pour de nombreux cas d'usage en programmation Python :

avantages_dictionnaires.py
# 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}")

Différences entre dictionnaires, listes et tuples

Chaque structure de données en Python a ses spécificités et cas d'usage privilégiés. Voici les principales différences :

comparaison_structures.py
# 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}")

Créer un Dictionnaire en Python

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.

Syntaxe de base avec des accolades {}

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_accolades.py
# 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}")

Création avec la fonction dict()

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.

fonction_dict.py
# 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}")

Créer un dictionnaire vide

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.

dictionnaire_vide.py
# 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)}")

Dictionnaires avec différents types de valeurs

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.

types_valeurs.py
# 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")

Accéder aux Éléments d'un Dictionnaire

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é.

Accès par clé avec []

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.

acces_crochets.py
# 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() et sa sécurité

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.

methode_get.py
# 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}")

Vérifier l'existence d'une clé avec 'in'

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.

operateur_in.py
# 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))

Modifier et Mettre à Jour un Dictionnaire

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.

Ajouter de nouvelles paires clé-valeur

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.

ajout_elements.py
# 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")

Modifier une valeur existante

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.

modification_valeurs.py
# 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() pour fusionner des dictionnaires

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.

methode_update.py
# 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)}")

Opérateur de fusion | (Python 3.9+)

À 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.

operateur_fusion.py
# 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")

Supprimer des Éléments

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.

Supprimer avec del

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.

suppression_del.py
# 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() avec valeur de retour

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.

methode_pop.py
# 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)}")

Supprimer avec .popitem()

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).

methode_popitem.py
# 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']}")

Vider un dictionnaire avec .clear()

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.

methode_clear.py
# 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}")

Parcourir un Dictionnaire

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.

Itérer sur les clés avec .keys()

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.

iterer_cles.py
# 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())}")

Itérer sur les valeurs avec .values()

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.

iterer_valeurs.py
# 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")

Itérer sur les paires avec .items()

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.

iterer_items.py
# 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}")

Boucles for optimisées

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é.

boucles_optimisees.py
# 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)}")

Méthodes Essentielles des Dictionnaires

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.

Récapitulatif des méthodes principales

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.

recapitulatif_methodes.py
# 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}")

.copy() pour dupliquer un dictionnaire

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.

methode_copy.py
# 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é!")

.setdefault() pour gérer les valeurs par défaut

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.

methode_setdefault.py
# 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}")

.fromkeys() pour initialiser plusieurs clés

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.

methode_fromkeys.py
# 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}")

Dictionnaires Imbriqués

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.

Créer des structures complexes

Les dictionnaires imbriqués permettent de modéliser des relations complexes entre différentes entités. Voici comment créer et initialiser ces structures :

dictionnaires_imbriques.py
# 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"])

Accéder aux éléments imbriqués

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.

acces_elements_imbriques.py
# 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')}")

Cas d'usage pratiques

Les dictionnaires imbriqués sont particulièrement utiles dans plusieurs scénarios réels. Voici quelques applications pratiques avec des données marocaines :

cas_usage_pratiques.py
# 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}")

Compréhensions de Dictionnaires

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.

Syntaxe de base

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.

syntaxe_base_comprehension.py
# 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)

Avec conditions

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.

comprehension_conditions.py
# 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)

Exemples pratiques de transformation de données

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.

transformation_donnees.py
# 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)

Bonnes Pratiques et Astuces

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.

Gérer les KeyError

Les KeyError surviennent lorsqu'on tente d'accéder à une clé inexistante dans un dictionnaire. Plusieurs techniques permettent de les éviter proprement.

gerer_keyerror.py
# 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}")

Dictionnaires ordonnés (Python 3.7+)

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.

dictionnaires_ordonnes.py
# 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)}")

Performance et optimisation

La performance des dictionnaires est cruciale pour les applications à grande échelle. Voici les meilleures pratiques pour optimiser leur utilisation.

performance_optimisation.py
# 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()}")

Quand ne pas utiliser un dictionnaire

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.

quand_ne_pas_utiliser.py
# 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")

Exercices Pratiques

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.

Exercice 1 : Gestion d'un carnet d'adresses

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_carnet_adresses.py
# 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']}")

Exercice 2 : Comptage de fréquence

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_comptage_frequence.py
# 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}")

Exercice 3 : Fusion de données

Fusionnez et transformez des données provenant de différentes sources pour créer des vues consolidées et des analyses croisées.

exercice_fusion_donnees.py
# 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()}}")

Conclusion et Ressources

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.

Récapitulatif des points clés

Voici un résumé des concepts les plus importants abordés dans ce chapitre, illustrés par des exemples concrets du contexte marocain.

recapitulatif_points_cles.py
# 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)}")

Pour aller plus loin

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_avances.py
# 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}")

? Félicitations pour votre parcours !

Vous maîtrisez maintenant les dictionnaires Python, un outil essentiel pour tout développeur. Continuez à pratiquer avec des projets concrets inspirés du contexte marocain et n'hésitez pas à explorer les ressources avancées pour devenir un expert !

Prochaines étapes recommandées :
  • ✅ Réalisez les exercices pratiques pour consolider vos connaissances
  • ? Lancez un projet personnel utilisant intensivement les dictionnaires
  • ? Explorez la documentation officielle pour découvrir les fonctionnalités avancées
  • ? Rejoignez la communauté Python Maroc pour échanger avec d'autres apprenants
Contact

📚 Cours à distance

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

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

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