Aller au contenu

Fiche d'exercices : Dictionnaires

Introduction 🦊

Moyenne d'une interrogation

Un dictionnaire notes représente les notes d'une interrogation.

notes = {
    'Alice': 15,
    'Bob': 12,
    'Charlie': 18,
    'Diana': 14
}
Introduction 🦊

Création et accès

Écrire une fonction afficher_notes qui prend en paramètre un dictionnaire et affiche la moyenne de chaque élève sous la forme : "Alice a une moyenne de 15.".

Ajouter un commentaire selon la moyenne : "Excellent" pour une moyenne ≥ 16, "Bien" pour une moyenne entre 12 et 15 inclus, et "À améliorer" pour une moyenne < 12.

def afficher_notes(notes):
    for eleve in notes:
        moyenne = notes[eleve]
        print(eleve + "a une moyenne de "+ str(moyenne)+".")
        if moyenne >= 16:
            print("Excellent")
        elif 12 <= moyenne <= 15:
            print("Bien")
        else:
            print("À améliorer")
Introduction 🦊

Modification et ajout

Écrire une fonction ajouter_eleve(notes, nom, moyenne) qui ajoute un nouvel élève au dictionnaire.

def ajouter_eleve(notes, nom, moyenne):
    # On vérifie d'abord si l'élève existe déjà
    if nom in notes:
        print("L'élève "+nom+" existe déjà !")
    else:
        # Si l'élève n'existe pas, on l'ajoute
        notes[nom] = moyenne
        print("L'élève "+nom+" a été ajouté avec la moyenne de "+str(moyenne))
Facile 🦊

Parcours de dictionnaire

Écrire une fonction modifier_moyenne(notes, nom, nouvelle_moyenne) qui modifie la moyenne d'un élève.

Gérer le cas où l'élève à modifier n'existe pas.

def modifier_moyenne(notes, nom, nouvelle_moyenne):
    # On vérifie si l'élève existe dans le dictionnaire
    if nom in notes:
        # Si oui, on modifie sa moyenne
        notes[nom] = nouvelle_moyenne
        print("La moyenne de "+nom+" a été mise à jour à "+str(nouvelle_moyenne))
    else:
        print("L'élève "+ nom + " n'existe pas dans la liste")
Facile 🦊🦊

Dictionnaire de notes

Écrire une fonction eleves_mention(notes, seuil) qui renvoie la liste des élèves ayant une moyenne ≥ seuil.

Afficher également le nombre total d'élèves ayant cette mention.

def eleves_mention(notes, seuil):
    # On crée une liste vide pour stocker les élèves
    eleves_avec_mention = []
    # On parcourt le dictionnaire
    for eleve in notes:
        if notes[eleve] >= seuil:
            eleves_avec_mention.append(eleve)
    # On affiche le résultat
    print(str(len(eleves_avec_mention)) + " élèves ont une mention")
    return eleves_avec_mention
Facile 🦊

Gestion d'un concessionnaire

Un dictionnaire voitures stocke des informations sur les voitures d'un concessionnaire.

voitures = {
    'Peugeot 208': {'prix': 15000, 'couleur': 'rouge', 'année': 2020},
    'Renault Clio': {'prix': 12000, 'couleur': 'bleu', 'année': 2019}
}

Écrire une fonction voitures_par_couleur qui renvoie la liste des voitures d'une couleur donnée.

def voitures_par_couleur(voitures, couleur):
    """
    Renvoie la liste des voitures d'une couleur donnée
    """
    voitures_couleur = []
    for voiture in voitures:
        if voitures[voiture]['couleur'] == couleur:
            voitures_couleur.append(voiture)
    return voitures_couleur
Facile 🦊

Voitures dans un budget

Écrire une fonction voitures_budget qui renvoie les voitures dont le prix est inférieur ou égal à un budget donné.

def voitures_budget(voitures, budget):
    """
    Renvoie les voitures dans le budget
    """
    voitures_abordables = []
    for voiture in voitures:
        if voitures[voiture]['prix'] <= budget:
            voitures_abordables.append(voiture)
    return voitures_abordables
Intermédiaire 🦊🦊

Gestion des bibliothèques

Un dictionnaire bibliotheque stocke des informations sur les livres.

bibliotheque = {
    'Le Petit Prince': {'auteur': 'Saint-Exupéry', 'genre': 'Fiction', 'disponible': True},
    '1984': {'auteur': 'Orwell', 'genre': 'Science-fiction', 'disponible': False}
}

