Exercices - Représentation des données : types construits

---

P-uplets (tuples)

Exercice 1 - Manipulation de tuples

a. Créer un tuple point contenant les coordonnées (5, -3). Afficher chaque coordonnée séparément.

b. Créer un tuple identite contenant un nom, un prénom et un âge. Utiliser le déballage pour affecter chaque valeur à une variable.

c. Que se passe-t-il si on essaie d'exécuter point[0] = 10 ? Pourquoi ?

Solution

a.

point = (5, -3)
print(point[0])    # 5
print(point[1])    # -3

b.

identite = ("Dupont", "Marie", 16)
nom, prenom, age = identite
print(f"{prenom} {nom}, {age} ans")    # Marie Dupont, 16 ans

c. Python lève une erreur TypeError: 'tuple' object does not support item assignment. Un tuple est immuable : on ne peut pas modifier ses éléments après sa création.

---

Exercice 2 - Fonctions renvoyant des tuples

a. Écrire une fonction statistiques(liste) qui renvoie un tuple contenant le minimum, le maximum et la moyenne d'une liste de nombres.

b. Tester avec [4, 7, 2, 9, 5, 1, 8] et afficher les résultats avec déballage.

c. Écrire une fonction position_max(liste) qui renvoie un tuple (indice, valeur) du plus grand élément.

def statistiques(liste):
  pass

def position_max(liste):
  pass

Solution

a.

def statistiques(liste):
    minimum = min(liste)
    maximum = max(liste)
    moyenne = sum(liste) / len(liste)
    return (minimum, maximum, moyenne)

b.

mini, maxi, moy = statistiques([4, 7, 2, 9, 5, 1, 8])
print(f"Min = {mini}, Max = {maxi}, Moyenne = {moy}")
# Min = 1, Max = 9, Moyenne = 5.142857142857143

c.

def position_max(liste):
    indice_max = 0
    for i in range(1, len(liste)):
        if liste[i] > liste[indice_max]:
            indice_max = i
    return (indice_max, liste[indice_max])

idx, val = position_max([4, 7, 2, 9, 5])
print(f"Le max est {val} à l'indice {idx}")    # Le max est 9 à l'indice 3

---

Tableaux (listes)

Exercice 3 - Opérations de base

a. Créer un tableau contenant les 10 premiers multiples de 3 (de 0 à 27) en utilisant une compréhension de liste.

b. Créer un tableau contenant uniquement les nombres pairs d'une liste [1, 4, 7, 10, 13, 16, 19, 22].

c. Créer un tableau contenant les longueurs des mots de la liste ["python", "est", "un", "langage"].

Solution

a.

multiples = [3 * i for i in range(10)]
print(multiples)    # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

b.

nombres = [1, 4, 7, 10, 13, 16, 19, 22]
pairs = [n for n in nombres if n % 2 == 0]
print(pairs)    # [4, 10, 16, 22]

c.

mots = ["python", "est", "un", "langage"]
longueurs = [len(m) for m in mots]
print(longueurs)    # [6, 3, 2, 7]

---

Exercice 4 - Algorithmes sur les tableaux

a. Écrire une fonction somme(tableau) qui calcule la somme des éléments d'un tableau sans utiliser sum().

b. Écrire une fonction recherche(tableau, valeur) qui renvoie l'indice de la première occurrence de valeur dans tableau, ou -1 si elle est absente. Ne pas utiliser .index().

c. Écrire une fonction sans_doublons(tableau) qui renvoie un nouveau tableau sans doublons, en conservant l'ordre d'apparition.

def somme(tableau):
  pass

def recherche(tableau, valeur):
  pass

def sans_doublons(tableau):
  pass

Solution

a.

def somme(tableau):
    total = 0
    for element in tableau:
        total += element
    return total

print(somme([3, 7, 2, 5]))    # 17

b.

def recherche(tableau, valeur):
    for i in range(len(tableau)):
        if tableau[i] == valeur:
            return i
    return -1

print(recherche([4, 7, 2, 9], 2))    # 2
print(recherche([4, 7, 2, 9], 5))    # -1

c.

def sans_doublons(tableau):
    resultat = []
    for element in tableau:
        if element not in resultat:
            resultat.append(element)
    return resultat

print(sans_doublons([3, 1, 4, 1, 5, 9, 2, 6, 5]))
# [3, 1, 4, 5, 9, 2, 6]

---

Exercice 5 - Tableaux en compréhension avancés

