Avant d'écrire un programme, il faut savoir prévoir ce qu'il affiche. Les 12 exercices corrigés de Python pour la Seconde partent de là : affectations, tests, boucles for et while, recherche de seuil. Ils passent ensuite aux fonctions à plusieurs arguments, aux simulations d'expériences aléatoires et à la lecture d'une fonction qui calcule une moyenne ou un écart type, après 5 questions flash. Chaque affichage donné dans les corrigés est celui que produit réellement Python 3, avec une graine fixée pour les simulations.
Les exercices 10 à 12 simulent des lancers de pièce ou de dés ; la loi des grands nombres explique pourquoi les fréquences se stabilisent quand le nombre de lancers augmente.
Sommaire6 parties
Questions flash : lire du Python
Question 1 : Quotient et reste
print(17 // 5, 17 % 5) affiche :3 23.4 23 3.42 3
Voir le corrigé
// donne le quotient entier 3, % le reste 2. Le nombre 3.4 serait 17 / 5.Question 2 : Valeurs parcourues par range
for k in range(2, 6):, la variable k prend les valeurs :- 2, 3, 4, 5, 6
- 2, 3, 4, 5
- 3, 4, 5
- 2 et 6
Voir le corrigé
Question 3 : Type d’un quotient
10 / 2 est de type :intfloatboolstr
Voir le corrigé
/ renvoie toujours un flottant, ici 5.0, même quand la division tombe juste.Question 4 : Suite d’affectations
x = 5, puis x = x * 2, puis x = x - 3, la variable x vaut :Voir le corrigé
x.Question 5 : Valeurs de randint
randint(1, 4) peut renvoyer :- 1, 2 ou 3
- 0, 1, 2, 3 ou 4
- 1, 2, 3 ou 4
- n'importe quel réel entre 1 et 4
Voir le corrigé
randint renvoie un entier, et ses deux bornes sont incluses, contrairement à range.Niveau 1 : variables, types et affectations
Exercice 1 : Suivre des affectations
x = 4
y = x * 3
x = y - x
y = y // x
print(x, y)- Dresser le tableau de suivi des variables et donner l'affichage.
- Que devient l'affichage si la première ligne est
x = 4.0?
Voir le corrigé
Instruction xyx = 44 y = x * 34 12 x = y - x8 12 y = y // x8 1 Au dernier calcul,xvaut déjà 8 : divisé par donne le quotient entier 1. Affichage :8 1- Les calculs sont les mêmes, mais un flottant contamine tous les résultats qui en dépendent :
x = 4.0 y = x * 3 x = y - x y = y // x print(x, y)8.0 1.0
Exercice 2 : Une puissance mal écrite
def f(x):
return 3*x^2 - 2*x + 1
print(f(2))-7.- Calculer à la main. Le résultat affiché est-il plausible ?
- Corriger la fonction, puis donner les affichages de
f(2)etf(-1). - Pourquoi Python n'a-t-il signalé aucune erreur ?
Voir le corrigé
- . Le programme affiche : il est faux.
- La puissance s'écrit
**:def f(x): return 3*x**2 - 2*x + 1 print(f(2), f(-1))9 6Contrôle : . ^est un opérateur qui existe en Python (le « ou exclusif » sur les écritures binaires), et il est moins prioritaire que+et-. La ligne a été lue comme(3*x) ^ (2 - 2*x + 1), soit6 ^ (-1), qui vaut-7. Le programme est syntaxiquement correct, mais il ne calcule pas ce qu'on veut : seul un calcul de contrôle à la main révèle l'erreur.
Exercice 3 : Opérations, booléens et divisibilité
a = 23 et b = 4. Prévoir la valeur et le type de chaque expression : a // b, a % b, a / b, a > 3*b, a % 2 == 0, a == b*(a//b) + a%b.Voir le corrigé
a = 23
b = 4
print(a // b, a % b, a / b, a > 3*b, a % 2 == 0, a == b*(a//b) + a%b)
5 3 5.75 True False Truea // bvaut 5 eta % bvaut 3 (entiers), car .a / bvaut5.75(flottant).a > 3*bcompare 23 et 12 :True(booléen).a % 2 == 0teste si 23 est pair :False.- La dernière expression traduit la division euclidienne : elle vaut
Truepour tous entiers et .
Niveau 2 : conditions et boucles
Exercice 4 : Frais de livraison
- Écrire une fonction
livraison(montant, express), oùexpressest un booléen, qui renvoie les frais. - Donner les valeurs renvoyées pour
(35, False),(60, True),(50, False)et(49.99, True). - Que changerait l'écriture
if montant > 50:? Quel cas de la question 2 permet de le voir ?
Voir le corrigé
- Deux tests successifs et indépendants : le seuil, puis l'option.
def livraison(montant, express): if montant >= 50: frais = 0 else: frais = 4.9 if express: frais = frais + 2 return frais print(livraison(35, False), livraison(60, True), livraison(50, False), livraison(49.99, True)) -
4.9 2 0 6.9Un booléen peut servir directement de condition :if express:équivaut àif express == True:. - Avec
>, un achat d'exactement 50 € paierait 4,90 € alors que l'énoncé dit « dès 50 € ». Le caslivraison(50, False)renverrait4.9au lieu de0. Il faut toujours tester la valeur frontière.
Exercice 5 : Somme des nombres impairs
range(a, b, p) parcourt les entiers de a à b exclu, avec un pas p : par exemple range(1, 10, 2) donne 1, 3, 5, 7, 9.- Écrire un programme qui calcule et donner le résultat.
- Combien de termes comporte cette somme ? Comparer avec le carré de ce nombre.
- Modifier le programme pour calculer .
Voir le corrigé
- Un accumulateur initialisé à 0 :
s = 0 for k in range(1, 100, 2): s = s + k print(s)2500La borne 100 est exclue, mais 99 est bien atteint ;range(1, 101, 2)donnerait le même résultat. - Les impairs de 1 à 99 sont les pour de 1 à 50 : il y a 50 termes, et . On peut le vérifier sur de petits cas : , .
- On change seulement la boucle :
s = 0 for k in range(2, 101, 2): s = s + k print(s)2550Ici la borne doit être 101 pour inclure 100. Contrôle : chaque pair dépasse l'impair qui le précède de 1, donc la somme vaut .
Exercice 6 : Chercher un seuil avec while
- Compléter le programme en remplaçant les pointillés, puis donner son affichage.
u = 120 n = 0 while ...: u = ... n = n + 1 print(n, round(u, 2)) - Vérifier le résultat avec les valeurs successives de , arrondies au centième.
- Un élève écrit
while u > 250:. Qu'affiche son programme, et pourquoi ?
Voir le corrigé
- La condition est celle qui permet de continuer : tant que l'effectif ne dépasse pas 250.
u = 120 n = 0 while u <= 250: u = 1.08 * u + 5 n = n + 1 print(n, round(u, 2))7 250.27 - Valeurs successives : 120 ; 134,6 ; 150,37 ; 167,4 ; 185,79 ; 205,65 ; 227,1 ; 250,27. La septième valeur est la première au-dessus de 250 : l'effectif dépasse 250 au bout de 7 semaines.
- Au départ, , donc
u > 250est faux : la boucle ne s'exécute pas du tout et le programme affiche0 120. L'élève a écrit la condition d'arrêt au lieu de la condition pour continuer.
Exercice 7 : Une boucle qui ne s’arrête pas
n = 0
p = 1
while p <= 1000:
n = n + 1
print(n)- Expliquer pourquoi la boucle est infinie.
- Corriger le programme et donner son affichage.
- Remplacer
<=par<change-t-il le résultat ici ? - On cherche maintenant le plus petit tel que . Comparer les résultats avec
<=et avec<, et dire lequel est correct.
Voir le corrigé
- La condition porte sur
p, qui vaut toujours 1 : rien ne la modifie dans la boucle. La condition reste vraie indéfiniment. - On double
pà chaque tour, de sorte quepvaut :n = 0 p = 1 while p <= 1000: p = 2 * p n = n + 1 print(n)10Contrôle : et . - Non : les deux conditions ne diffèrent que si
pvaut exactement 1000, ce qui n'arrive jamais, 1000 n'étant pas une puissance de 2. - Avec le seuil 1024,
while p <= 1024:donne 11, etwhile p < 1024:donne 10. On veut : or n'est pas strictement supérieur à 1024. La bonne réponse est 11, obtenue avec<=, qui est exactement la négation de la condition d'arrêt .
Niveau 3 : fonctions, simulations et statistiques
Exercice 8 : Approcher un minimum par balayage
def f(x):
return x**2 - 3*x + 1
def minimum_approche(a, b, n):
pas = (b - a) / n
xmin = a
for k in range(n + 1):
x = a + k * pas
if f(x) < f(xmin):
xmin = x
return xmin- Quelles valeurs de sont testées par
minimum_approche(0, 3, 30)? Que contientxminà la fin ? - Donner l'affichage de
print(round(minimum_approche(0, 3, 30), 2), round(f(minimum_approche(0, 3, 30)), 2)). - Démontrer que le minimum de sur vaut bien .
Voir le corrigé
- Le pas vaut ; les valeurs testées sont , , , …, (31 valeurs, d'où
range(n + 1)). À chaque tour, si est plus petit que la plus petite valeur trouvée jusque-là,xminest remplacé par : à la fin,xminest l'abscisse testée où est minimale. -
print(round(minimum_approche(0, 3, 30), 2), round(f(minimum_approche(0, 3, 30)), 2))1.5 -1.25 - On fait apparaître un carré : . Un carré est positif ou nul, donc , avec égalité seulement pour . Le balayage tombe ici sur la valeur exacte parce que est un multiple du pas ; en général, il ne donne qu'une valeur approchée.
Exercice 9 : Le plus grand multiple inférieur à un nombre
- Écrire une fonction
plus_grand_multiple(a, b)qui part de 0 et ajoute tant que c'est possible. - Donner les résultats pour
(7, 100),(7, 5)et(6, 42). - Justifier que
b - b % adonne le même résultat, sans boucle.
Voir le corrigé
- On ajoute tant que le multiple suivant ne dépasse pas :
def plus_grand_multiple(a, b): m = 0 while m + a <= b: m = m + a return m print(plus_grand_multiple(7, 100), plus_grand_multiple(7, 5), plus_grand_multiple(6, 42)) -
98 0 42et . Pour , aucun multiple non nul ne convient : la boucle ne tourne pas et 0 est renvoyé. Pour , 42 est lui-même multiple de 6 : la condition large<=permet de l'atteindre. - Par division euclidienne, avec , et
b % avaut . Doncb - b % avaut , un multiple de inférieur ou égal à , et le multiple suivant dépasse puisque . Pour : .
Exercice 10 : Simuler des lancers de pièce
from random import randint, seed
def lancer_piece():
return randint(0, 1)
def nb_piles(n):
nb = 0
for i in range(n):
nb = nb + lancer_piece()
return nb
seed(7)
for n in [10, 1000, 100000]:
p = nb_piles(n)
print(n, p, p / n)10 3 0.3
1000 489 0.489
100000 49864 0.49864- Que renvoie
lancer_piece()? Expliquer pourquoinb_piles(n)compte le nombre de piles, si l'on code pile par 1. - Quelles valeurs
nb_piles(10)peut-il renvoyer ? - Interpréter la troisième colonne de l'affichage.
Voir le corrigé
lancer_piece()renvoie 0 ou 1, chacun avec la probabilité . Ajouter le résultat ànbl'augmente de 1 pour un pile et ne le change pas pour un face : après tours,nbest le nombre de piles.- Tout entier de 0 à 10. Les valeurs extrêmes sont possibles mais rares : 0 n'arrive qu'avec dix faces de suite.
- C'est la fréquence des piles. Sur 10 lancers, elle vaut 0,3, loin de 0,5 ; sur 100 000 lancers, elle vaut , très proche de . C'est la loi des grands nombres : plus on répète l'expérience, plus la fréquence a tendance à se rapprocher de la probabilité. Avec une autre graine, les valeurs changeraient, pas cette tendance.
Exercice 11 : Somme de deux dés, un modèle à ne pas raccourcir
- Écrire une fonction
somme_deux_des()qui renvoie la somme de deux dés, puis une fonctionfrequence_sept(n)qui renvoie la fréquence des sommes égales à 7 sur lancers. - Calculer la probabilité d'obtenir 7 à l'aide d'un tableau des 36 issues équiprobables.
- Un élève remplace
somme_deux_des()parrandint(2, 12), « puisque la somme est entre 2 et 12 ». Avec la graine 3 et 10 000 lancers, sa fréquence vaut0.0993, contre0.1678avec la bonne fonction. Expliquer l'erreur.
Indication
Voir le corrigé
- Une fonction pour une expérience, une autre pour la répétition :
from random import randint, seed def somme_deux_des(): return randint(1, 6) + randint(1, 6) def frequence_sept(n): nb = 0 for i in range(n): if somme_deux_des() == 7: nb = nb + 1 return nb / n seed(3) print(frequence_sept(10000))0.1678 - Les 36 couples (dé 1, dé 2) sont équiprobables. La somme vaut 7 pour , , , , , : 6 issues. Donc , proche de la fréquence simulée.
randint(2, 12)rend les 11 sommes équiprobables, chacune de probabilité : c'est ce que reflète la fréquence . Or les sommes ne sont pas équiprobables : 2 ne s'obtient que par , soit , alors que 7 s'obtient de six façons. Le programme simule une autre expérience que celle de l'énoncé. Pour simuler, on reproduit le mécanisme réel (deux dés), pas seulement l'ensemble des résultats possibles.
Exercice 12 : Lire une fonction qui renvoie une moyenne et un écart type
from random import randint, seed
from math import sqrt
def stats_des(n):
s = 0
s2 = 0
for i in range(n):
x = randint(1, 6)
s = s + x
s2 = s2 + x**2
m = s / n
return round(m, 3), round(sqrt(s2 / n - m**2), 3)
seed(10)
print(stats_des(100000))(3.494, 1.704)- Que contiennent
sets2à la fin de la boucle ? - Expliquer pourquoi la fonction renvoie la moyenne et l'écart type des résultats.
- On remplace
x = randint(1, 6)parx = 4. Que renvoiestats_des(10)? Est-ce cohérent ? - Interpréter l'affichage obtenu.
Voir le corrigé
sest la somme des résultats,s2la somme de leurs carrés : à chaque tour, le résultat est ajouté àset às2.m = s / nest la moyenne des résultats.s2 / nest la moyenne des carrés, doncsqrt(s2 / n - m**2)est l'écart type, d'après la formule admise. Les résultats ne sont jamais stockés : deux accumulateurs suffisent.- Tous les résultats valent 4 : , , et .
from math import sqrt def stats_constante(n): s = 0 s2 = 0 for i in range(n): x = 4 s = s + x s2 = s2 + x**2 m = s / n return round(m, 3), round(sqrt(s2 / n - m**2), 3) print(stats_constante(10))(4.0, 0.0)C'est cohérent : une série constante a pour moyenne cette constante et ne présente aucune dispersion. Tester un programme sur un cas dont on connaît la réponse est un bon moyen de le valider. - Sur 100 000 lancers, la moyenne est , proche de , moyenne des six faces ; l'écart type mesure la dispersion des résultats autour de cette moyenne. Avec un très grand nombre de lancers, il se stabilise lui aussi, vers environ .
Problème de synthèse : un plan d’épargne
Problème : combien d’années pour atteindre 5 000 euros ?
- Calculer et . Justifier que l'on passe de à en multipliant par puis en ajoutant 100.
- Écrire une fonction
capital(n), avec une bouclefor, qui renvoie arrondi au centième. Vérifier avec la question 1. - Écrire une fonction
annees(objectif, taux), avec une bouclewhile, qui renvoie le nombre d'années nécessaires pour que le capital atteigne au moinsobjectif, le taux étant donné en pourcentage. - Que renvoient
annees(5000, 3)etannees(5000, 4)? Vérifier le premier résultat aveccapital. - Sans la boucle, expliquer pourquoi pour tout .
Indication
Voir le corrigé
- Les intérêts d'une année valent 3 % du capital : , puis on ajoute 100. et .
-
def capital(n): c = 2000 for k in range(n): c = 1.03 * c + 100 return round(c, 2) print(capital(1), capital(2))2160.0 2324.8 - Le nombre d'années est inconnu d'avance, d'où la boucle
while; on continue tant que l'objectif n'est pas atteint.def annees(objectif, taux): c = 2000 n = 0 while c < objectif: c = c * (1 + taux / 100) + 100 n = n + 1 return n print(annees(5000, 3), annees(5000, 4)) -
16 14À 3 %, il faut 16 ans ; à 4 %, 14 ans. Vérification :print(capital(15), capital(16))4975.83 5225.1Le capital est encore sous 5 000 € après 15 ans et le dépasse après 16 ans : 16 est bien le premier rang qui convient. - Sans les versements, le capital serait multiplié par chaque année et vaudrait . Les versements de 100 € ne font qu'ajouter des sommes positives, qui rapportent elles-mêmes des intérêts : le capital réel est donc au moins égal à . On contrôle pour : .