Écrire une fonction livres_disponibles qui renvoie la liste des livres disponibles.

def livres_disponibles(bibliotheque):
    """
    Renvoie la liste des livres disponibles
    """
    livres_dispo = []
    for livre in bibliotheque:
        if bibliotheque[livre]['disponible']:
            livres_dispo.append(livre)
    return livres_dispo
Intermédiaire 🦊🦊

Emprunter un livre

Écrire une fonction emprunter_livre qui permet d'emprunter un livre (le marquer comme non disponible).

def emprunter_livre(bibliotheque, titre):
    """
    Emprunte un livre s'il est disponible
    """
    if titre in bibliotheque:
        if bibliotheque[titre]['disponible']:
            bibliotheque[titre]['disponible'] = False
            return "Livre emprunté avec succès"
        else:
            return "Livre déjà emprunté"
    return "Livre non trouvé"
Intermédiaire 🦊🦊

Gestion des employés

Un dictionnaire employes stocke des informations sur les employés d'une entreprise.

employes = {
    'Alice': {'poste': 'Développeur', 'salaire': 45000, 'anciennete': 3},
    'Bob': {'poste': 'Designer', 'salaire': 40000, 'anciennete': 2}
}

Écrire une fonction augmentation_salaire qui augmente le salaire d'un employé de 10% s'il a plus de 2 ans d'ancienneté.

def augmentation_salaire(employes, nom):
    """
    Augmente le salaire si l'ancienneté > 2 ans
    """
    if nom in employes:
        if employes[nom]['anciennete'] > 2:
            employes[nom]['salaire'] = int(employes[nom]['salaire'] * 1.1)
            return "Augmentation accordée"
        else:
            return "Ancienneté insuffisante"
    return "Employé non trouvé"
Intermédiaire 🦊🦊

Gestion des contacts

Un dictionnaire contacts stocke des informations de contact.

contacts = {
    'Alice': {'téléphone': '0123456789', 'email': 'alice@email.com', 'ville': 'Paris'},
    'Bob': {'téléphone': '0987654321', 'email': 'bob@email.com', 'ville': 'Lyon'}
}

Écrire une fonction rechercher_contact(nom) qui affiche toutes les informations d'un contact

Écrire une fonction contacts_par_ville(ville) qui retourne la liste des noms des personnes habitant dans une ville donnée

Écrire une fonction modifier_telephone(nom, nouveau_telephone) qui modifie le numéro de téléphone d'un contact

def rechercher_contact(nom):
    """Affiche toutes les informations d'un contact"""
    if nom in contacts:
        print(f"Informations de {nom}:")
        for cle, valeur in contacts[nom].items():
            print(f"  {cle}: {valeur}")
    else:
        print(f"Contact {nom} non trouvé.")

def contacts_par_ville(ville):
    """Retourne la liste des contacts d'une ville"""
    personnes_ville = []
    for nom, infos in contacts.items():
        if infos['ville'] == ville:
            personnes_ville.append(nom)
    return personnes_ville

def modifier_telephone(nom, nouveau_telephone):
    """Modifie le numéro de téléphone d'un contact"""
    if nom in contacts:
        contacts[nom]['telephone'] = nouveau_telephone
        print(f"Téléphone de {nom} mis à jour.")
    else:
        print(f"Contact {nom} non trouvé.")

# Tests des fonctions
rechercher_contact('Alice Martin')
print("Contacts à Paris:", contacts_par_ville('Paris'))
modifier_telephone('Bob Dupont', '06.99.88.77.66')
Facile 🦊

Inventaire de magasin

Un magasin utilise un dictionnaire pour gérer son inventaire :

inventaire = {
    'pommes': {'prix': 2.5, 'stock': 50},
    'bananes': {'prix': 1.8, 'stock': 30},
    'oranges': {'prix': 3.0, 'stock': 25}
}

Écrire les fonctions suivantes :

  1. afficher_inventaire() : affiche tous les produits avec leur prix et stock
  2. produits_en_rupture() : retourne la liste des produits avec un stock ≤ 10
  3. valeur_totale_stock() : calcule la valeur totale du stock (prix × quantité pour chaque produit)