a. Créer un tableau contenant les carrés des nombres impairs de 1 à 19.

b. Étant donné un tableau de mots, créer un tableau ne contenant que les mots de plus de 4 lettres, mis en majuscules.

c. Créer un tableau de 20 nombres aléatoires entre 1 et 100, puis un second tableau ne contenant que ceux qui sont supérieurs à 50.

Solution

a.

carres_impairs = [x ** 2 for x in range(1, 20) if x % 2 != 0]
print(carres_impairs)
# [1, 9, 25, 49, 81, 121, 169, 225, 289, 361]

b.

mots = ["le", "python", "est", "un", "super", "langage", "de", "programmation"]
resultat = [m.upper() for m in mots if len(m) > 4]
print(resultat)    # ['PYTHON', 'SUPER', 'LANGAGE', 'PROGRAMMATION']

c.

import random
nombres = [random.randint(1, 100) for _ in range(20)]
grands = [n for n in nombres if n > 50]
print(f"Tous : {nombres}")
print(f"Grands : {grands}")

---

Exercice 6 - Matrices

a. Créer une matrice identité 4×4 (des 1 sur la diagonale, des 0 ailleurs) par compréhension.

b. Écrire une fonction somme_matrice(m1, m2) qui renvoie la matrice somme de deux matrices de même taille.

c. Écrire une fonction transpose(matrice) qui renvoie la transposée d'une matrice (les lignes deviennent les colonnes).

Solution

a.

identite = [[1 if i == j else 0 for j in range(4)] for i in range(4)]
for ligne in identite:
    print(ligne)
# [1, 0, 0, 0]
# [0, 1, 0, 0]
# [0, 0, 1, 0]
# [0, 0, 0, 1]

b.

def somme_matrice(m1, m2):
    n = len(m1)
    p = len(m1[0])
    return [[m1[i][j] + m2[i][j] for j in range(p)] for i in range(n)]

a = [[1, 2], [3, 4]]
b = [[5, 6], [7, 8]]
print(somme_matrice(a, b))    # [[6, 8], [10, 12]]

c.

def transpose(matrice):
    n = len(matrice)
    p = len(matrice[0])
    return [[matrice[i][j] for i in range(n)] for j in range(p)]

m = [[1, 2, 3], [4, 5, 6]]
t = transpose(m)
for ligne in t:
    print(ligne)
# [1, 4]
# [2, 5]
# [3, 6]

---

Dictionnaires

Exercice 7 - Manipulation de dictionnaires

a. Créer un dictionnaire capitale associant 5 pays européens à leur capitale. Afficher la capitale de l'Allemagne.

b. Ajouter un sixième pays. Modifier la capitale d'un pays existant. Supprimer un pays.

c. Écrire une boucle qui affiche chaque association sous la forme « La capitale de X est Y. »

Solution

a.

capitale = {
    "France": "Paris",
    "Allemagne": "Berlin",
    "Espagne": "Madrid",
    "Italie": "Rome",
    "Portugal": "Lisbonne"
}
print(capitale["Allemagne"])    # Berlin

b.

capitale["Belgique"] = "Bruxelles"    # ajout
capitale["Allemagne"] = "Berlin"       # modification (ici identique)
del capitale["Portugal"]               # suppression

c.

for pays, ville in capitale.items():
    print(f"La capitale de {pays} est {ville}.")

---

Exercice 8 - Comptage et fréquences

a. Écrire une fonction compter_lettres(texte) qui renvoie un dictionnaire associant chaque lettre (en minuscule, sans espaces ni ponctuation) à son nombre d'occurrences.

b. Tester avec la phrase "Le loup et le renard".

c. Écrire une fonction lettre_la_plus_frequente(texte) qui renvoie la lettre la plus fréquente.

def compter_lettres(texte):
  pass

def lettre_la_plus_frequente(texte):
  pass

Solution

a.

def compter_lettres(texte):
    compteur = {}
    for c in texte.lower():
        if c.isalpha():
            if c in compteur:
                compteur[c] += 1
            else:
                compteur[c] = 1
    return compteur

b.

resultat = compter_lettres("Le loup et le renard")
print(resultat)
# {'l': 3, 'e': 3, 'o': 1, 'u': 1, 'p': 1, 't': 1, 'r': 2, 'n': 1, 'a': 1, 'd': 1}

c.

