Entraînement et Remédiation — Programmation Python
Ce document propose des exercices d'entraînement parallèles à l'évaluation pour consolider les notions clés vues pendant la correction.
Exercice 1 — Analyse et compréhension de code
On considère les trois fonctions suivantes :
def fct_A(n: int) -> int:
total = 0
while n != 0:
total = total + 2
n = n - 1
return total
def fct_B(a: int, b: int) -> int:
resultat = a
while b != 0:
resultat = resultat - 1
b = b - 1
return resultat
def fct_C(n: int) -> int:
compteur = 0
while n > 0:
n = n // 10
compteur = compteur + 1
return compteur
- Quels sont les paramètres de la fonction
fct_Bainsi que leurs types ? - Quel est le type de la valeur renvoyée par chacune de ces trois fonctions ?
- Pour la fonction
fct_A, quelle est la valeur de la variabletotalavant d'entrer dans la bouclewhile? - Pour la fonction
fct_C, quelle est la condition pour que la bouclewhilecontinue à tourner ? Quelle condition provoque l'arrêt ? - Pour la fonction
fct_B, comment évolue la variableresultatà chaque itération (tour de boucle) ? - Compléter le tableau d'exécution suivant :
| Fonction | Paramètre(s) | Résultat renvoyé |
|---|---|---|
fct_A |
n = 4 |
|
fct_A |
n = 0 |
|
fct_B |
a = 7, b = 3 |
|
fct_B |
a = 5, b = 0 |
|
fct_C |
n = 354 |
|
fct_C |
n = 9 |
- Quel est le rôle mathématique ou algorithmique de chacune de ces trois fonctions ?
Exercice 2 — Boucles for et calculs cumulés
Partie A : Produit des entiers (Factorielle)
Écrire une fonction produit_entiers(n: int) -> int qui prend en paramètre un nombre entier strictement positif n et renvoie le produit de tous les entiers de 1 à n inclus :
⚠️ Contraintes :
- Utiliser une boucle
foravec la fonctionrange(). - Utiliser une variable accumulatrice bien initialisée.
def produit_entiers(n: int) -> int:
# À compléter
Exemples attendus :
print(produit_entiers(3)) # Affiche 6 (car 1 * 2 * 3 = 6)
print(produit_entiers(5)) # Affiche 120 (car 1 * 2 * 3 * 4 * 5 = 120)
print(produit_entiers(1)) # Affiche 1
Partie B : Somme des entiers pairs
Écrire une fonction somme_pairs(n: int) -> int qui prend en paramètre un nombre entier positif n et renvoie la somme de tous les entiers pairs compris entre 1 et n inclus.
⚠️ Contraintes et rappel :
- Utiliser une boucle
foravecrange(). - Tester si chaque entier est pair à l'aide de l'opérateur modulo
% 2 == 0et d'une conditionif. - Accumuler la somme des nombres vérifiant la condition.
def somme_pairs(n: int) -> int:
# À compléter
Exemples attendus :
print(somme_pairs(6)) # Affiche 12 (car 2 + 4 + 6 = 12)
print(somme_pairs(7)) # Affiche 12 (car 2 + 4 + 6 = 12)
print(somme_pairs(10)) # Affiche 30 (car 2 + 4 + 6 + 8 + 10 = 30)
Exercice 3 — Arithmétique entière et division euclidienne
Partie A : Rendu de monnaie
Un distributeur automatique doit rendre un montant entier en euros en utilisant le moins de pièces et billets possible. Il dispose de :
- Billets de 20 €
- Pièces de 2 €
- Pièces de 1 €
Compléter la fonction rendre_monnaie(montant: int) :
def rendre_monnaie(montant: int):
billets_20 = montant // 20
reste = montant % 20
pieces_2 = ... # À compléter
pieces_1 = ... # À compléter
print("Billets de 20€ :", billets_20, "| Pièces de 2€ :", pieces_2, "| Pièces de 1€ :", pieces_1)
Exemples attendus :
rendre_monnaie(47) # Affiche : Billets de 20€ : 2 | Pièces de 2€ : 3 | Pièces de 1€ : 1
rendre_monnaie(15) # Affiche : Billets de 20€ : 0 | Pièces de 2€ : 7 | Pièces de 1€ : 1
Partie B : Algorithme avec boucle while (soustractions successives)
On souhaite savoir combien de fois on peut soustraire un pas p > 0 à un nombre n >= 0 tant que n >= p. Cela correspond à la division entière de n par p réalisée à l'aide d'une boucle while.
Écrire une fonction nb_soustractions(n: int, p: int) -> int :
def nb_soustractions(n: int, p: int) -> int:
compteur = 0
while ... :
# À compléter
return compteur
Exemple : pour n = 14 et p = 3 :
14 - 3 = 11(1ère soustraction)11 - 3 = 8(2ème soustraction)8 - 3 = 5(3ème soustraction)5 - 3 = 2(4ème soustraction)2 < 3$\rightarrow$ arrêt.- Le résultat renvoyé est
4.
Exercice 4 — Conditions et programme interactif
Partie 1 : Fonction de décision
Écrire une fonction categorie_sport(age: int) -> str qui prend en paramètre l'âge d'un adhérent et renvoie :
"Erreur : âge invalide"siage < 0ouage > 120."Senior"siage >= 18."Junior"si14 <= age < 18."Cadet"si10 <= age < 14."Poussin"si0 <= age < 10.
def categorie_sport(age: int) -> str:
# À compléter
Partie 2 : Programme interactif complet
Écrire un programme Python complet qui :
- Demande le prénom du sportif à l'utilisateur (
input()). - Demande son âge à l'utilisateur (
input()). - Convertit l'âge saisi en nombre entier (
int(...)). - Appelle la fonction
categorie_sportpour déterminer sa catégorie. - Affiche le récapitulatif sous la forme :
"Sportif <prenom> (<age> ans) : Catégorie <categorie>"
🌟 Exercice Bonus : Contrôle d'accès par mot de passe
Écrire une fonction verifier_mot_de_passe(bon_mdp: str) qui demande à un utilisateur de saisir un mot de passe avec les règles suivantes :
- L'utilisateur a au maximum 3 tentatives.
- Tant que la saisie est incorrecte et qu'il reste des tentatives :
- Afficher
"Mot de passe incorrect !" - Indiquer le nombre d'essais restants.
- Si le mot de passe saisi correspond à
bon_mdp, la boucle s'arrête immédiatement et le programme affiche :
"Accès autorisé !" - Si les 3 tentatives sont épuisées sans succès, afficher :
"Compte verrouillé : trop de tentatives échouées."
def verifier_mot_de_passe(bon_mdp: str):
# À compléter
Exemple d'exécution :
>>> verifier_mot_de_passe("secret123")
Entrez le mot de passe : test
Mot de passe incorrect ! (2 essais restants)
Entrez le mot de passe : secret123
Accès autorisé !