Compléter un programme avec une boucle

[enonce]
Une association récolte des dons. Chaque semaine, le montant collecté augmente de $3$ euros : $3$ euros la première semaine, $6$ euros la deuxième, $9$ euros la troisième, et ainsi de suite jusqu'à la dixième semaine.

On souhaite écrire un programme Python qui calcule le total récolté au bout des $10$ semaines, c'est-à-dire la somme $3 + 6 + 9 + \ldots + 30$. Le programme est donné à trous : il s'agit de le compléter ligne par ligne, puis d'anticiper son affichage.
[/enonce]

[etape]
On hésite entre une boucle for et une boucle while pour parcourir les $10$ semaines. Quel type de boucle convient le mieux ici ?
[qcm]
[option correct="true"]Une boucle for[/option]
[option]Une boucle while[/option]
[option]Les deux sont impossibles ici[/option]
[reponse statut="correct"]Exactement !
Le nombre de répétitions est connu d'avance : $10$ semaines.
Une boucle for avec range est donc la plus adaptée, car elle est faite pour répéter un nombre de fois fixé à l'avance.[/reponse]
[reponse motif="Une boucle while"]Une boucle while reste possible techniquement, mais elle n'est pas la plus naturelle ici.
Repenser à la question décisive : connaît-on à l'avance le nombre de tours à effectuer ?[/reponse]
[reponse statut="incorrect"]Les deux types de boucles peuvent répéter des instructions.
Se demander lequel est le plus adapté quand le nombre de répétitions est connu dès le départ.[/reponse]
[/qcm]
[/etape]

[etape]
Avant la boucle, il faut préparer la variable qui contiendra le total récolté. On la nomme S. Écrire la ligne d'initialisation de S.
[code-python id="init" attendu="S = 0"]
[reponse statut="correct"]Correct !
Comme aucun euro n'a encore été ajouté, le total démarre à $0$.[/reponse]
[reponse motif="S == 0"]Le double signe == sert à comparer deux valeurs, pas à affecter une valeur à une variable.[/reponse]
[reponse motif="S = 1"]Vérifier la valeur de départ : combien la somme contient-elle avant le premier ajout ?[/reponse]
[reponse statut="incorrect"]On affecte une valeur de départ à S avec le signe = simple.
Quelle valeur neutre choisir pour une somme qui n'a encore rien accumulé ?[/reponse]
[aide essai="2"]Pour une somme, la valeur de départ doit être neutre : ajouter cette valeur ne change rien au total.[/aide]
[aide essai="3"]La ligne est de la forme S = ...... est la valeur de départ d'une somme.[/aide]
[/code-python]
[solution]

S = 0

[/solution]
[/etape]

[etape]
La boucle est écrite for i in range(1, ...) de façon à ce que i prenne successivement les valeurs $1, 2, 3, \ldots, 10$. Par quelle valeur faut-il remplacer les pointillés pour que la borne supérieure $10$ soit bien parcourue ?
[math id="borne" attendu="11"]
[reponse statut="correct"]Exactement !
Avec range(1, 11), la valeur $11$ est exclue : i parcourt donc bien $1, 2, \ldots, 10$.[/reponse]
[reponse motif="10"]Avec range, la borne supérieure indiquée n'est jamais atteinte : elle est exclue. Vérifier si $10$ serait alors parcouru.[/reponse]
[reponse statut="incorrect"]Penser à la règle des bornes de range(a, b) : la première est incluse, la seconde est exclue.[/reponse]
[aide essai="2"]Dans range(a, b), les valeurs vont de a inclus jusqu'à b exclu.[/aide]
[aide essai="3"]Pour que le dernier tour utilise $i = 10$, la borne supérieure doit valoir un de plus que $10$.[/aide]
[/math]
[solution]La borne supérieure doit valoir $\mathbf{11}$ : avec range(1, 11), la variable i prend les valeurs $1, 2, \ldots, 10$, car $11$ est exclu.[/solution]
[/etape]