inventaire = {
    'pommes': {'prix': 2.5, 'stock': 50},
    'bananes': {'prix': 1.8, 'stock': 30},
    'oranges': {'prix': 3.0, 'stock': 25}
}

def afficher_inventaire():
    """Affiche tous les produits avec prix et stock"""
    print("=== INVENTAIRE ===")
    for produit, infos in inventaire.items():
        print(f"{produit}: {infos['prix']}€ - Stock: {infos['stock']}")

def produits_en_rupture():
    """Retourne les produits avec stock ≤ 10"""
    rupture = []
    for produit, infos in inventaire.items():
        if infos['stock'] <= 10:
            rupture.append(produit)
    return rupture

def valeur_totale_stock():
    """Calcule la valeur totale du stock"""
    total = 0
    for produit, infos in inventaire.items():
        total += infos['prix'] * infos['stock']
    return total

# Tests
afficher_inventaire()
print("Produits en rupture:", produits_en_rupture())
print(f"Valeur totale du stock: {valeur_totale_stock()}€")
Intermédiaire 🦊🦊

Système de notes - Partie 1

🎓 Contexte : Gestion des notes d'une classe

Vous développez un système pour gérer les notes des élèves d'une classe. Chaque élève a plusieurs matières avec plusieurs notes par matière.

Créer un dictionnaire classe qui stocke pour chaque élève ses notes par matière :

classe = {
    'Alice': {
        'Maths': [15, 12, 18],
        'Français': [14, 16, 13],
        'Histoire': [17, 15]
    },
    'Bob': {
        'Maths': [10, 14, 12],
        'Français': [13, 11, 15],
        'Histoire': [12, 14, 16]
    }
}

Écrire une fonction moyenne_matiere(eleve, matiere) qui calcule la moyenne d'un élève dans une matière donnée.

classe = {
    'Alice': {
        'Maths': [15, 12, 18],
        'Français': [14, 16, 13],
        'Histoire': [17, 15]
    },
    'Bob': {
        'Maths': [10, 14, 12],
        'Français': [13, 11, 15],
        'Histoire': [12, 14, 16]
    }
}

def moyenne_matiere(eleve, matiere):
    """Calcule la moyenne d'un élève dans une matière"""
    if eleve in classe and matiere in classe[eleve]:
        notes = classe[eleve][matiere]
        if len(notes) > 0:
            moyenne = sum(notes) / len(notes)
            return round(moyenne, 2)
        else:
            return 0
    else:
        print(f"Élève {eleve} ou matière {matiere} non trouvé(e)")
        return None

# Tests
print(f"Moyenne d'Alice en Maths: {moyenne_matiere('Alice', 'Maths')}")
print(f"Moyenne de Bob en Français: {moyenne_matiere('Bob', 'Français')}")
Intermédiaire 🦊🦊

Système de notes - Partie 2

🎓 Contexte : Gestion des notes d'une classe (suite)

Continuons le développement de notre système de notes avec des fonctionnalités plus avancées.

En utilisant le dictionnaire classe de l'exercice précédent :

  1. Écrire une fonction moyenne_generale(eleve) qui calcule la moyenne générale d'un élève (moyenne de toutes ses matières)
  2. Écrire une fonction ajouter_note(eleve, matiere, note) qui ajoute une note à un élève dans une matière
  3. Écrire une fonction bulletin_classe() qui affiche le bulletin de tous les élèves avec leurs moyennes par matière et leur moyenne générale
def moyenne_generale(eleve):
    """Calcule la moyenne générale d'un élève"""
    if eleve in classe:
        moyennes_matieres = []
        for matiere, notes in classe[eleve].items():
            if len(notes) > 0:
                moyenne_mat = sum(notes) / len(notes)
                moyennes_matieres.append(moyenne_mat)

        if len(moyennes_matieres) > 0:
            return round(sum(moyennes_matieres) / len(moyennes_matieres), 2)
        else:
            return 0
    else:
        print(f"Élève {eleve} non trouvé")
        return None

def ajouter_note(eleve, matiere, note):
    """Ajoute une note à un élève dans une matière"""
    if eleve in classe:
        if matiere in classe[eleve]:
            classe[eleve][matiere].append(note)
        else:
            classe[eleve][matiere] = [note]
        print(f"Note {note} ajoutée pour {eleve} en {matiere}")
    else:
        print(f"Élève {eleve} non trouvé")