def lettre_la_plus_frequente(texte):
    compteur = compter_lettres(texte)
    meilleure = None
    max_count = 0
    for lettre, count in compteur.items():
        if count > max_count:
            max_count = count
            meilleure = lettre
    return meilleure

print(lettre_la_plus_frequente("Le loup et le renard"))    # 'l' ou 'e'

---

Exercice 9 - Répertoire téléphonique

a. Créer un dictionnaire repertoire contenant 4 contacts (nom → numéro de téléphone).

b. Écrire une fonction ajouter_contact(rep, nom, numero) qui ajoute un contact s'il n'existe pas déjà, ou affiche un message d'avertissement sinon.

c. Écrire une fonction rechercher_numero(rep, nom) qui renvoie le numéro d'un contact ou "Contact inconnu".

d. Écrire une fonction rechercher_nom(rep, numero) qui fait la recherche inverse : trouver le nom à partir du numéro.

Solution

a.

repertoire = {
    "Alice": "06 12 34 56 78",
    "Bob": "06 98 76 54 32",
    "Charlie": "07 11 22 33 44",
    "Diana": "06 55 66 77 88"
}

b.

def ajouter_contact(rep, nom, numero):
    if nom in rep:
        print(f"Le contact {nom} existe deja.")
    else:
        rep[nom] = numero
        print(f"Contact {nom} ajoute.")

c.

def rechercher_numero(rep, nom):
    return rep.get(nom, "Contact inconnu")

print(rechercher_numero(repertoire, "Alice"))    # 06 12 34 56 78
print(rechercher_numero(repertoire, "Eve"))      # Contact inconnu

d.

def rechercher_nom(rep, numero):
    for nom, num in rep.items():
        if num == numero:
            return nom
    return "Numero inconnu"

print(rechercher_nom(repertoire, "06 98 76 54 32"))    # Bob

---

Exercice 10 - Tableaux de dictionnaires

On dispose du tableau suivant représentant les résultats d'élèves :

eleves = [
    {"nom": "Dupont", "prenom": "Marie", "maths": 15, "nsi": 18, "anglais": 12},
    {"nom": "Martin", "prenom": "Léo", "maths": 8, "nsi": 14, "anglais": 16},
    {"nom": "Durand", "prenom": "Emma", "maths": 17, "nsi": 19, "anglais": 15},
    {"nom": "Petit", "prenom": "Hugo", "maths": 11, "nsi": 10, "anglais": 13},
    {"nom": "Leroy", "prenom": "Alice", "maths": 14, "nsi": 16, "anglais": 18}
]

a. Écrire une fonction moyenne_eleve(eleve) qui calcule la moyenne des trois notes d'un élève.

b. Afficher le prénom et la moyenne de chaque élève.

c. Écrire une fonction meilleur_en(eleves, matiere) qui renvoie le nom et le prénom de l'élève ayant la meilleure note dans une matière donnée.

d. Écrire une fonction au_dessus(eleves, matiere, seuil) qui renvoie la liste des prénoms des élèves ayant une note supérieure ou égale au seuil dans la matière donnée.

Solution

a.

def moyenne_eleve(eleve):
    return (eleve["maths"] + eleve["nsi"] + eleve["anglais"]) / 3

b.

15.0

for e in eleves:
    moy = moyenne_eleve(e)
    print(f"{e['prenom']} : {moy:.1f}")
# Léo : 12.7
# Emma : 17.0
# Hugo : 11.3
# Alice : 16.0

c.

def meilleur_en(eleves, matiere):
    meilleur = eleves[0]
    for e in eleves[1:]:
        if e[matiere] > meilleur[matiere]:
            meilleur = e
    return f"{meilleur['prenom']} {meilleur['nom']}"

print(meilleur_en(eleves, "nsi"))       # Emma Durand
print(meilleur_en(eleves, "anglais"))   # Alice Leroy

d.

def au_dessus(eleves, matiere, seuil):
    return [e["prenom"] for e in eleves if e[matiere] >= seuil]

print(au_dessus(eleves, "maths", 14))    # ['Marie', 'Emma', 'Alice']
print(au_dessus(eleves, "nsi", 16))      # ['Marie', 'Emma', 'Alice']

---

---

Activités

---

Activité 1 - Le carnet d'adresses (dictionnaires)

Objectif

Construire pas à pas un programme de gestion de contacts en utilisant un tableau de dictionnaires.

Déroulement

a. Créer un tableau contacts contenant 3 dictionnaires, chacun avec les clés "nom", "prenom", "email" et "telephone".

