# Atelier 4 - Préparation au test CoderPad Cet atelier peut être réalisé en autonomie comme en atelier avec un enseignant. Il n'y a pas d'obligation d'avoir suivi l'atelier précédent en présentiel pour pouvoir participer à cet atelier en présentiel. # 🧪 Exercices d’entraînement **Avant de commencer**, assurez-vous d'avoir visionné le tutoriel d'utilisation de la plateforme **CoderPad** : <div style="position: relative; width: 100%; padding-bottom: 56.25%; height: 0;"> <iframe src="https://www.youtube.com/embed/AFL8X9-JpcI?si=8jIByl5_ISYVKdOD" title="YouTube video player" style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen> </iframe> </div> Lors du test CoderPad, vous pouvez demander la **Cheat Sheet** qui vous sera remise en entrant en salle d'examen : ![[Cheat Sheet Python.png]] Ces exercices vous entraînent au format de l’examen Python réalisé sur **CoderPad**. Chaque fonction possède : - un **nom imposé** ; - un ou plusieurs **paramètres à utiliser** ; - un **retour obligatoire** (utilisez `return`, _pas_ `print`). Le code de base de l'examen ressemble à cela. Il faudra modifier le contenu de la fonction et la valeur retournée pour répondre aux consignes. ```python # Python code below # Use print("messages...") to debug your solution. def nom_fonction(n): # Your code goes here return 0 ``` CoderPad teste la fonction avec un Code de Test de ce type. Seul le paramètre peut être modifié dans ce code, pour tester la fonction avec d'autres valeurs d'entrée et garantir la fiabilité de votre solution. ```python print(nom_fonction(42)) ``` ## 🔹 Exercice 1 — Valeur absolue Écrire la fonction **`valeur_positive(n)`** qui : - prend un entier `n` en paramètre, - renvoie `n` si `n >= 0`, - renvoie `-n` si `n < 0`. ### Exemples - `valeur_positive(5)` ➜ `5` - `valeur_positive(-7)` ➜ `7` - `valeur_positive(0)` ➜ `0` ### Code de départ ```python # Python code below # Use print("messages...") to debug your solution. def valeur_positive(n): # Your code goes here return 0 # À modifier ``` Copiez ce code dans un environnement Python (Notebook), et testez votre solution avec les valeurs fournies (la valeur indiquée en commentaire est le résultat attendu lors du print): ```python print(valeur_positive(5)) # 5 print(valeur_positive(-7)) # 7 print(valeur_positive(0)) # 0 ``` >[!tip]- Corrigé (ne consulter qu'en cas d'extrême urgence) > ```python >def valeur_positive(n): > if n >= 0: > return n > else: > return -n > ``` ## 🔹 Exercice 2 — Trois derniers caractères Écrire la fonction **`trois_derniers(n)`** qui : - prend une chaîne `n` en paramètre, - Retourner les **trois derniers caractères** de cette chaîne. ### Exemples - `trois_derniers("Python")` ➜ `hon` - `trois_derniers("abc")` ➜ `abc` ### Code de départ ```python # Python code below # Use print("messages...") to debug your solution. def trois_derniers(n): # Your code goes here return 0 # À modifier ``` Copiez ce code dans un environnement Python (Notebook), et testez votre solution avec les valeurs fournies (la valeur indiquée en commentaire est le résultat attendu lors du print): ```python print(trois_derniers("Python")) # "hon" print(trois_derniers("abc")) # "abc" ``` >[!tip]- Corrigé (ne consulter qu'en cas d'extrême urgence) > ```python >def trois_derniers(n): > return n[-3:] > ``` ## 🔹 Exercice 3 — Compter les zéros Écrire la fonction **`compter_zero(l)`** qui : - prend une liste `l` en paramètre, - Retourner les **nombre de zéros** dans cette liste. > [!tip] Attention > On compte **uniquement** les éléments **qui sont exactement 0**. > - On **ne compte pas** un nombre qui _contient_ un 0 (ex : `10`, `203`). > - On **ne compte pas** une chaîne contenant `"0"` (ex : `"0"`, `"a0b"`). > - On compte seulement les éléments **égaux au nombre entier 0**. ### Exemples - `compter_zero([0, 1, 0, 3])` ➜ `2` - `compter_zero([1, 2, 3])` ➜ `0` - `compter_zero([10, 203, "0", "a0b"])` ➜ `0` ### Code de départ ```python # Python code below # Use print("messages...") to debug your solution. def compter_zero(n): # Your code goes here return 0 # À modifier ``` Copiez ce code dans un environnement Python (Notebook), et testez votre solution avec les valeurs fournies (la valeur indiquée en commentaire est le résultat attendu lors du print): ```python print(compter_zero([0, 1, 0, 3])) # 2 print(compter_zero([1, 2, 3])) # 0 print(compter_zero([10, 203, "0", "a0b"])) # 0 ``` >[!tip]- Corrigé (ne consulter qu'en cas d'extrême urgence) > ```python >def compter_zero(l): > cpt = 0 > for i in l: > if i==0: > cpt+=1 > return cpt > ``` ## 🔹 Exercice 4 — Compter les éléments supérieurs à une valeur Écrire la fonction **`compter_superieurs(l, seuil)`** qui : - prend une liste `l` en paramètre, - Retourner les **nombre d'éléments supérieurs à** `seuil` dans cette liste. > [!tip] Attention > Tous les éléments de la liste `l` sont des **entiers**. ### Exemples - `compter_superieurs([3, 8, 2, 10], 5)` ➜ `2` (8 et 10) - `compter_superieurs([1, 2, 3], 10)` ➜ `0` - `compter_superieurs([], 4])` ➜ `0` ### Code de départ ```python # Python code below # Use print("messages...") to debug your solution. def compter_superieurs(l,seuil): # Your code goes here return 0 # À modifier ``` Copiez ce code dans un environnement Python (Notebook), et testez votre solution avec les valeurs fournies (la valeur indiquée en commentaire est le résultat attendu lors du print): ```python print(compter_superieurs([3, 8, 2, 10], 5)) # 2 print(compter_superieurs([1, 2, 3], 10)) # 0 print(compter_superieurs([], 4)) # 0 ``` >[!tip]- Corrigé (ne consulter qu'en cas d'extrême urgence) > ```python >def compter_superieurs(l,seuil): > cpt = 0 > for i in l: > if i>seuil: > cpt+=1 > return cpt > ``` ## 🔹 Exercice 5 — Calculer la médiane d’une liste d’entiers Écrire la fonction **`mediane(l)`** qui : - prend une liste `l` d’entiers, - retourne la **médiane** des valeurs. 📌 **Définition simple pour cet exercice :** - si la liste a un nombre impair d’éléments → la médiane est l’élément du milieu après tri, - si la liste a un nombre pair d’éléments → la médiane est la **moyenne des deux éléments du milieu** après tri. - la liste peut être vide → dans ce cas, retourner `None`. ### Exemples - `mediane([3, 1, 2])` ➜ `2` - `mediane([10, 2, 8, 4])` ➜ `6` (moyenne de 4 et 8) - `mediane([5])` ➜ `5` - `mediane([])` ➜ `None` >[!tip] Comment savoir si un nombre est pair ? >Un nombre `n` est **pair** si `n % 2 == 0`. >Exemple : `4 % 2 == 0` → 4 est pair. >Exemple : `5 % 2 == 1` → 5 est impair. > [!tip] Comment trier une liste ? > > - Vous pouvez utiliser la fonction Python **`sorted()`** > `sorted(l)` retourne **une nouvelle liste triée**, sans modifier la liste d’origine. >Exemple : >```python >l = [4, 1, 3] >l2 = sorted(l) # l2 vaut [1, 3, 4] >``` >La liste `l` n’est **pas modifiée**. ### Code de départ ```python # Python code below # Use print("messages...") to debug your solution. def mediane(l): # Your code goes here return None # À modifier ``` Copiez ce code dans un environnement Python (Notebook), et testez votre solution avec les valeurs fournies (la valeur indiquée en commentaire est le résultat attendu lors du print): ```python print(mediane([3, 1, 2])) # 2 print(mediane([10, 2, 8, 4])) # 6 print(mediane([5])) # 5 print(mediane([])) # None ``` >[!tip]- Corrigé (ne consulter qu'en cas d'extrême urgence) > ```python >def mediane(l): > if len(l) == 0: > return None > l2 = sorted(l) > n = len(l2) > milieu = n // 2 > if n % 2 == 1: > return l2[milieu] > else: > return (l2[milieu - 1] + l2[milieu]) / 2 > ``` ## 🗓️ Historique > **Dernière mise à jour :** `21 novembre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]