def bulletin_classe():
    """Affiche le bulletin de toute la classe"""
    print("=== BULLETIN DE CLASSE ===")
    for eleve in classe:
        print(f"\n--- {eleve} ---")
        for matiere, notes in classe[eleve].items():
            moyenne_mat = moyenne_matiere(eleve, matiere)
            print(f"{matiere}: {moyenne_mat}/20")
        print(f"Moyenne générale: {moyenne_generale(eleve)}/20")

# Tests
ajouter_note('Alice', 'Maths', 16)
bulletin_classe()
Intermédiaire 🦊🦊

Analyse de ventes

Une entreprise stocke ses données de ventes dans un dictionnaire :

ventes = {
    'Janvier': {'produit_A': 150, 'produit_B': 200, 'produit_C': 100},
    'Février': {'produit_A': 180, 'produit_B': 150, 'produit_C': 120},
    'Mars': {'produit_A': 200, 'produit_B': 180, 'produit_C': 90}
}

Écrire les fonctions suivantes :

  1. ventes_totales_mois(mois) : calcule le total des ventes d'un mois
  2. ventes_totales_produit(produit) : calcule le total des ventes d'un produit sur tous les mois
  3. meilleur_mois_produit(produit) : trouve le mois où un produit s'est le mieux vendu
  4. produit_le_plus_vendu() : trouve le produit avec le plus de ventes totales
ventes = {
    'Janvier': {'produit_A': 150, 'produit_B': 200, 'produit_C': 100},
    'Février': {'produit_A': 180, 'produit_B': 150, 'produit_C': 120},
    'Mars': {'produit_A': 200, 'produit_B': 180, 'produit_C': 90}
}

def ventes_totales_mois(mois):
    """Calcule le total des ventes d'un mois"""
    if mois in ventes:
        return sum(ventes[mois].values())
    else:
        print(f"Mois {mois} non trouvé")
        return 0

def ventes_totales_produit(produit):
    """Calcule le total des ventes d'un produit sur tous les mois"""
    total = 0
    for mois, produits in ventes.items():
        if produit in produits:
            total += produits[produit]
    return total

def meilleur_mois_produit(produit):
    """Trouve le mois où un produit s'est le mieux vendu"""
    meilleur_mois = None
    meilleures_ventes = 0

    for mois, produits in ventes.items():
        if produit in produits and produits[produit] > meilleures_ventes:
            meilleures_ventes = produits[produit]
            meilleur_mois = mois

    return meilleur_mois, meilleures_ventes

def produit_le_plus_vendu():
    """Trouve le produit avec le plus de ventes totales"""
    # Calculer les ventes totales pour chaque produit
    totaux_produits = {}

    # Récupérer tous les produits
    tous_produits = set()
    for mois_data in ventes.values():
        tous_produits.update(mois_data.keys())

    # Calculer le total pour chaque produit
    for produit in tous_produits:
        totaux_produits[produit] = ventes_totales_produit(produit)

    # Trouver le maximum
    meilleur_produit = max(totaux_produits, key=totaux_produits.get)
    return meilleur_produit, totaux_produits[meilleur_produit]

# Tests
print(f"Ventes totales de Janvier: {ventes_totales_mois('Janvier')}")
print(f"Ventes totales du produit_A: {ventes_totales_produit('produit_A')}")
mois, ventes_max = meilleur_mois_produit('produit_B')
print(f"Meilleur mois pour produit_B: {mois} ({ventes_max} ventes)")
produit, total = produit_le_plus_vendu()
print(f"Produit le plus vendu: {produit} ({total} ventes)")
📦 Gestion d'inventaire de magasin ▶
Difficile 🦊🦊🦊

Inventaire - Valeur totale

Écrire une fonction valeur_totale_inventaire qui calcule la valeur totale d'un inventaire de magasin.
inventaire = {
    'pommes': {'quantite': 50, 'prix': 2.5, 'categorie': 'fruits'},
    'bananes': {'quantite': 30, 'prix': 1.8, 'categorie': 'fruits'},
    'carottes': {'quantite': 25, 'prix': 1.2, 'categorie': 'legumes'}
}

La fonction doit calculer et retourner la valeur totale de l'inventaire (quantité × prix pour chaque produit).

def valeur_totale_inventaire(inventaire):
    """Calcule la valeur totale de l'inventaire"""
    valeur_totale = 0
    for produit, infos in inventaire.items():
        valeur_totale += infos['quantite'] * infos['prix']
    return valeur_totale