b. Écrire une fonction afficher_contacts(contacts) qui affiche tous les contacts sous une forme lisible.

c. Écrire une fonction ajouter(contacts) qui demande les informations à l'utilisateur (avec input()) et ajoute un nouveau contact au tableau.

d. Écrire une fonction chercher(contacts, nom) qui affiche tous les contacts dont le nom contient la chaîne recherchée (recherche partielle, insensible à la casse).

e. Écrire une fonction supprimer(contacts, nom) qui supprime un contact par son nom exact.

f. Assembler le tout dans un menu interactif avec les options : afficher, ajouter, chercher, supprimer, quitter.

Correction

contacts = [
    {"nom": "Dupont", "prenom": "Marie", "email": "[email protected]", "telephone": "0612345678"},
    {"nom": "Martin", "prenom": "Léo", "email": "[email protected]", "telephone": "0698765432"},
    {"nom": "Durand", "prenom": "Emma", "email": "[email protected]", "telephone": "0711223344"}
]

def afficher_contacts(contacts):
    if not contacts:
        print("Aucun contact.")
        return
    for i, c in enumerate(contacts):
        print(f"{i + 1}. {c['prenom']} {c['nom']} - {c['email']} - {c['telephone']}")

def ajouter(contacts):
    nom = input("Nom : ")
    prenom = input("Prenom : ")
    email = input("Email : ")
    telephone = input("Telephone : ")
    contacts.append({
        "nom": nom,
        "prenom": prenom,
        "email": email,
        "telephone": telephone
    })
    print("Contact ajoute.")

def chercher(contacts, recherche):
    resultats = [c for c in contacts if recherche.lower() in c["nom"].lower()]
    if resultats:
        afficher_contacts(resultats)
    else:
        print("Aucun contact trouve.")

def supprimer(contacts, nom):
    for i, c in enumerate(contacts):
        if c["nom"] == nom:
            contacts.pop(i)
            print(f"Contact {nom} supprime.")
            return
    print(f"Contact {nom} introuvable.")

# Menu
while True:
    print("\n=== Carnet d'adresses ===")
    print("1. Afficher tous les contacts")
    print("2. Ajouter un contact")
    print("3. Chercher un contact")
    print("4. Supprimer un contact")
    print("5. Quitter")

    choix = input("Choix : ")
    if choix == "1":
        afficher_contacts(contacts)
    elif choix == "2":
        ajouter(contacts)
    elif choix == "3":
        recherche = input("Nom a chercher : ")
        chercher(contacts, recherche)
    elif choix == "4":
        nom = input("Nom exact a supprimer : ")
        supprimer(contacts, nom)
    elif choix == "5":
        print("Au revoir !")
        break

---

Activité 2 - Le jeu du pendu (tableaux)

Objectif

Programmer le jeu du pendu en utilisant des tableaux pour suivre les lettres devinées et l'affichage du mot.

Déroulement

a. Choisir un mot secret au hasard parmi une liste de mots :

import random
mots = ["python", "tableau", "dictionnaire", "fonction", "variable", "boucle", "condition"]
secret = random.choice(mots)

b. Créer un tableau affichage de la même longueur que le mot, rempli de "_". Ce tableau représente l'état actuel de la partie (les lettres trouvées et les tirets).

c. Créer un tableau lettres_essayees initialement vide pour stocker les lettres déjà proposées.

d. Écrire la boucle de jeu :

• Afficher l'état du mot (le tableau affichage sous forme de chaîne).
• Demander une lettre à l'utilisateur.
• Si la lettre a déjà été essayée, afficher un message et redemander.
• Si la lettre est dans le mot, remplacer les "_" correspondants dans affichage.
• Si la lettre n'est pas dans le mot, incrémenter un compteur d'erreurs.
• La partie s'arrête quand le mot est trouvé (plus de "_") ou après 7 erreurs.

Correction

import random

mots = ["python", "tableau", "dictionnaire", "fonction", "variable", "boucle", "condition"]
secret = random.choice(mots)
affichage = ["_"] * len(secret)
lettres_essayees = []
erreurs = 0
max_erreurs = 7

print("=== Jeu du Pendu ===")