[etape]
À chaque tour de boucle, le montant de la semaine vaut $3 \times i$ euros (semaine $1$ : $3$, semaine $2$ : $6$, etc.). Écrire la ligne, à l'intérieur de la boucle, qui ajoute ce montant au total S.
[code-python id="accu" attendu="S = S + 3*i" indent="1" variantes="S = S + 3 * i || S = 3*i + S || S += 3*i"]
[reponse statut="correct"]Bien vu !
À chaque tour, le total est augmenté du montant de la semaine, ce qui réalise l'accumulation des dons.[/reponse]
[reponse motif="S = 3*i"]Cette ligne écrase le total à chaque tour au lieu de l'augmenter : il faut repartir de la valeur déjà accumulée dans S.[/reponse]
[reponse motif="S = S + i"]Le montant ajouté n'est pas i mais le montant de la semaine. Relire comment ce montant se calcule à partir de i.[/reponse]
[reponse statut="incorrect"]On veut ajouter le montant de la semaine au total déjà obtenu : la ligne réutilise donc S dans son calcul.[/reponse]
[aide essai="2"]Le principe d'accumulation : S = S + (terme à ajouter). Ici le terme est le montant de la semaine.[/aide]
[aide essai="3"]Le montant de la semaine s'écrit 3*i. La ligne réutilise l'ancienne valeur de S.[/aide]
[/code-python]
[solution]

S = S + 3*i

[/solution]
[/etape]

[etape]
Le programme complet est donc :

S = 0
for i in range(1, 11):
    S = S + 3*i
print(S)

Quelle valeur s'affiche à l'écran à la fin de l'exécution ?
[math id="total" attendu="165"]
[reponse statut="correct"]Parfait !
La boucle ajoute $3, 6, 9, \ldots, 30$, dont la somme vaut $165$ : c'est le total affiché par print(S).[/reponse]
[reponse motif="30"]$30$ est le montant de la dernière semaine, pas le total accumulé sur les dix semaines.[/reponse]
[reponse motif="55"]$55$ est la somme $1 + 2 + \ldots + 10$. Or chaque terme ajouté n'est pas i mais le montant de la semaine.[/reponse]
[reponse motif="150"]Recompter le nombre de termes : la boucle effectue bien dix tours, de la semaine $1$ à la semaine $10$.[/reponse]
[reponse statut="incorrect"]Additionner les dix montants successifs, ou remarquer qu'ils sont tous multiples de $3$.[/reponse]
[aide essai="2"]Les montants ajoutés sont $3, 6, 9, \ldots, 30$. On peut factoriser par $3$.[/aide]
[aide essai="3"]La somme vaut $3 \times (1 + 2 + \ldots + 10)$. Calculer d'abord la parenthèse.[/aide]
[/math]
[solution]Les montants ajoutés sont $3, 6, 9, \ldots, 30$, soit $3 \times (1 + 2 + \ldots + 10) = 3 \times 55$.
Le programme affiche donc $\mathbf{165}$.[/solution]
[/etape]

[etape]
On modifie maintenant le projet : l'association veut savoir au bout de combien de semaines le total récolté atteint ou dépasse $100$ euros. Cette fois, le nombre de tours n'est plus connu d'avance. Quel type de boucle est désormais le plus adapté ?
[qcm]
[option]Une boucle for avec range[/option]
[option correct="true"]Une boucle while[/option]
[option]Aucune boucle n'est nécessaire[/option]
[reponse statut="correct"]Tout à fait !
On ne sait pas d'avance combien de semaines seront nécessaires pour atteindre $100$ euros : on répète tant que le total reste inférieur au seuil.
C'est exactement le rôle d'une boucle while.[/reponse]
[reponse motif="Une boucle for avec range"]Une boucle for demande de fixer à l'avance le nombre de tours. Or ici, c'est précisément ce nombre que l'on cherche.[/reponse]
[reponse statut="incorrect"]Il faut bien répéter une addition plusieurs fois.
Comme le nombre de répétitions dépend d'un seuil à atteindre, se demander quelle boucle s'arrête sur une condition.[/reponse]
[/qcm]
[solution]Le nombre de tours dépend d'un seuil à franchir et n'est pas connu d'avance : on utilise une boucle while, qui répète tant que la condition « total inférieur à $100$ » est vraie.
En suivant les totaux successifs $3, 9, 18, 30, 45, 63, 84, 108$, le seuil de $100$ euros est dépassé au bout de $8$ semaines.[/solution]
[/etape]

QCM : Analyse fine des boucles en Python