# Test
inventaire = {
    'pommes': {'quantite': 50, 'prix': 2.5, 'categorie': 'fruits'},
    'bananes': {'quantite': 30, 'prix': 1.8, 'categorie': 'fruits'},
    'carottes': {'quantite': 25, 'prix': 1.2, 'categorie': 'legumes'}
}

print(f"Valeur totale: {valeur_totale_inventaire(inventaire)}€")
Difficile 🦊🦊🦊

Inventaire - Produit le plus cher

Écrire une fonction produit_plus_cher qui trouve le produit le plus cher dans l'inventaire.

Utiliser le même dictionnaire inventaire que l'exercice précédent.

La fonction doit retourner le nom du produit le plus cher et son prix.

def produit_plus_cher(inventaire):
    """Trouve le produit le plus cher"""
    produit_cher = None
    prix_max = 0

    for produit, infos in inventaire.items():
        if infos['prix'] > prix_max:
            prix_max = infos['prix']
            produit_cher = produit

    return produit_cher, prix_max

# Test
produit, prix = produit_plus_cher(inventaire)
print(f"Produit le plus cher: {produit} ({prix}€)")
Difficile 🦊🦊🦊

Inventaire - Filtrage par catégorie

Écrire une fonction produits_par_categorie qui liste les produits d'une catégorie donnée.

La fonction prend en paramètres l'inventaire et une catégorie, et retourne la liste des noms des produits de cette catégorie.

def produits_par_categorie(inventaire, categorie):
    """Liste les produits d'une catégorie donnée"""
    produits = []
    for produit, infos in inventaire.items():
        if infos['categorie'] == categorie:
            produits.append(produit)
    return produits

# Test
fruits = produits_par_categorie(inventaire, 'fruits')
legumes = produits_par_categorie(inventaire, 'legumes')
print(f"Fruits: {fruits}")
print(f"Légumes: {legumes}")
Difficile 🦊🦊🦊

Inventaire - Mise à jour des quantités

Écrire une fonction mettre_a_jour_quantite qui met à jour la quantité d'un produit.

La fonction prend en paramètres l'inventaire, le nom du produit et la nouvelle quantité.

Elle doit gérer le cas où le produit n'existe pas dans l'inventaire.

def mettre_a_jour_quantite(inventaire, produit, nouvelle_quantite):
    """Met à jour la quantité d'un produit"""
    if produit in inventaire:
        ancienne_quantite = inventaire[produit]['quantite']
        inventaire[produit]['quantite'] = nouvelle_quantite
        print(f"Quantité de {produit} mise à jour: {ancienne_quantite} → {nouvelle_quantite}")
        return True
    else:
        print(f"Erreur: Le produit '{produit}' n'existe pas dans l'inventaire")
        return False

# Test
mettre_a_jour_quantite(inventaire, 'pommes', 75)
mettre_a_jour_quantite(inventaire, 'oranges', 20)  # Produit inexistant
📊 Analyse de données de ventes ▶
Difficile 🦊🦊🦊

Ventes - Total par mois

Écrire une fonction ventes_totales_par_mois qui calcule les ventes totales pour chaque mois.
ventes = {
    'janvier': {'produit_A': 150, 'produit_B': 200, 'produit_C': 100},
    'fevrier': {'produit_A': 180, 'produit_B': 150, 'produit_C': 120},
    'mars': {'produit_A': 200, 'produit_B': 180, 'produit_C': 90}
}

La fonction doit retourner un dictionnaire avec le total des ventes pour chaque mois.

def ventes_totales_par_mois(ventes):
    """Calcule les ventes totales pour chaque mois"""
    ventes_par_mois = {}
    for mois, produits in ventes.items():
        total_mois = sum(produits.values())
        ventes_par_mois[mois] = total_mois
    return ventes_par_mois

# Test
ventes = {
    'janvier': {'produit_A': 150, 'produit_B': 200, 'produit_C': 100},
    'fevrier': {'produit_A': 180, 'produit_B': 150, 'produit_C': 120},
    'mars': {'produit_A': 200, 'produit_B': 180, 'produit_C': 90}
}

resultat = ventes_totales_par_mois(ventes)
print("Ventes totales par mois:")
for mois, total in resultat.items():
    print(f"{mois}: {total}")
Difficile 🦊🦊🦊

Ventes - Total par produit