while erreurs < max_erreurs and "_" in affichage:
    print(f"\nMot : {' '.join(affichage)}")
    print(f"Erreurs : {erreurs}/{max_erreurs}")
    print(f"Lettres essayees : {', '.join(lettres_essayees)}")

    lettre = input("Proposez une lettre : ").lower()

    if len(lettre) != 1 or not lettre.isalpha():
        print("Entrez une seule lettre.")
        continue

    if lettre in lettres_essayees:
        print("Lettre deja essayee !")
        continue

    lettres_essayees.append(lettre)

    if lettre in secret:
        for i in range(len(secret)):
            if secret[i] == lettre:
                affichage[i] = lettre
        print("Bonne lettre !")
    else:
        erreurs += 1
        print("Mauvaise lettre !")

print(f"\nMot : {' '.join(affichage)}")
if "_" not in affichage:
    print(f"Bravo ! Vous avez trouve : {secret}")
else:
    print(f"Perdu ! Le mot etait : {secret}")

---

Activité 3 - Analyse de données (tableaux de dictionnaires)

Objectif

Manipuler un jeu de données structuré sous forme de tableau de dictionnaires pour en extraire des informations.

Données

meteo = [
    {"jour": "Lundi",    "temperature": 18, "pluie": False, "vent": 15},
    {"jour": "Mardi",    "temperature": 22, "pluie": False, "vent": 10},
    {"jour": "Mercredi", "temperature": 15, "pluie": True,  "vent": 35},
    {"jour": "Jeudi",    "temperature": 12, "pluie": True,  "vent": 40},
    {"jour": "Vendredi", "temperature": 20, "pluie": False, "vent": 20},
    {"jour": "Samedi",   "temperature": 25, "pluie": False, "vent": 5},
    {"jour": "Dimanche", "temperature": 23, "pluie": False, "vent": 12}
]

Questions

a. Calculer la température moyenne de la semaine.

b. Trouver le jour le plus chaud et le jour le plus froid.

c. Lister les jours de pluie.

d. Lister les jours où le vent dépasse 25 km/h.

e. Créer un nouveau tableau ne contenant que les jours ensoleillés (sans pluie) avec une température supérieure à 20°C. Quels sont ces jours ?

f. Calculer la température moyenne des jours de pluie et celle des jours sans pluie. Comparer.

Correction

a.

moyenne = sum(j["temperature"] for j in meteo) / len(meteo)
print(f"Temperature moyenne : {moyenne:.1f} C")    # 19.3 C

b.

plus_chaud = max(meteo, key=lambda j: j["temperature"])
plus_froid = min(meteo, key=lambda j: j["temperature"])
print(f"Plus chaud : {plus_chaud['jour']} ({plus_chaud['temperature']} C)")
print(f"Plus froid : {plus_froid['jour']} ({plus_froid['temperature']} C)")
# Plus chaud : Samedi (25 C)
# Plus froid : Jeudi (12 C)

c.

jours_pluie = [j["jour"] for j in meteo if j["pluie"]]
print(f"Jours de pluie : {jours_pluie}")    # ['Mercredi', 'Jeudi']

d.

jours_venteux = [j["jour"] for j in meteo if j["vent"] > 25]
print(f"Jours venteux : {jours_venteux}")    # ['Mercredi', 'Jeudi']

e.

beaux_jours = [j for j in meteo if not j["pluie"] and j["temperature"] > 20]
for j in beaux_jours:
    print(f"{j['jour']} : {j['temperature']} C")
# Mardi : 22 C
# Samedi : 25 C
# Dimanche : 23 C

f.

pluie = [j["temperature"] for j in meteo if j["pluie"]]
soleil = [j["temperature"] for j in meteo if not j["pluie"]]
moy_pluie = sum(pluie) / len(pluie)
moy_soleil = sum(soleil) / len(soleil)
print(f"Moyenne pluie : {moy_pluie:.1f} C")     # 13.5 C
print(f"Moyenne soleil : {moy_soleil:.1f} C")    # 21.6 C

---

Projet final - Le gestionnaire de notes

Objectif

Concevoir un programme complet de gestion de notes de classe en combinant tuples, tableaux et dictionnaires.

Cahier des charges

Le programme gère une classe d'élèves. Chaque élève est un dictionnaire avec son nom, son prénom et un tableau de notes. Le programme propose un menu avec les fonctionnalités suivantes :

=== Gestionnaire de notes ===
1. Afficher la classe
2. Ajouter un élève
3. Ajouter une note à un élève
4. Afficher les statistiques d'un élève
5. Afficher les statistiques de la classe
6. Classement
7. Quitter

Partie A - Structure de données

a. Choisir la structure de données pour représenter la classe. Créer un tableau classe contenant 4 élèves avec 3 notes chacun.