[enonce]
Ce QCM propose une analyse fine des boucles Python : pièges de bornes, compteurs complexes, boucles while délicates et choix entre for et while. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Dans la boucle for i in range(1, 10) :, quelle est la plus grande valeur prise par i ?
[qcm]
[option]$10$[/option]
[option correct="true"]$9$[/option]
[option]$11$[/option]
[option]$1$[/option]
[reponse statut="correct"]Exact !
La borne supérieure de range(a, b) est exclue. Pour range(1, 10), la variable i parcourt $1, 2, 3, \ldots, 9$. La plus grande valeur est donc $9$.[/reponse]
[reponse motif="$10$"]Non.
Piège classique : la borne supérieure $10$ n'est pas atteinte par i. La séquence s'arrête une unité avant la borne.[/reponse]
[reponse motif="$11$"]Non.
$11$ n'apparaît jamais dans range(1, 10) : la séquence va de $1$ à $9$ inclus.[/reponse]
[reponse motif="$1$"]Non.
$1$ est la plus petite valeur prise par i, pas la plus grande. La question porte sur la plus grande.[/reponse]
[reponse statut="incorrect"]Non.
Règle à retenir : range(a, b) parcourt de $a$ à $b - 1$.[/reponse]
[/qcm]
[/etape]

[etape]
Dans les situations suivantes, laquelle exige une boucle while plutôt qu'une boucle for ?
[qcm]
[option]Afficher les $20$ premiers carrés parfaits[/option]
[option]Calculer la somme $1 + 2 + \ldots + 100$[/option]
[option correct="true"]Trouver le plus petit entier $n$ tel que $2^n > 10^6$[/option]
[option]Afficher chaque élément d'une liste donnée[/option]
[reponse statut="correct"]Bonne réponse !
On ne connaît pas à l'avance la valeur de $n$ ; on ne peut donc pas fixer le nombre de tours dans un range. La boucle while est adaptée : on répète tant que $2^n \leqslant 10^6$.[/reponse]
[reponse motif="Afficher les $20$ premiers carrés parfaits"]Non.
Le nombre de répétitions est connu ($20$). On peut donc utiliser for i in range(1, 21) : la boucle for est plus simple.[/reponse]
[reponse motif="Calculer la somme $1 + 2 + \ldots + 100$"]Non.
Le nombre de termes est fixé ($100$). Une boucle for i in range(1, 101) convient parfaitement.[/reponse]
[reponse motif="Afficher chaque élément d'une liste donnée"]Non.
Parcourir une liste dont on connaît les éléments est typiquement le rôle d'une boucle for.[/reponse]
[reponse statut="incorrect"]Non.
Règle : for si le nombre de tours est connu à l'avance, while sinon.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

c = 0
for i in range(100) :
    if i % 7 == 0 :
        c = c + 1
print(c)

Que s'affiche-t-il ?
[qcm]
[option]$14$[/option]
[option correct="true"]$15$[/option]
[option]$7$[/option]
[option]$100$[/option]
[reponse statut="correct"]Bravo !
Les multiples de $7$ entre $0$ et $99$ sont $0, 7, 14, 21, \ldots, 98$. Le dernier est $98 = 7 \times 14$, mais $0 = 7 \times 0$ est aussi compté. Il y en a donc $14 + 1 = 15$.[/reponse]
[reponse motif="$14$"]Non.
Vous avez oublié de compter $0$, qui est bien divisible par $7$ ($0 = 7 \times 0$). Python considère que $0 \% 7 = 0$, donc $0$ vérifie la condition.[/reponse]
[reponse motif="$7$"]Non.
$7$ est le plus petit multiple non nul de $7$ rencontré, mais la question porte sur le nombre total de multiples de $7$ entre $0$ et $99$.[/reponse]
[reponse motif="$100$"]Non.
$100$ est le nombre total de valeurs parcourues par i, pas le nombre de celles qui vérifient la condition.[/reponse]
[reponse statut="incorrect"]Non.
Les multiples de $7$ entre $0$ et $99$ sont $0, 7, 14, \ldots, 98$. Compter en incluant $0$.[/reponse]
[/qcm]
[/etape]

[etape]
On considère le programme Python ci-dessous :

i = 0
while i < 10 :
    print(i)