Écrire une fonction ventes_totales_par_produit qui calcule les ventes totales pour chaque produit sur tous les mois.

Utiliser le même dictionnaire ventes que l'exercice précédent.

La fonction doit retourner un dictionnaire avec le total des ventes pour chaque produit.

def ventes_totales_par_produit(ventes):
    """Calcule les ventes totales pour chaque produit"""
    ventes_par_produit = {}
    for mois, produits in ventes.items():
        for produit, quantite in produits.items():
            if produit not in ventes_par_produit:
                ventes_par_produit[produit] = 0
            ventes_par_produit[produit] += quantite
    return ventes_par_produit

# Test
resultat = ventes_totales_par_produit(ventes)
print("Ventes totales par produit:")
for produit, total in resultat.items():
    print(f"{produit}: {total}")
Difficile 🦊🦊🦊

Ventes - Meilleur mois par produit

Écrire une fonction meilleur_mois_par_produit qui trouve le meilleur mois de vente pour chaque produit.

La fonction doit retourner un dictionnaire où chaque produit est associé à son meilleur mois et la quantité vendue ce mois-là.

def meilleur_mois_par_produit(ventes):
    """Trouve le meilleur mois pour chaque produit"""
    meilleur_mois_produit = {}

    for mois, produits in ventes.items():
        for produit, quantite in produits.items():
            if produit not in meilleur_mois_produit:
                meilleur_mois_produit[produit] = {'mois': mois, 'quantite': quantite}
            elif quantite > meilleur_mois_produit[produit]['quantite']:
                meilleur_mois_produit[produit] = {'mois': mois, 'quantite': quantite}

    return meilleur_mois_produit

# Test
resultat = meilleur_mois_par_produit(ventes)
print("Meilleur mois par produit:")
for produit, info in resultat.items():
    print(f"{produit}: {info['mois']} ({info['quantite']} ventes)")
Difficile 🦊🦊🦊

Ventes - Moyenne par produit

Écrire une fonction moyenne_ventes_par_produit qui calcule la moyenne des ventes pour chaque produit.

La fonction doit calculer la moyenne des ventes de chaque produit sur tous les mois disponibles.

def moyenne_ventes_par_produit(ventes):
    """Calcule la moyenne des ventes pour chaque produit"""
    # D'abord calculer les totaux par produit
    ventes_par_produit = ventes_totales_par_produit(ventes)

    # Calculer le nombre de mois
    nb_mois = len(ventes)

    # Calculer les moyennes
    moyenne_par_produit = {}
    for produit, total in ventes_par_produit.items():
        moyenne_par_produit[produit] = round(total / nb_mois, 2)

    return moyenne_par_produit

# Test
resultat = moyenne_ventes_par_produit(ventes)
print("Moyenne des ventes par produit:")
for produit, moyenne in resultat.items():
    print(f"{produit}: {moyenne}")
📚 Système de notation d'étudiants ▶
Difficile 🦊🦊🦊

Notes - Moyenne par matière

Écrire une fonction moyenne_matiere qui calcule la moyenne d'un étudiant dans une matière donnée.
etudiants = {
    'Alice': {'maths': [15, 12, 18], 'francais': [14, 16], 'histoire': [13, 15, 17]},
    'Bob': {'maths': [10, 14, 12], 'francais': [15, 13], 'histoire': [11, 14]}
}

La fonction prend en paramètres le dictionnaire des étudiants, le nom de l'étudiant et la matière.

Elle doit gérer les cas d'erreur (étudiant ou matière inexistants).

def moyenne_matiere(etudiants, etudiant, matiere):
    """Calcule la moyenne d'un étudiant dans une matière"""
    if etudiant in etudiants and matiere in etudiants[etudiant]:
        notes = etudiants[etudiant][matiere]
        if notes:
            return round(sum(notes) / len(notes), 2)
        else:
            return 0
    else:
        print(f"Erreur: Étudiant '{etudiant}' ou matière '{matiere}' non trouvé(e)")
        return None

# Test
etudiants = {
    'Alice': {'maths': [15, 12, 18], 'francais': [14, 16], 'histoire': [13, 15, 17]},
    'Bob': {'maths': [10, 14, 12], 'francais': [15, 13], 'histoire': [11, 14]}
}