Partie B - Fonctions de base

b. Écrire afficher_classe(classe) qui affiche chaque élève avec ses notes et sa moyenne.

c. Écrire ajouter_eleve(classe, nom, prenom) qui ajoute un élève sans notes.

d. Écrire ajouter_note(classe, nom, note) qui ajoute une note à un élève.

Partie C - Statistiques

e. Écrire stats_eleve(eleve) qui renvoie un tuple (moyenne, minimum, maximum, nombre_de_notes).

f. Écrire stats_classe(classe) qui affiche la moyenne générale, la meilleure et la pire moyenne, le nombre d'élèves au-dessus de 10.

Partie D - Classement

g. Écrire classement(classe) qui affiche les élèves triés par moyenne décroissante.

Partie E - Le menu

h. Assembler le tout dans un menu interactif.

Correction

classe = [
    {"nom": "Dupont", "prenom": "Marie", "notes": [15, 12, 18]},
    {"nom": "Martin", "prenom": "Léo", "notes": [8, 14, 11]},
    {"nom": "Durand", "prenom": "Emma", "notes": [17, 19, 16]},
    {"nom": "Petit", "prenom": "Hugo", "notes": [9, 7, 12]}
]

def moyenne(notes):
    if not notes:
        return 0
    return sum(notes) / len(notes)

def afficher_classe(classe):
    for e in classe:
        moy = moyenne(e["notes"])
        notes_str = ", ".join(str(n) for n in e["notes"])
        print(f"{e['prenom']} {e['nom']} | Notes : [{notes_str}] | Moyenne : {moy:.1f}")

def ajouter_eleve(classe, nom, prenom):
    classe.append({"nom": nom, "prenom": prenom, "notes": []})

def ajouter_note(classe, nom, note):
    for e in classe:
        if e["nom"] == nom:
            e["notes"].append(note)
            return True
    return False

def stats_eleve(eleve):
    notes = eleve["notes"]
    if not notes:
        return (0, 0, 0, 0)
    return (moyenne(notes), min(notes), max(notes), len(notes))

def stats_classe(classe):
    moyennes = [moyenne(e["notes"]) for e in classe if e["notes"]]
    if not moyennes:
        print("Aucune note dans la classe.")
        return
    moy_gen = sum(moyennes) / len(moyennes)
    print(f"Moyenne generale : {moy_gen:.1f}")
    print(f"Meilleure moyenne : {max(moyennes):.1f}")
    print(f"Pire moyenne : {min(moyennes):.1f}")
    au_dessus = sum(1 for m in moyennes if m >= 10)
    print(f"Eleves au-dessus de 10 : {au_dessus}/{len(moyennes)}")

def classement(classe):
    eleves_tries = sorted(classe, key=lambda e: moyenne(e["notes"]), reverse=True)
    for i, e in enumerate(eleves_tries):
        moy = moyenne(e["notes"])
        print(f"{i + 1}. {e['prenom']} {e['nom']} : {moy:.1f}")

# Menu
while True:
    print("\n=== Gestionnaire de notes ===")
    print("1. Afficher la classe")
    print("2. Ajouter un eleve")
    print("3. Ajouter une note")
    print("4. Statistiques d'un eleve")
    print("5. Statistiques de la classe")
    print("6. Classement")
    print("7. Quitter")

    choix = input("Choix : ")

    if choix == "1":
        afficher_classe(classe)
    elif choix == "2":
        nom = input("Nom : ")
        prenom = input("Prenom : ")
        ajouter_eleve(classe, nom, prenom)
        print("Eleve ajoute.")
    elif choix == "3":
        nom = input("Nom de l'eleve : ")
        note = float(input("Note : "))
        if ajouter_note(classe, nom, note):
            print("Note ajoutee.")
        else:
            print("Eleve introuvable.")
    elif choix == "4":
        nom = input("Nom de l'eleve : ")
        for e in classe:
            if e["nom"] == nom:
                moy, mini, maxi, nb = stats_eleve(e)
                print(f"{e['prenom']} {e['nom']}")
                print(f"  Moyenne : {moy:.1f}")
                print(f"  Min : {mini} / Max : {maxi}")
                print(f"  Nombre de notes : {nb}")
                break
        else:
            print("Eleve introuvable.")
    elif choix == "5":
        stats_classe(classe)
    elif choix == "6":
        classement(classe)
    elif choix == "7":
        print("Au revoir !")
        break