Que se passe-t-il lors de l'exécution ?
[qcm]
[option]Le programme affiche $0, 1, 2, \ldots, 9$ puis s'arrête[/option]
[option]Le programme n'affiche rien[/option]
[option correct="true"]Le programme affiche $0$ indéfiniment (boucle infinie)[/option]
[option]Le programme affiche $10$ puis s'arrête[/option]
[reponse statut="correct"]Parfait !
La variable i n'est jamais modifiée à l'intérieur de la boucle. La condition i < 10 reste donc toujours vraie (car $i$ reste à $0$) et la boucle tourne indéfiniment en affichant $0$.[/reponse]
[reponse motif="Le programme affiche $0, 1, 2, \ldots, 9$ puis s'arrête"]Non.
Pour cela, il faudrait incrémenter i à chaque tour avec i = i + 1. Ici, rien ne fait évoluer i.[/reponse]
[reponse motif="Le programme n'affiche rien"]Non.
La condition i < 10 est vraie au premier tour ($0 < 10$), donc le bloc s'exécute au moins une fois. Un print s'effectue donc.[/reponse]
[reponse motif="Le programme affiche $10$ puis s'arrête"]Non.
La boucle while ne s'arrête pas pile sur une valeur précise : elle continue tant que la condition est vraie. Et ici, rien ne rend la condition fausse.[/reponse]
[reponse statut="incorrect"]Non.
Rechercher si i évolue dans le corps de la boucle. Si non, la condition reste inchangée et la boucle ne s'arrête jamais.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
q = 1
for i in range(4) :
    S = S + q
    q = q * 2
print(S)

Que s'affiche-t-il ?
[qcm]
[option]$7$[/option]
[option]$8$[/option]
[option correct="true"]$15$[/option]
[option]$16$[/option]
[reponse statut="correct"]Exactement !
Traçons les étapes avec $S$ et $q$ :
Avant la boucle : $S = 0$, $q = 1$.
Tour $0$ : $S = 0 + 1 = 1$, $q = 2$.
Tour $1$ : $S = 1 + 2 = 3$, $q = 4$.
Tour $2$ : $S = 3 + 4 = 7$, $q = 8$.
Tour $3$ : $S = 7 + 8 = 15$, $q = 16$.
On a calculé $1 + 2 + 4 + 8 = 15$.[/reponse]
[reponse motif="$7$"]Non.
$7 = 1 + 2 + 4$ correspond à seulement trois tours de boucle. Or range(4) en fait quatre. Vérifier le dernier tour.[/reponse]
[reponse motif="$8$"]Non.
$8$ est la valeur de $q$ à la fin d'un certain tour, pas la valeur finale de S. La question porte sur S, le cumul.[/reponse]
[reponse motif="$16$"]Non.
$16$ est la valeur finale de q, pas celle de S. Ne pas confondre la variable de cumul et la variable qui évolue.[/reponse]
[reponse statut="incorrect"]Non.
Faire un tableau avec deux colonnes (S et q) et suivre les quatre tours de boucle.[/reponse]
[/qcm]
[/etape]

[etape]
On souhaite calculer la plus petite valeur de n telle que $1 + 2 + \ldots + n \geqslant 100$. Parmi les programmes ci-dessous, lequel est correct ?
[qcm]
[option]for n in range(100) : S = S + n[/option]
[option correct="true"]S = 0 ; n = 0 ; while S < 100 : n = n + 1 ; S = S + n[/option]
[option]S = 0 ; for n in range(100) : if S < 100 : S = S + n[/option]
[option]n = 0 ; while S >= 100 : n = n + 1 ; S = S + n[/option]
[reponse statut="correct"]Tu as raison !
On ne connaît pas $n$ à l'avance : il faut une boucle while. On incrémente $n$ à chaque tour et on cumule dans $S$ tant que $S < 100$. Dès que le cumul dépasse $100$, la boucle s'arrête et $n$ contient la valeur cherchée.[/reponse]
[reponse motif="for n in range(100) : S = S + n"]Non.
Ce programme ne s'arrête pas quand le seuil est atteint : il parcourt toutes les valeurs jusqu'à $99$. De plus, S n'est pas initialisée.[/reponse]
[reponse motif="S = 0 ; for n in range(100) : if S < 100 : S = S + n"]Non.
Même si le test empêche de cumuler après le seuil, la boucle for tourne toujours $100$ fois (juste sans rien ajouter). On ne s'arrête pas quand on a trouvé $n$.[/reponse]
[reponse motif="n = 0 ; while S >= 100 : n = n + 1 ; S = S + n"]Non.
La condition est inversée : on veut rester dans la boucle tant que S < 100, pas tant que S >= 100. De plus, S n'est pas initialisée.[/reponse]
[reponse statut="incorrect"]Non.
Stratégie : condition d'arrêt inconnue → boucle while. La condition écrite dans while est celle pour rester dans la boucle.[/reponse]
[/qcm]
[/etape]