print(f"Moyenne d'Alice en maths: {moyenne_matiere(etudiants, 'Alice', 'maths')}")
print(f"Moyenne de Bob en français: {moyenne_matiere(etudiants, 'Bob', 'francais')}")
print(f"Test erreur: {moyenne_matiere(etudiants, 'Charlie', 'maths')}")
Difficile 🦊🦊🦊

Notes - Moyenne générale

Écrire une fonction moyenne_generale qui calcule la moyenne générale d'un étudiant.

Utiliser le même dictionnaire etudiants que l'exercice précédent.

La fonction doit calculer la moyenne de toutes les matières de l'étudiant.

def moyenne_generale(etudiants, etudiant):
    """Calcule la moyenne générale d'un étudiant"""
    if etudiant in etudiants:
        moyennes_matieres = []
        for matiere, notes in etudiants[etudiant].items():
            if notes:  # Vérifier que la liste n'est pas vide
                moyenne = sum(notes) / len(notes)
                moyennes_matieres.append(moyenne)

        if moyennes_matieres:
            return round(sum(moyennes_matieres) / len(moyennes_matieres), 2)
        else:
            return 0
    else:
        print(f"Erreur: Étudiant '{etudiant}' non trouvé")
        return None

# Test
print(f"Moyenne générale d'Alice: {moyenne_generale(etudiants, 'Alice')}")
print(f"Moyenne générale de Bob: {moyenne_generale(etudiants, 'Bob')}")
print(f"Test erreur: {moyenne_generale(etudiants, 'Charlie')}")
Difficile 🦊🦊🦊

Notes - Classement par matière

Écrire une fonction classement_matiere qui classe les étudiants dans une matière donnée.

La fonction doit retourner une liste de tuples (étudiant, moyenne) triée par moyenne décroissante.

def classement_matiere(etudiants, matiere):
    """Classe les étudiants dans une matière"""
    moyennes = []
    for etudiant in etudiants:
        if matiere in etudiants[etudiant]:
            moyenne = moyenne_matiere(etudiants, etudiant, matiere)
            if moyenne is not None:
                moyennes.append((etudiant, moyenne))

    # Tri par moyenne décroissante
    moyennes.sort(key=lambda x: x[1], reverse=True)
    return moyennes

# Test
print("Classement en maths:")
classement = classement_matiere(etudiants, 'maths')
for i, (etudiant, moyenne) in enumerate(classement, 1):
    print(f"{i}. {etudiant}: {moyenne}")

print("\nClassement en français:")
classement = classement_matiere(etudiants, 'francais')
for i, (etudiant, moyenne) in enumerate(classement, 1):
    print(f"{i}. {etudiant}: {moyenne}")
Difficile 🦊🦊🦊

Notes - Ajout de notes

Écrire une fonction ajouter_note qui ajoute une note à un étudiant dans une matière.

La fonction doit gérer les cas où l'étudiant existe mais n'a pas encore de notes dans cette matière.

Elle doit aussi gérer le cas où l'étudiant n'existe pas.

def ajouter_note(etudiants, etudiant, matiere, note):
    """Ajoute une note à un étudiant"""
    if etudiant in etudiants:
        if matiere in etudiants[etudiant]:
            etudiants[etudiant][matiere].append(note)
            print(f"Note {note} ajoutée pour {etudiant} en {matiere}")
        else:
            etudiants[etudiant][matiere] = [note]
            print(f"Nouvelle matière '{matiere}' créée pour {etudiant} avec la note {note}")
        return True
    else:
        print(f"Erreur: Étudiant '{etudiant}' non trouvé")
        return False

# Test
print("État initial d'Alice en maths:", etudiants['Alice']['maths'])
ajouter_note(etudiants, 'Alice', 'maths', 16)
print("Après ajout:", etudiants['Alice']['maths'])

# Ajouter une nouvelle matière
ajouter_note(etudiants, 'Alice', 'physique', 14)
print("Nouvelles matières d'Alice:", list(etudiants['Alice'].keys()))

# Test avec étudiant inexistant
ajouter_note(etudiants, 'Charlie', 'maths', 15)
📝 Analyse de fréquence de mots ▶
Difficile 🦊🦊🦊

Texte - Comptage de fréquence

Écrire une fonction compter_mots qui compte la fréquence de chaque mot dans un texte.
Exemple de texte : 
texte = "Python est un langage de programmation. Python est facile à apprendre."

La fonction doit ignorer la casse et la ponctuation, et retourner un dictionnaire avec les fréquences.

