Dans quel cas utilise-t-on une boucle « while » plutôt qu'une boucle « for » ?

quand on ne connaît pas à l'avance le nombre de répétitions

quand on veut parcourir une liste élément par élément

quand le programme doit être plus rapide

quand on connaît exactement le nombre de répétitions

Une fonction prend n en paramètre, initialise c à 0, répète n fois un tirage par random.random() en ajoutant 1 à c lorsque le tirage est inférieur à 0,5, puis renvoie c / n. Que représente la valeur renvoyée ?

la fréquence de piles observée sur une simulation de n lancers

la probabilité théorique d'obtenir pile, qui vaut exactement 0,5

le nombre de piles obtenus sur n lancers

l'espérance de la loi binomiale B(n ; 0,5)

Algorithmique et programmation en Python

Terminale · Maths · Algorithmique et programmation

Algorithmique et programmation

Les outils Python indispensables au bac

En terminale, la programmation n'est pas une matière à part : elle apparaît à l'intérieur des exercices d'analyse et de probabilités. On te demande de compléter une fonction, de dire ce qu'elle renvoie, ou de justifier qu'une boucle s'arrête. Cette fiche fait le tour des briques à maîtriser ; la suivante présente les grands algorithmes du programme.

Écriture Python	Ce que ça produit	Remarque
range(5)	0, 1, 2, 3, 4	5 valeurs, on s'arrête AVANT 5
range(1, 5)	1, 2, 3, 4	la borne de droite est exclue
range(0, 10, 2)	0, 2, 4, 6, 8	le troisième argument est le pas
len(L)	le nombre d'éléments de la liste L	une liste vide a une longueur 0
L[0]	le premier élément de L	les indices commencent à 0
L[len(L) - 1]	le dernier élément de L	s'écrit aussi L[-1]
L.append(x)	ajoute x à la fin de la liste L	modifie L, ne renvoie rien
x % 2 == 0	True si x est pair	% est le reste de la division euclidienne
x ** 2	le carré de x	l'exponentiation utilise deux étoiles

Simuler le hasard avec le module random. Après import random, la fonction random.random() renvoie un nombre décimal tiré au hasard dans l'intervalle [0 ; 1[. On l'utilise pour simuler une épreuve de Bernoulli de paramètre p : si le nombre tiré est inférieur à p, on compte un succès, ce qui se produit avec une probabilité exactement égale à p. Répété n fois, cela simule un échantillon de taille n, et la fréquence obtenue estime p — la loi des grands nombres garantit que l'estimation s'améliore quand n grandit.

Les erreurs qui reviennent chaque année

range(n) s'arrête à n − 1, pas à n : range(5) ne contient jamais 5. C'est l'erreur numéro 1 en devoir.
Le premier indice d'une liste est 0, donc le dernier est len(L) − 1. Écrire L[len(L)] provoque une erreur.
Confondre return et print : une fonction qui se contente d'afficher ne renvoie rien d'exploitable.
Placer le return à l'intérieur de la boucle : la fonction s'arrête alors dès le premier tour. Vérifie toujours l'indentation.
Oublier l'initialisation (u = 3 ou s = 0) avant la boucle : la variable n'existe pas encore et le programme plante.
Dans une boucle while, oublier de modifier la variable testée : la condition reste vraie et le programme tourne indéfiniment.
Simulation : deux exécutions donnent des résultats différents, c'est normal. Une estimation par simulation n'est jamais une valeur exacte.

Algorithmique et programmation

Les algorithmes du programme : seuil, dichotomie, simulation

Trois familles d'algorithmes reviennent en boucle dans les sujets de bac : la recherche de seuil pour les suites, la dichotomie pour les équations et l'approximation d'aire pour les intégrales. Les connaître, c'est gagner du temps le jour J.

1. L'algorithme de seuil. Problème type : la suite u est définie par u0 = 1 et u(n+1) = 3 u(n). On cherche le plus petit entier n tel que u(n) dépasse 100. Comme on ne connaît pas d'avance le nombre de tours, on utilise une boucle while.

2. La dichotomie. Elle encadre une solution de l'équation f(x) = 0 sur un intervalle [a ; b], lorsque f est continue et change de signe entre a et b (théorème des valeurs intermédiaires). Le principe : on coupe l'intervalle en deux, on regarde de quel côté se trouve la solution, on recommence. Après n étapes, la longueur de l'intervalle vaut (b − a)/2^n : pour une précision de 10^(−3) sur [0 ; 1], il faut donc résoudre 1/2^n inférieur ou égal à 10^(−3), c'est-à-dire 2^n supérieur ou égal à 1000. Comme 2^9 = 512 et 2^10 = 1024, il faut 10 étapes.