QCM : Boucles for et range en Python

[enonce]
Ce QCM porte sur la boucle for et la fonction range en Python. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Quelles valeurs parcourt range(5) en Python ?
[qcm]
[option]$1, 2, 3, 4, 5$[/option]
[option correct="true"]$0, 1, 2, 3, 4$[/option]
[option]$0, 1, 2, 3, 4, 5$[/option]
[option]$5$[/option]
[reponse statut="correct"]Exact !
Avec un seul argument, range(b) parcourt les entiers de $0$ à $b-1$ inclus. Pour $b = 5$, cela fait donc $0, 1, 2, 3, 4$, soit cinq valeurs.[/reponse]
[reponse motif="$1, 2, 3, 4, 5$"]Non.
Le piège : range(5) commence à $0$, pas à $1$. La borne inférieure par défaut est $0$, et la borne supérieure $5$ est exclue.[/reponse]
[reponse motif="$0, 1, 2, 3, 4, 5$"]Non.
La borne supérieure est exclue : $5$ n'est pas atteint. Compter le nombre de valeurs : range(5) produit exactement $5$ valeurs.[/reponse]
[reponse motif="$5$"]Non.
range(5) ne renvoie pas la valeur $5$ seule : c'est une séquence d'entiers qu'on parcourt avec une boucle.[/reponse]
[reponse statut="incorrect"]Non.
Règle à retenir : range(b) parcourt les entiers de $0$ à $b-1$.[/reponse]
[/qcm]
[/etape]

[etape]
Quelles valeurs parcourt range(2, 6) en Python ?
[qcm]
[option]$2, 3, 4, 5, 6$[/option]
[option correct="true"]$2, 3, 4, 5$[/option]
[option]$3, 4, 5$[/option]
[option]$2, 6$[/option]
[reponse statut="correct"]Bonne réponse !
range(a, b) parcourt les entiers de $a$ (inclus) à $b - 1$ (inclus). Ici, de $2$ à $5$, soit $2, 3, 4, 5$.[/reponse]
[reponse motif="$2, 3, 4, 5, 6$"]Non.
La borne supérieure $b = 6$ est exclue. Piège classique : ne pas confondre range(2, 6) avec l'intervalle $[2\,;\,6]$ au sens mathématique.[/reponse]
[reponse motif="$3, 4, 5$"]Non.
La borne inférieure $a = 2$ est incluse, contrairement à la borne supérieure. range(2, 6) commence donc par $2$.[/reponse]
[reponse motif="$2, 6$"]Non.
range(2, 6) ne renvoie pas seulement les deux bornes, mais tous les entiers entre $2$ et $5$ inclus.[/reponse]
[reponse statut="incorrect"]Non.
Règle : range(a, b) commence à $a$ (inclus) et s'arrête à $b - 1$ (inclus).[/reponse]
[/qcm]
[/etape]

[etape]
Combien de fois le bloc d'instructions de la boucle ci-dessous est-il exécuté ?

for i in range(10) :
    print("Bonjour")

[qcm]
[option]$9$[/option]
[option]$11$[/option]
[option correct="true"]$10$[/option]
[option]$1$[/option]
[reponse statut="correct"]Bravo !
range(10) parcourt $10$ valeurs ($0, 1, \ldots, 9$). Le bloc est donc exécuté $10$ fois.[/reponse]
[reponse motif="$9$"]Non.
Il y a bien $10$ valeurs parcourues : même si $10$ est exclu, la séquence $0, 1, \ldots, 9$ contient $10$ entiers.[/reponse]
[reponse motif="$11$"]Non.
range(10) parcourt les entiers de $0$ à $9$, soit exactement $10$ valeurs. Pas une de plus.[/reponse]
[reponse motif="$1$"]Non.
Le bloc est exécuté à chaque tour de boucle. range(10) fait parcourir $10$ valeurs à la variable i, donc le bloc s'exécute $10$ fois.[/reponse]
[reponse statut="incorrect"]Non.
Compter les valeurs prises par i : range(10) produit $10$ valeurs.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

for i in range(3) :
    print(i, end=' ')