def compter_mots(texte):
    """Compte la fréquence de chaque mot dans un texte"""
    import string

    # Nettoyer le texte : enlever la ponctuation et convertir en minuscules
    texte_propre = texte.lower()
    for caractere in string.punctuation:
        texte_propre = texte_propre.replace(caractere, '')

    # Diviser en mots
    mots = texte_propre.split()

    # Compter la fréquence de chaque mot
    frequences = {}
    for mot in mots:
        if mot in frequences:
            frequences[mot] += 1
        else:
            frequences[mot] = 1

    return frequences

# Test
texte = "Python est un langage de programmation. Python est facile à apprendre."
frequences = compter_mots(texte)
print("Fréquences des mots:")
for mot, freq in frequences.items():
    print(f"{mot}: {freq}")
Difficile 🦊🦊🦊

Texte - Mots les plus fréquents

Écrire une fonction mots_plus_frequents qui trouve les N mots les plus fréquents dans un texte.

Utiliser la fonction compter_mots de l'exercice précédent.

La fonction prend en paramètres le texte et le nombre N de mots à retourner.

def mots_plus_frequents(texte, n=3):
    """Trouve les N mots les plus fréquents"""
    # Utiliser la fonction précédente
    frequences = compter_mots(texte)

    # Convertir en liste de tuples pour le tri
    mots_tries = []
    for mot, freq in frequences.items():
        mots_tries.append((mot, freq))

    # Tri par fréquence décroissante
    mots_tries.sort(key=lambda x: x[1], reverse=True)

    # Retourner les N premiers
    return mots_tries[:n]

# Test
texte = "Python est un langage de programmation. Python est facile à apprendre."
top_3 = mots_plus_frequents(texte, 3)
print(f"Top 3 des mots les plus fréquents: {top_3}")

top_5 = mots_plus_frequents(texte, 5)
print(f"Top 5 des mots les plus fréquents: {top_5}")
Difficile 🦊🦊🦊

Texte - Mots uniques

Écrire une fonction compter_mots_uniques qui compte le nombre de mots uniques dans un texte.

La fonction doit retourner le nombre total de mots différents (sans répétition).

def compter_mots_uniques(texte):
    """Compte le nombre de mots uniques dans un texte"""
    frequences = compter_mots(texte)
    return len(frequences)

def statistiques_texte(texte):
    """Affiche des statistiques complètes sur un texte"""
    import string

    # Nettoyer le texte pour compter le total de mots
    texte_propre = texte.lower()
    for caractere in string.punctuation:
        texte_propre = texte_propre.replace(caractere, '')
    mots_total = len(texte_propre.split())

    # Calculer les statistiques
    mots_uniques = compter_mots_uniques(texte)

    print(f"Nombre total de mots: {mots_total}")
    print(f"Nombre de mots uniques: {mots_uniques}")
    print(f"Pourcentage de mots uniques: {round(mots_uniques/mots_total*100, 1)}%")

    return mots_total, mots_uniques

# Test
resultat = statistiques_texte(texte)
Difficile 🦊🦊🦊

Texte - Mots répétés

Écrire une fonction mots_repetes qui trouve tous les mots qui apparaissent plus d'une fois dans un texte.

La fonction doit retourner une liste de tuples (mot, fréquence) pour les mots répétés.

def mots_repetes(texte):
    """Trouve les mots qui apparaissent plus d'une fois"""
    frequences = compter_mots(texte)

    mots_frequents = []
    for mot, freq in frequences.items():
        if freq > 1:
            mots_frequents.append((mot, freq))

    # Trier par fréquence décroissante
    mots_frequents.sort(key=lambda x: x[1], reverse=True)

    return mots_frequents

def analyse_complete_texte(texte):
    """Analyse complète d'un texte"""
    print("=== ANALYSE COMPLÈTE DU TEXTE ===")
    print(f"Texte analysé: '{texte}'")
    print()

    # Statistiques générales
    statistiques_texte(texte)
    print()

    # Mots les plus fréquents
    top_3 = mots_plus_frequents(texte, 3)
    print(f"Top 3 des mots les plus fréquents: {top_3}")

    # Mots répétés
    repetes = mots_repetes(texte)
    if repetes:
        print(f"Mots répétés: {repetes}")
    else:
        print("Aucun mot répété")

# Test
analyse_complete_texte(texte)