Nombre d'étapes	Longueur de l'intervalle (départ [0 ; 1])	Précision atteinte
0	1	1
1	0,5	5 × 10^(−1)
4	0,0625	environ 6 × 10^(−2)
7	environ 0,0078	environ 8 × 10^(−3)
10	environ 0,00098	inférieure à 10^(−3)
20	environ 0,00000095	inférieure à 10^(−6)

3. Approcher une aire : la méthode des rectangles. Pour approcher l'intégrale de 0 à 1 de f, on découpe [0 ; 1] en n morceaux de largeur 1/n et on additionne les aires des rectangles : la somme (1/n) × [f(0) + f(1/n) + ... + f((n−1)/n)] approche l'intégrale, avec une précision qui s'améliore quand n augmente.

Exercices corrigés

Combien de fois le bloc d'instructions est-il exécuté dans une boucle « for i in range(5) » ?
- A.4 fois
- B.5 foisBonne réponse
- C.6 fois
- D.1 fois
Réponse : B — 5 fois
range(5) parcourt les entiers 0, 1, 2, 3, 4, soit exactement 5 valeurs : le bloc est donc exécuté 5 fois. Le piège est double : la borne 5 est EXCLUE (on ne va jamais jusqu'à 5), mais le comptage démarre à 0, si bien que le nombre total de tours reste bien 5. Retiens la formule : range(n) donne n valeurs, de 0 à n − 1.
Quelles valeurs la variable i prend-elle dans « for i in range(1, 5) » ?
- A.1, 2, 3, 4, 5
- B.0, 1, 2, 3, 4
- C.1, 2, 3, 4Bonne réponse
- D.1, 2, 3, 4, 5, 6
Réponse : C — 1, 2, 3, 4
Avec deux arguments, range(a, b) démarre à a et s'arrête AVANT b. Ici on obtient donc 1, 2, 3, 4, soit 4 valeurs (b − a = 5 − 1 = 4). La borne de droite est toujours exclue en Python, c'est une convention qu'il faut connaître par cœur. Répondre 1, 2, 3, 4, 5 est l'erreur la plus courante : elle vient d'un réflexe mathématique où l'on inclut spontanément les deux bornes.
Dans quel cas utilise-t-on une boucle « while » plutôt qu'une boucle « for » ?
- A.quand on veut parcourir une liste élément par élément
- B.quand le programme doit être plus rapide
- C.quand on connaît exactement le nombre de répétitions
- D.quand on ne connaît pas à l'avance le nombre de répétitionsBonne réponse
Réponse : D — quand on ne connaît pas à l'avance le nombre de répétitions
La boucle while est dite NON BORNÉE : on répète tant qu'une condition reste vraie, sans savoir combien de tours seront nécessaires. C'est exactement la situation d'un algorithme de seuil, où l'on cherche le premier rang dépassant une valeur donnée. À l'inverse, la boucle for est BORNÉE : le nombre de tours est fixé dès le départ par le range, ce qui la rend idéale pour parcourir une liste. La rapidité n'entre pas en jeu dans ce choix.
La suite u est définie par u0 = 3 et u(n+1) = 2 u(n) + 1. On initialise u à 3, puis on répète trois fois l'instruction « u = 2 * u + 1 ». Que vaut u à la fin ?
- A.15
- B.31Bonne réponse
- C.63
- D.10
Réponse : B — 31
Déroulons les trois tours à partir de u = 3. Tour 1 : u = 2 × 3 + 1 = 7. Tour 2 : u = 2 × 7 + 1 = 15. Tour 3 : u = 2 × 15 + 1 = 31. La variable vaut donc 31, ce qui est bien u3. Répondre 15, c'est s'être arrêté après deux tours ; répondre 63, c'est en avoir fait un de trop. Le repère à garder : après n tours de boucle depuis u0, la variable contient un.
On initialise S à 0, puis on exécute « for k in range(1, 11): S = S + k ». Que vaut S à la fin ?
- A.45
- B.10
- C.66
- D.55Bonne réponse
Réponse : D — 55
range(1, 11) parcourt les entiers de 1 à 10 (la borne 11 est exclue). On calcule donc 1 + 2 + ... + 10. On peut utiliser la formule de la somme des premiers entiers : 10 × 11/2 = 55. Répondre 45, c'est avoir sommé de 1 à 9, en croyant que la borne 11 exclut aussi 10. Répondre 66, c'est avoir inclus 11 par erreur. Répondre 10, c'est confondre la somme avec le nombre de tours.
Que contient la liste L après l'instruction « L = [k * k for k in range(4)] » ?
- A.[1, 4, 9, 16]
- B.[0, 1, 4, 9]Bonne réponse
- C.[0, 1, 2, 3]
- D.[1, 4, 9]
Réponse : B — [0, 1, 4, 9]
range(4) parcourt 0, 1, 2, 3, et l'on stocke le carré de chaque valeur : 0² = 0, 1² = 1, 2² = 4, 3² = 9. La liste obtenue est donc [0, 1, 4, 9]. Répondre [1, 4, 9, 16], c'est avoir démarré le parcours à 1 et l'avoir terminé à 4 : les deux bornes sont fausses. Répondre [0, 1, 2, 3], c'est avoir oublié d'élever au carré : c'est la liste des k, pas des k * k.
Une fonction prend n en paramètre, initialise c à 0, répète n fois un tirage par random.random() en ajoutant 1 à c lorsque le tirage est inférieur à 0,5, puis renvoie c / n. Que représente la valeur renvoyée ?
- A.la probabilité théorique d'obtenir pile, qui vaut exactement 0,5
- B.le nombre de piles obtenus sur n lancers
- C.l'espérance de la loi binomiale B(n ; 0,5)
- D.la fréquence de piles observée sur une simulation de n lancersBonne réponse
Réponse : D — la fréquence de piles observée sur une simulation de n lancers
Le compteur c enregistre le nombre de tirages inférieurs à 0,5, c'est-à-dire le nombre de succès simulés, chacun ayant une probabilité 0,5. En divisant par n, on obtient une FRÉQUENCE observée, donc un résultat expérimental qui change à chaque exécution. Ce n'est pas la probabilité théorique 0,5, même si la loi des grands nombres garantit que la fréquence s'en rapproche quand n devient grand. Ce n'est pas non plus c tout seul (le nombre de piles), puisque la fonction divise par n, ni l'espérance n × 0,5, qui vaut n/2 et non un nombre entre 0 et 1.
Quel est l'indice du premier élément d'une liste Python ?
- A.0Bonne réponse
- B.1
- C.−1
- D.la longueur de la liste
Réponse : A — 0
En Python, les indices commencent à 0. Pour une liste L de longueur n, les indices valides vont donc de 0 à n − 1. Conséquence pratique : le dernier élément est L[len(L) − 1], et écrire L[len(L)] provoque une erreur d'exécution. L'indice −1 existe bien en Python, mais il désigne le DERNIER élément, pas le premier.
On pose L = [3, 7, 2, 9]. Que vaut len(L) ?
- A.3
- B.4Bonne réponse
- C.9
- D.21
Réponse : B — 4
La fonction len renvoie le NOMBRE d'éléments de la liste, ici 4 (les valeurs 3, 7, 2 et 9). Répondre 3 confondrait avec le premier élément L[0], et 9 avec le dernier. Répondre 21, c'est calculer la somme des éléments : cela s'obtient avec sum(L), pas avec len(L). Retiens que les indices de cette liste vont de 0 à 3, donc de 0 à len(L) − 1.
On pose L = [2, 5, 8]. Que vaut L[2] ?
- A.2
- B.5
- C.8Bonne réponse
- D.cela provoque une erreur
Réponse : C — 8
Les indices démarrant à 0, on a L[0] = 2, L[1] = 5 et L[2] = 8. La valeur cherchée est donc 8, c'est-à-dire le troisième élément. Répondre 5, c'est appliquer un décalage mathématique où le deuxième élément porterait l'indice 2. Et il n'y a aucune erreur ici : la liste possède 3 éléments, donc les indices 0, 1 et 2 sont tous valides. C'est L[3] qui provoquerait une erreur.
La suite u est définie par u0 = 1 et u(n+1) = 3 u(n). Un algorithme de seuil cherche le plus petit rang n tel que u(n) dépasse 100. Que renvoie-t-il ?
- A.4
- B.81
- C.5Bonne réponse
- D.243
Réponse : C — 5
Calculons les termes : u0 = 1, u1 = 3, u2 = 9, u3 = 27, u4 = 81, u5 = 243. Le premier terme strictement supérieur à 100 est u5 = 243, donc le rang cherché est n = 5. Répondre 4, c'est s'arrêter à u4 = 81, qui ne dépasse pas encore 100. Répondre 243 ou 81, c'est donner la VALEUR du terme au lieu de son RANG : c'est le piège classique de ce type d'exercice, relis toujours ce qui est demandé.
On applique la dichotomie sur l'intervalle [0 ; 1]. Quelle est la longueur de l'intervalle après 4 étapes ?
- A.0,25
- B.0,125
- C.0,0625Bonne réponse
- D.0,5
Réponse : C — 0,0625
Chaque étape divise la longueur par 2. Après n étapes, elle vaut donc (b − a)/2^n = 1/2^4 = 1/16 = 0,0625. Déroulons pour vérifier : 1 puis 0,5 puis 0,25 puis 0,125 puis 0,0625. On atteint bien 0,0625 après la quatrième étape. Répondre 0,5, c'est n'avoir compté qu'une étape ; 0,25 en compte deux et 0,125 en compte trois : le décalage d'un rang est l'erreur la plus fréquente ici.

S'entraîner sur ce chapitre

Ce chapitre compte 36 exercices corrigés dans l'application, avec le suivi de ta progression.

Commencer les exercices