Que s'affiche-t-il ?
[qcm]
[option correct="true"]0 1 2[/option]
[option]1 2 3[/option]
[option]0 1 2 3[/option]
[option]3[/option]
[reponse statut="correct"]C'est bien ça !
range(3) parcourt les entiers $0, 1, 2$. À chaque tour de boucle, la variable i prend successivement ces valeurs et elles sont affichées sur la même ligne, séparées par des espaces.[/reponse]
[reponse motif="1 2 3"]Non.
range(3) commence à $0$ (pas $1$) et s'arrête avant $3$ (pas après). La séquence est $0, 1, 2$.[/reponse]
[reponse motif="0 1 2 3"]Non.
La borne supérieure $3$ est exclue de la séquence. range(3) produit exactement $3$ valeurs : $0, 1, 2$.[/reponse]
[reponse motif="3"]Non.
La boucle affiche chaque valeur parcourue, pas seulement la borne supérieure. Observer le contenu de print : elle affiche i à chaque tour.[/reponse]
[reponse statut="incorrect"]Non.
La boucle for i in range(3) fait prendre à i trois valeurs successives : $0$, $1$, $2$.[/reponse]
[/qcm]
[/etape]

[etape]
Quand on ne sait pas à l'avance combien de fois il faudra répéter un bloc (car cela dépend d'une condition à vérifier), quelle instruction Python utilise-t-on ?
[qcm]
[option]for[/option]
[option correct="true"]while[/option]
[option]if[/option]
[option]range[/option]
[reponse statut="correct"]Parfait !
La boucle while (« tant que ») répète un bloc tant qu'une condition est vérifiée. On l'utilise justement quand le nombre de répétitions n'est pas connu à l'avance. On l'appelle aussi « boucle non bornée ».[/reponse]
[reponse motif="for"]Non.
La boucle for est une boucle bornée : on l'utilise quand on connaît le nombre de répétitions à l'avance (par exemple via range(...)).[/reponse]
[reponse motif="if"]Non.
if n'est pas une boucle mais un test conditionnel : son bloc s'exécute une seule fois (ou pas du tout).[/reponse]
[reponse motif="range"]Non.
range n'est pas une boucle mais une fonction qui génère une séquence d'entiers. Elle accompagne la boucle for mais ne remplace pas l'instruction.[/reponse]
[reponse statut="incorrect"]Non.
Résumé : for pour un nombre de tours connu à l'avance, while pour un arrêt conditionnel.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

for i in [1, 3, 5] :
    print(2*i, end=' ')

