Niveau : Moyen — Durée estimée : 60 min — 10 exercices avec corrections détaillées
Rappel des notions clés
La programmation en Python repose sur la manipulation efficace des structures de données. Une fonction est un bloc de code réutilisable défini par le mot-clé def. Elle permet de structurer ton programme, d'éviter les répétitions et de rendre ton code plus lisible en isolant des tâches spécifiques.
Les listes sont des collections ordonnées et modifiables d'éléments. Tu peux y accéder par leur indice (commençant à 0), ajouter des éléments avec append() ou les parcourir avec une boucle for. Les dictionnaires, quant à eux, stockent des données sous forme de paires clé-valeur, ce qui est idéal pour représenter des objets complexes comme un profil utilisateur ou un inventaire.
Pour manipuler ces structures, les boucles et les conditions sont tes meilleures alliées. La compréhension de liste est également une syntaxe concise et puissante en Python pour créer de nouvelles listes à partir de listes existantes en une seule ligne de code.
Syntaxe de base : def ma_fonction(parametre): return resultat | liste = [1, 2, 3] | dico = {"cle": "valeur"}
Exercices — Niveau Facile
Exercice 1 : Crée une fonction nommée calculer_moyenne qui prend en paramètre une liste de nombres et retourne la moyenne arithmétique de cette liste. Teste ta fonction avec la liste [10, 20, 30, 40].
Correction :
Pour calculer la moyenne, tu dois diviser la somme des éléments par le nombre total d'éléments.
1. Utilise la fonction native sum() pour obtenir le total de la liste.
2. Utilise la fonction native len() pour obtenir le nombre d'éléments.
3. Effectue la division et retourne le résultat.
Code : def calculer_moyenne(nombres): somme = sum(nombres) quantite = len(nombres) return somme / quantite
Résultat pour [10, 20, 30, 40] : 25.0
Exercice 2 : Écris un script qui demande à l'utilisateur de saisir 3 fruits, les stocke dans une liste, puis affiche le deuxième fruit de la liste en majuscules.
Correction :
1. On initialise une liste vide : fruits = [].
2. On utilise une boucle for i in range(3) pour demander trois fois une saisie avec input() et on l'ajoute avec .append().
3. Pour accéder au deuxième élément, on utilise l'indice 1 (car Python commence à 0).
4. On applique la méthode .upper() pour mettre en majuscules.
Résultat : si l'utilisateur saisit "pomme", "banane", "orange", le programme affiche BANANE.
Exercice 3 : Crée un dictionnaire représentant un étudiant avec les clés "nom", "age" et "note". Écris une fonction qui prend ce dictionnaire et affiche : "L'étudiant [nom] a [age] ans".
Correction :
1. Définition du dictionnaire : etudiant = {"nom": "Alice", "age": 20, "note": 15}.
2. Accès aux valeurs : on utilise la syntaxe dictionnaire["cle"].
3. Affichage avec f-string : print(f"L'étudiant {etudiant['nom']} a {etudiant['age']} ans").
Résultat : L'étudiant Alice a 20 ans
Exercices — Niveau Moyen
Exercice 4 : Écris une fonction filtrer_pairs qui prend une liste d'entiers et retourne une nouvelle liste contenant uniquement les nombres pairs, en utilisant une compréhension de liste.
Correction :
La compréhension de liste permet de filtrer élégamment.
1. Syntaxe : [element for element in liste if condition].
2. La condition pour un nombre pair est n % 2 == 0 (le reste de la division par 2 est nul).
Code : return [n for n in liste if n % 2 == 0].
Si la liste est [1, 2, 3, 4, 5, 6], le résultat est [2, 4, 6].
Exercice 5 : Soit un dictionnaire de stocks : {"pommes": 10, "bananes": 5, "oranges": 8}. Écris une fonction qui augmente le stock de "bananes" de 10 et supprime les "pommes" du dictionnaire.
Correction :
1. Modification : stock["bananes"] += 10.
2. Suppression : utilise le mot-clé del ou la méthode .pop().
Code : stock["bananes"] += 10 del stock["pommes"]
Le dictionnaire final est {"bananes": 15, "oranges": 8}.
Exercice 6 : Crée une fonction inverser_chaine qui prend une chaîne de caractères et la retourne inversée (ex: "python" devient "nohtyp") en utilisant le slicing de liste.
Correction :
En Python, les chaînes de caractères peuvent être découpées comme des listes.
1. La syntaxe du slicing est [début:fin:pas].
2. En omettant le début et la fin et en mettant un pas de -1, on parcourt la chaîne à l'envers.
Code : return chaine[::-1].
Résultat : nohtyp
Exercices — Niveau Difficile
Exercice 7 : Écris une fonction qui prend une liste de mots et retourne un dictionnaire où les clés sont les mots et les valeurs sont la longueur de chaque mot. Exemple : ["code", "python"] -> {"code": 4, "python": 6}.
Correction :
1. On initialise un dictionnaire vide resultat = {}.
2. On parcourt la liste avec une boucle : for mot in liste:.
3. Pour chaque mot, on calcule sa longueur avec len(mot) et on l'assigne à la clé : resultat[mot] = len(mot).
4. On peut aussi utiliser une compréhension de dictionnaire : {mot: len(mot) for mot in liste}.
Le résultat est un dictionnaire associant chaque mot à sa taille.
Exercice 8 : Développe un mini-système de gestion de notes. Crée une fonction qui reçoit une liste de dictionnaires (chaque dictionnaire contient "nom" et "note"). La fonction doit retourner le nom de l'élève ayant la meilleure note.
Correction :
1. On initialise deux variables : meilleure_note = -1 et major = "".
2. On parcourt la liste de dictionnaires avec une boucle for.
3. À chaque itération, on compare la note actuelle avec meilleure_note.
4. Si note_actuelle > meilleure_note, on met à jour les deux variables.
5. On retourne major à la fin. C'est un algorithme classique de recherche de maximum.
Exercice 9 : Écris une fonction qui fusionne deux dictionnaires. Si une clé est présente dans les deux, on additionne leurs valeurs. Exemple : d1={"a":1, "b":2}, d2={"b":3, "c":4} -> {"a":1, "b":5, "c":4}.
Correction :
1. On crée une copie du premier dictionnaire : resultat = d1.copy().
2. On parcourt le deuxième dictionnaire avec for cle, valeur in d2.items():.
3. Si la clé existe déjà dans resultat, on fait : resultat[cle] += valeur.
4. Sinon, on crée la clé : resultat[cle] = valeur.
C'est une méthode efficace pour consolider des données.
Exercice 10 : Crée une fonction qui prend une liste d'entiers et retourne une liste sans doublons, triée par ordre décroissant, sans utiliser la fonction set().
Correction :
1. Crée une liste vide unique = [].
2. Parcourt la liste d'origine : for x in liste:.
3. Ajoute x à unique seulement si x not in unique.
4. Utilise la méthode unique.sort(reverse=True) pour trier par ordre décroissant.
Le résultat est une liste propre, unique et ordonnée.
Bilan et conseils
Ce qu'il faut retenir : Pour maîtriser Python, tu dois pratiquer la manipulation des indices de listes et comprendre comment itérer sur les dictionnaires (clés, valeurs, items). N'oublie jamais que les fonctions doivent être pures (une seule tâche) pour rester maintenables.
Comment ORBITECH Peut T'aider
ORBITECH AI Academy met à ta disposition des outils concrets pour réviser plus efficacement et progresser à ton rythme.
- Générateur de Quiz : crée des quiz personnalisés pour tester tes connaissances et identifier tes lacunes.
- Générateur d'Exercices : crée des exercices d'entraînement adaptés à ton niveau avec corrections détaillées.
- Générateur de Résumés : transforme tes cours en fiches de révision claires et structurées.
- Générateur de Mind Maps : visualise et organise tes idées avec des cartes mentales générées automatiquement.
Tous ces outils sont disponibles sur ta plateforme ORBITECH. Connecte-toi et explore ceux qui correspondent le mieux à tes besoins !