Que s'affiche-t-il ?
[qcm]
[option]1 3 5[/option]
[option]2 4 6[/option]
[option correct="true"]2 6 10[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Exactement !
La variable i prend successivement les valeurs $1$, $3$, $5$. À chaque tour, on affiche $2 \times i$ : soit $2$, $6$, puis $10$.[/reponse]
[reponse motif="1 3 5"]Non.
Attention à ce qui est affiché : le print affiche 2*i, pas i directement. Multiplier chaque valeur par $2$.[/reponse]
[reponse motif="2 4 6"]Non.
Cela correspondrait à i prenant les valeurs $1, 2, 3$ et afficher 2*i. Or la liste parcourue est $[1, 3, 5]$, avec un pas de $2$.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
Une boucle for peut parfaitement parcourir une liste de valeurs explicites, pas seulement un range.[/reponse]
[reponse statut="incorrect"]Non.
Lister les valeurs de i dans l'ordre, puis calculer $2 \times i$ pour chacune.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Boucles for et range (niveau 1)

[enonce]
Pour chaque affirmation suivante sur la boucle for et la fonction range en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
Affirmation : L'instruction range(5) génère les entiers $1$, $2$, $3$, $4$, $5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
range(5) génère les entiers de $0$ à $4$ (inclus), soit $0, 1, 2, 3, 4$.
La borne supérieure ($5$) est exclue et la valeur de départ est $0$ par défaut.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention : en Python, range(n) commence à $0$ (pas à $1$) et s'arrête avant $n$.
range(5) génère donc $0, 1, 2, 3, 4$ — cinq valeurs, mais à partir de $0$.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. range(5) génère $0, 1, 2, 3, 4$ (et non $1$ à $5$).
[/solution]
[/etape]

[etape]
Affirmation : L'instruction range(2, 6) génère les entiers $2$, $3$, $4$, $5$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
range(2, 6) parcourt les entiers de $2$ (inclus) à $6$ (exclu), soit $2, 3, 4, 5$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : range(a, b) génère les entiers de $a$ à $b-1$.
Pour range(2, 6), cela donne $2, 3, 4, 5$ (la borne $6$ est exclue).[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(2, 6) parcourt $2, 3, 4, 5$ — borne de départ incluse, borne d'arrivée exclue.
[/solution]
[/etape]

[etape]
Affirmation : Dans la boucle for i in range(3, 10) :, la variable i prend la valeur $10$ au dernier tour.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bravo !
range(3, 10) fait varier i de $3$ à $9$ (inclus).
La borne supérieure ($10$) est exclue : i ne prend jamais la valeur $10$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège classique est d'inclure la borne supérieure.
range(a, b) s'arrête avant $b$ : ici, i prend les valeurs $3, 4, 5, 6, 7, 8, 9$, puis la boucle se termine.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. range(3, 10) s'arrête à $9$ ; i ne prend jamais la valeur $10$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

for i in range(4) :
    print("Bonjour")

Affirmation : Ce programme affiche Bonjour $4$ fois.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
range(4) produit $4$ valeurs ($0, 1, 2, 3$), donc le bloc est exécuté $4$ fois.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : range(n) produit $n$ valeurs (de $0$ à $n-1$), donc la boucle s'exécute $n$ fois.
Ici, for i in range(4) répète le bloc $4$ fois : Bonjour est affiché $4$ fois.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(4) produit $4$ valeurs, donc la boucle s'exécute $4$ fois.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

for i in [1, 2, 5, 11] :
    print(i, end=" ")

Affirmation : Ce programme affiche 1 2 5 11.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Correct !
Dans une boucle for, la variable prend successivement chacune des valeurs de la liste.
i parcourt donc $1$, $2$, $5$ puis $11$ et chaque valeur est affichée séparée par un espace.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : for i in [liste] parcourt les valeurs de la liste dans l'ordre.
Le paramètre end=" " de print sépare les affichages par un espace au lieu d'un retour à la ligne.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. i prend successivement les valeurs $1, 2, 5, 11$ ; chacune est affichée à la suite séparée par un espace.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(1, 5) :
    S = S + i
print(S)

Affirmation : Ce programme affiche $10$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
i prend les valeurs $1, 2, 3, 4$ (la borne $5$ est exclue).
On calcule donc $S = 1 + 2 + 3 + 4 = 10$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il faut bien identifier les valeurs parcourues : range(1, 5) donne $1, 2, 3, 4$.
$S$ reçoit successivement $0+1 = 1$, puis $1+2 = 3$, puis $3+3 = 6$, puis $6+4 = 10$. Le programme affiche $10$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(1, 5) donne $1, 2, 3, 4$ ; leur somme vaut $10$.
[/solution]
[/etape]

Python : Table de multiplication

On souhaite afficher les $ 10 $ premières lignes de la table de multiplication de $ 7 $, au format :

7 x 1 = 7
7 x 2 = 14
...
7 x 10 = 70
  1. Écrire un programme Python utilisant une boucle for qui affiche la table de multiplication de $ 7 $.
  2. Modifier le programme pour en faire une fonction table(n) qui affiche la table de multiplication d'un entier $ n $ donné en argument.
  3. Utiliser la fonction pour afficher la table de $ 13 $.

Corrigé

  1. On répète $ 10 $ fois l'affichage d'une ligne. On fait donc varier $ i $ de $ 1 $ à $ 10 $, ce qui se traduit par range(1, 11) en Python :

    for i in range(1, 11):
        print("7 x", i, "=", 7 * i)
  2. On remplace la valeur $ 7 $ par le paramètre $ n $ :

    def table(n):
        for i in range(1, 11):
            print(n, "x", i, "=", n * i)
  3. L'appel table(13) affiche :

    13 x 1 = 13
    13 x 2 = 26
    13 x 3 = 39
    13 x 4 = 52
    13 x 5 = 65
    13 x 6 = 78
    13 x 7 = 91
    13 x 8 = 104
    13 x 9 = 117
    13 x 10 = 130

Remarque
L'instruction range(1, 11) produit la suite $ 1, 2, 3, \ldots, 10 $ : la borne de fin ($ 11 $) n'est jamais atteinte.