$course$/QCM de NSI/SNT/5. Boucles bornées : for La boucle for et la fonction range, avec un, deux ou trois arguments ;
le nombre de tours et les valeurs prises par la variable de boucle ;
les schémas de l'accumulateur et du compteur ; le parcours d'une
chaîne de caractères ; les boucles imbriquées.

]]> 5. Boucles bornées : for — Q01 : Les valeurs de range `python
for i in range(4):
print(i)
`

Quelles valeurs sont affichées ?

]]> range(n) produit les entiers de 0 à n - 1, soit n valeurs. La
variable de boucle les prend une à une, dans l'ordre.

]]> 1.0 0.0 0 true true abc 0, 1, 2, 3 et 4

]]> Erreur : ce serait cinq valeurs. range(4) s'arrête avant 4.

]]> 0, 1, 2 et 3

]]> Bonne réponse : range(4) fournit quatre entiers, de 0 à 3. La
valeur 4 n'en fait pas partie.

]]> 1, 2, 3 et 4

]]> Erreur : range commence à 0 quand on ne lui donne qu'un
argument.

]]> Quatre fois le nombre 4

]]> Erreur : i change à chaque tour, il prend les valeurs
successives fournies par range.

]]> 5. Boucles bornées : for — Q02 : Combien de pas Un robot avance d'un pas à chaque tour de boucle.

`python
for k in range(2, 7):
avancer()
`

Combien de pas fait-il ?

]]> range(a, b) fournit les entiers de a inclus à b exclu, soit
b - a valeurs. Le nombre de tours ne dépend pas de ce que fait le
corps de la boucle.

]]> 1.0 0.0 0 true true abc 4

]]> Erreur : de 2 à 6 inclus, il y a 5 valeurs.

]]> 7

]]> Erreur : la boucle ne part pas de 0 mais de 2, et s'arrête avant
7.

]]> 6

]]> Erreur : la borne 7 est exclue, la dernière valeur est 6.

]]> 5

]]> Bonne réponse : k prend les valeurs 2, 3, 4, 5 et 6, soit 5
tours. Le nombre de tours vaut 7 moins 2.

]]> 5. Boucles bornées : for — Q03 : Un range qui descend `python
for n in range(10, 0, -3):
print(n)
`

Quelles valeurs sont affichées ?

]]> range(depart, fin, pas) accepte un pas négatif pour compter à
rebours. La borne fin reste exclue, comme toujours.

]]> 1.0 0.0 0 true true abc 10, 7, 4 et 1

]]> Bonne réponse : on part de 10 et on retire 3 à chaque fois tant
qu'on reste strictement au-dessus de 0.

]]> 0, 3, 6 et 9

]]> Erreur : le premier argument est le point de départ, 10, et le
pas est négatif.

]]> 10, 7, 4, 1 et -2

]]> Erreur : -2 dépasse la borne 0, la boucle s'arrête avant.

]]> 10, 7 et 4

]]> Erreur : 1 est encore strictement supérieur à 0, il est
affiché.

]]> 5. Boucles bornées : for — Q04 : La somme des premiers entiers `python
total = 0
for i in range(1, 6):
total = total + i
print(total)
`

Qu'affiche ce programme ?

]]> L'accumulateur est le schéma de base : une variable initialisée à 0
avant la boucle, à laquelle on ajoute une valeur à chaque tour. À la
sortie, elle contient la somme.

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : total accumule les valeurs successives, il ne garde
pas la dernière.

]]> 15

]]> Bonne réponse : la boucle ajoute 1, 2, 3, 4 et 5, ce qui fait
15.

]]> 21

]]> Erreur : 21 ajouterait 6, qui est exclu par range(1, 6).

]]> 10

]]> Erreur : 10 serait la somme de 1 à 4. La valeur 5 est incluse,
seule la borne 6 est exclue.

]]> 5. Boucles bornées : for — Q05 : Compter les multiples `python
compte = 0
for n in range(1, 21):
if n % 5 == 0:
compte = compte + 1
print(compte)
`

Qu'affiche ce programme ?

]]> Le compteur est un accumulateur qui n'augmente que sous condition.
Une variable à 0, un if dans la boucle, et un ajout de 1 quand la
propriété est vérifiée.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : entre 1 et 20, les multiples de 5 sont 5, 10, 15 et 20.

]]> 5

]]> Erreur : 25 n'est pas atteint, la boucle s'arrête à 20.

]]> 20

]]> Erreur : le compteur n'augmente que quand la condition est
vraie, pas à chaque tour.

]]> 3

]]> Erreur : 20 est bien parcouru, range(1, 21) va jusqu'à 20.

]]> 5. Boucles bornées : for — Q06 : La valeur qui reste `python
for i in range(3):
x = i * 10
print(x)
`

Qu'affiche ce programme ?

]]> Les variables modifiées dans la boucle conservent leur dernière
valeur à la sortie. Il en va de même pour la variable de boucle
elle-même.

]]> 1.0 0.0 0 true true abc 0

]]> Erreur : 0 est la valeur au premier tour, écrasée ensuite.

]]> 20

]]> Bonne réponse : x est recalculé à chaque tour ; au dernier,
i vaut 2 et x vaut 20. Cette valeur subsiste après la
boucle.

]]> 30

]]> Erreur : i prend les valeurs 0, 1 et 2, jamais 3.

]]> Une erreur, x n'existe plus après la boucle

]]> Erreur : une variable créée dans une boucle reste accessible
après. Elle garde sa dernière valeur.

]]> 5. Boucles bornées : for — Q07 : Parcourir une chaîne `python
for lettre in "SNT":
print(lettre)
`

Qu'affiche ce programme ?

]]> for sait parcourir une chaîne : la variable prend successivement
chaque caractère. Pas besoin de range pour cela.

]]> 1.0 0.0 0 true true abc 0, 1 et 2, les positions des lettres

]]> Erreur : en parcourant une chaîne, la variable reçoit les
caractères, pas leurs positions.

]]> lettre trois fois, sur trois lignes

]]> Erreur : print(lettre) affiche la valeur de la variable, un
caractère différent à chaque tour.

]]> SNT sur une seule ligne, sans retour

]]> Erreur : chaque tour affiche un seul caractère et revient à la
ligne.

]]> S, N et T, sur trois lignes

]]> Bonne réponse : la boucle parcourt la chaîne caractère par
caractère, et chaque print occupe une ligne.

]]> 5. Boucles bornées : for — Q08 : Compter une lettre `python
compte = 0
for c in "programmation":
if c == "a":
compte = compte + 1
print(compte)
`

Qu'affiche ce programme ?

]]> Compter une lettre combine le parcours d'une chaîne et le schéma du
compteur : un test sur chaque caractère, un ajout de 1 quand il
convient.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : chaque a rencontré ajoute 1, et il y en a 2.

]]> 3

]]> Erreur : en épelant le mot, on ne trouve que 2 fois la lettre a.

]]> 2

]]> Bonne réponse : en épelant « programmation », on trouve 2 fois la
lettre a.

]]> 13

]]> Erreur : 13 est le nombre de tours, mais le compteur n'augmente
que sur les a.

]]> 5. Boucles bornées : for — Q09 : Afficher avant d'ajouter `python
s = 0
for k in range(3):
print(s)
s = s + k
`

Qu'affiche ce programme ?

]]> La place du print dans le corps de la boucle change ce qui est
affiché. Une trace tour par tour, avec les valeurs de k et de s,
lève tout doute.

]]> 1.0 0.0 0 true true abc 0, 1 et 3

]]> Erreur : ce seraient les valeurs après chaque ajout. Or le
print vient avant l'ajout.

]]> 0, 0 et 1

]]> Bonne réponse : au premier tour s vaut 0 ; puis on ajoute 0.
Au deuxième, s vaut encore 0 ; puis on ajoute 1. Au troisième,
s vaut 1.

]]> 0, 1 et 2

]]> Erreur : le programme affiche s, pas k.

]]> 1, 3 et 6

]]> Erreur : k part de 0, et l'affichage précède l'ajout.

]]> 5. Boucles bornées : for — Q10 : Deux boucles imbriquées `python
for i in range(2):
for j in range(3):
print(i, j)
`

Combien de lignes ce programme affiche-t-il ?

]]> Quand une boucle en contient une autre, le nombre total de passages
est le produit des nombres de tours. Ici, (0, 0), (0, 1), et
ainsi de suite jusqu'à (0, 2), puis la même chose pour chaque
valeur suivante de i.

]]> 1.0 0.0 0 true true abc 3

]]> Erreur : la boucle intérieure est relancée entièrement pour
chaque valeur de i.

]]> 6

]]> Bonne réponse : pour chacune des 2 valeurs de i, la boucle
intérieure fait 3 tours, soit 2 fois 3 lignes.

]]> 5

]]> Erreur : les tours se multiplient, ils ne s'additionnent pas.

]]> 2

]]> Erreur : chaque tour de la boucle extérieure déclenche 3
affichages.

]]> 5. Boucles bornées : for — Q11 : La dernière valeur affichée `python
for i in range(1, 10, 2):
print(i)
`

Quelle est la dernière valeur affichée ?

]]> Avec trois arguments, range part du premier, avance du troisième
et s'arrête avant le deuxième. Ici, il énumère 1, 3, 5, 7 et 9.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : les valeurs sont 1, 3, 5, 7 et 9. La suivante,
11, dépasse la borne.

]]> 10

]]> Erreur : la borne 10 est exclue, et de toute façon le pas de 2
ne l'atteint pas.

]]> 8

]]> Erreur : en partant de 1 avec un pas de 2, on ne passe que par
1, 3, 5 et ainsi de suite.

]]> 7

]]> Erreur : 9 est encore strictement inférieur à 10, il est
affiché.

]]> 5. Boucles bornées : for — Q12 : Un produit `python
p = 1
for i in range(1, 5):
p = p * i
print(p)
`

Qu'affiche ce programme ?

]]> Pour accumuler un produit, on initialise à 1, pas à 0. Le schéma est
celui de l'accumulateur, avec une multiplication à la place de
l'addition.

]]> 1.0 0.0 0 true true abc 120

]]> Erreur : 120 inclurait le facteur 5, exclu par range(1, 5).

]]> 0

]]> Erreur : p part de 1, pas de 0. Un produit initialisé à 0
resterait nul.

]]> 24

]]> Bonne réponse : 1 fois 2 fois 3 fois 4 font 24.

]]> 10

]]> Erreur : 10 serait la somme de 1 à 4, or la boucle multiplie.

]]> 5. Boucles bornées : for — Q13 : Modifier la variable de boucle `python
for i in range(3):
i = i + 10
print(i)
`

Qu'affiche ce programme ?

]]> Au début de chaque tour, for donne à sa variable la valeur suivante
de range, quoi qu'on lui ait fait au tour précédent. Modifier la
variable de boucle n'influence pas le nombre de tours.

]]> 1.0 0.0 0 true true abc 10, puis une erreur

]]> Erreur : modifier la variable de boucle est autorisé, même si
c'est déconseillé.

]]> 10, 21 et 32

]]> Erreur : la modification de i ne se cumule pas. range
réaffecte i au début de chaque tour.

]]> 10, 11 et 12

]]> Bonne réponse : à chaque tour, i reçoit la valeur suivante de
range, 0, 1 et 2, avant l'ajout de 10.

]]> 0, 1 et 2

]]> Erreur : l'ajout de 10 a lieu avant l'affichage.

]]> 5. Boucles bornées : for — Q14 : La borne exclue La valeur 5 est-elle affichée par la boucle suivante ?

`python
for i in range(5):
print(i)
`

]]> range(n) compte de 0 à n - 1. Retenir que la borne est exclue
évite l'erreur classique du « tour de trop » ou du « tour de moins ».

]]> 1.0 0.0 0 true true abc Oui, cinq fois de suite

]]> Erreur : i change à chaque tour et ne vaut jamais 5.

]]> Oui, en dernier

]]> Erreur : la borne donnée à range est toujours exclue.

]]> Oui, en premier

]]> Erreur : la boucle commence à 0.

]]> Non, range(5) s'arrête à 4

]]> Bonne réponse : range(5) fournit 0, 1, 2, 3 et 4, soit cinq
valeurs, mais pas 5.

]]> 5. Boucles bornées : for — Q15 : Compléter une boucle On veut afficher tous les entiers de 3 à 12 inclus. Quelle ligne
convient ?

]]> Pour parcourir de a à b inclus, on écrit range(a, b + 1). Le
« plus un » compense l'exclusion de la borne.

]]> 1.0 0.0 0 true true abc for n in range(3, 13):

]]> Bonne réponse : pour inclure 12, la borne exclue doit être 13.

]]> for n in range(13, 3):

]]> Erreur : avec un départ supérieur à la borne et un pas positif,
range est vide : aucun tour.

]]> for n in range(3, 12):

]]> Erreur : 12 serait exclu, la boucle s'arrêterait à 11.

]]> for n in range(12):

]]> Erreur : cette boucle part de 0 et s'arrête à 11.

]]> 5. Boucles bornées : for — Q16 : La somme des nombres pairs `python
s = 0
for n in range(1, 11):
if n % 2 == 0:
s = s + n
print(s)
`

Qu'affiche ce programme ?

]]> Accumulateur et condition se combinent : on n'ajoute une valeur que
si elle vérifie le test. C'est le schéma d'une somme sélective.

]]> 1.0 0.0 0 true true abc 30

]]> Bonne réponse : 2, 4, 6, 8 et 10 font 30.

]]> 20

]]> Erreur : 10 est bien parcouru, range(1, 11) va jusqu'à 10.

]]> 25

]]> Erreur : 25 est la somme des impairs de 1 à 9. La condition
retient les pairs.

]]> 55

]]> Erreur : 55 serait la somme de tous les entiers de 1 à 10, sans
la condition.

]]> 5. Boucles bornées : for — Q17 : Chercher un maximum `python
maxi = 0
for x in range(1, 6):
valeur = x * (6 - x)
if valeur > maxi:
maxi = valeur
print(maxi)
`

Qu'affiche ce programme ?

]]> Pour trouver un maximum, on garde une variable mise à jour chaque
fois qu'une valeur la dépasse. À la fin, elle contient la plus
grande valeur rencontrée.

]]> 1.0 0.0 0 true true abc 6

]]> Erreur : 6 n'est jamais une valeur de x * (6 - x).

]]> 9

]]> Bonne réponse : les valeurs calculées sont 5, 8, 9, 8 et 5. La
plus grande est 9, atteinte pour x égal à 3.

]]> 8

]]> Erreur : 8 est dépassé par 9 au tour numéro 3.

]]> 5

]]> Erreur : 5 est la dernière valeur calculée, mais maxi garde la
plus grande rencontrée.

]]> 5. Boucles bornées : for — Q18 : Un compte à rebours `python
for t in range(3, 0, -1):
print(t)
print("Partez")
`

Qu'affiche ce programme ?

]]> Un pas négatif fait décroître la variable de boucle. Les règles sont
inchangées : départ inclus, borne exclue.

]]> 1.0 0.0 0 true true abc 3, 2, 1 puis Partez

]]> Bonne réponse : le pas -1 fait descendre de 3 à 1, la borne 0
étant exclue, puis la ligne hors de la boucle s'exécute.

]]> 2, 1, 0 puis Partez

]]> Erreur : le départ est le premier argument, 3.

]]> 3, 2, 1, 0 puis Partez

]]> Erreur : la borne 0 est exclue, même en descendant.

]]> Partez seulement

]]> Erreur : range(3, 0, -1) fournit bien trois valeurs.

]]> 5. Boucles bornées : for — Q19 : Construire une chaîne `python
mot = ""
for c in "abc":
mot = c + mot
print(mot)
`

Qu'affiche ce programme ?

]]> Une chaîne peut servir d'accumulateur : on part de la chaîne vide et
on concatène à chaque tour. L'ordre de la concaténation décide du
sens de la chaîne obtenue.

]]> 1.0 0.0 0 true true abc abcabc

]]> Erreur : chaque tour n'ajoute qu'un caractère.

]]> ccc

]]> Erreur : mot conserve les caractères précédents.

]]> cba

]]> Bonne réponse : chaque caractère est placé devant ce qui est
déjà construit : a, puis ba, puis cba.

]]> abc

]]> Erreur : ce serait le résultat de mot = mot + c, qui ajoute à
la fin.

]]> 5. Boucles bornées : for — Q20 : Un range vide `python
for i in range(5, 5):
print(i)
print("Fin")
`

Qu'affiche ce programme ?

]]> Une boucle for sur un range vide ne s'exécute pas du tout, sans
erreur. C'est un cas à prévoir quand les bornes viennent d'un calcul.

]]> 1.0 0.0 0 true true abc 0, 1, 2, 3, 4 puis Fin

]]> Erreur : ce serait range(5). Avec deux arguments, le départ
est 5.

]]> Une erreur, un range ne peut pas être vide

]]> Erreur : un range vide est parfaitement valable, la boucle
est simplement sautée.

]]> 5 puis Fin

]]> Erreur : la borne 5 est exclue, il ne reste rien à parcourir.

]]> Fin seulement

]]> Bonne réponse : range(5, 5) ne contient aucune valeur, la
boucle ne fait aucun tour, et le programme continue.

]]> 5. Boucles bornées : for — Q21 : Un message répété Combien de fois ce programme affiche-t-il hop ?
`python
for i in range(3):
print("hop")
`

]]> range(n) produit n valeurs, et le corps de la boucle est exécuté
une fois pour chacune.

]]> 1.0 0.0 0 true true abc 4 fois

]]> Erreur : la valeur 3 elle-même n'est pas comprise dans
range(3).

]]> 2 fois

]]> Erreur : range(3) s'arrête avant 3, mais commence à 0, ce
qui fait bien 3 valeurs.

]]> Une seule fois, i n'étant pas utilisé

]]> Erreur : la boucle se répète même si i ne sert pas dans le
corps.

]]> 3 fois

]]> Bonne réponse : range(3) fournit 3 valeurs, de 0 à 2,
donc le corps de la boucle s'exécute 3 fois.

]]> 5. Boucles bornées : for — Q22 : Une table de multiplication partielle Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?
`python
for i in range(1, 4):
print(i * 10)
`

]]> range(1, 4) donne 1, 2, 3 : la première borne est incluse, la
seconde exclue.

]]> 1.0 0.0 0 true true abc 0 10 20

]]> Erreur : range(1, 4) commence à 1, pas à 0.

]]> 10 20 30

]]> Bonne réponse : i prend les valeurs 1, 2 et 3, et chacune est
multipliée par 10.

]]> 1 2 3

]]> Erreur : c'est i * 10 qui est affiché, pas i.

]]> 10 20 30 40

]]> Erreur : la borne 4 est exclue, i ne la prend jamais.

]]> 5. Boucles bornées : for — Q23 : Un accumulateur qui avance de deux en deux Qu'affiche ce programme ?
`python
s = 0
for i in range(3):
s = s + 2
print(s)
`

]]> Une boucle qui ajoute une constante calcule une multiplication :
3 tours de + 2 donnent 6.

]]> 1.0 0.0 0 true true abc 2

]]> Erreur : s grandit à chaque tour, il ne reste pas à 2.

]]> 3

]]> Erreur : 3 est le nombre de tours, mais chaque tour ajoute 2.

]]> 6

]]> Bonne réponse : la boucle tourne 3 fois et ajoute 2 à chaque
tour, soit 6 au total.

]]> 5

]]> Erreur : il ne s'agit pas d'ajouter 2 une fois à 3, mais
d'ajouter 2 à chacun des 3 tours.

]]> 5. Boucles bornées : for — Q24 : Les impairs d'une plage Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?
`python
for i in range(5):
if i % 2 == 1:
print(i)
`

]]> Un if dans une boucle sélectionne certains tours. Ici, le reste
de la division par 2 reconnaît les impairs.

]]> 1.0 0.0 0 true true abc 1 3 5

]]> Erreur : range(5) s'arrête à 4, la valeur 5 n'est
jamais testée.

]]> 0 1 2 3 4

]]> Erreur : le if filtre les valeurs, toutes ne sont pas
affichées.

]]> 1 3

]]> Bonne réponse : seules les valeurs dont le reste par 2 vaut 1,
les impairs, sont affichées, et 5 est exclu de la plage.

]]> 0 2 4

]]> Erreur : i % 2 == 1 retient les impairs, pas les pairs.

]]> 5. Boucles bornées : for — Q25 : Compter au-delà d'un seuil Qu'affiche ce programme ?
`python
n = 0
for i in range(10):
if i > 6:
n = n + 1
print(n)
`

]]> Un compteur n'avance que lorsque la condition est vraie. Compter
les tours retenus demande d'écrire la liste des valeurs qui
passent le test.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : les valeurs de range(10) strictement
supérieures à 6 vont de 7 à 9, il y en a 3.

]]> 6

]]> Erreur : 6 est le seuil, pas le nombre de valeurs qui le
dépassent.

]]> 10

]]> Erreur : seules les valeurs qui vérifient la condition sont
comptées.

]]> 4

]]> Erreur : i > 6 exclut 6 lui-même, et range(10) s'arrête
à 9.

]]> 5. Boucles bornées : for — Q26 : Des carrés ligne par ligne Qu'affiche ce programme ? Les lignes sont données séparées par des
virgules.
`python
for i in range(3):
print(i, i * i)
`

]]> Un print dans la boucle produit une ligne par tour, avec les
valeurs calculées à ce tour.

]]> 1.0 0.0 0 true true abc 3 9

]]> Erreur : le print est dans la boucle, une ligne par tour est
affichée.

]]> 1 1, 2 4, 3 9

]]> Erreur : range(3) commence à 0 et exclut 3.

]]> 0 0, 1 2, 2 4

]]> Erreur : i * i est le carré de i, pas son double.

]]> 0 0, 1 1, 2 4

]]> Bonne réponse : pour chaque valeur de i, de 0 à 2, la ligne
affiche i puis son carré.

]]> 5. Boucles bornées : for — Q27 : Une somme de doubles Qu'affiche ce programme ?
`python
total = 0
for i in range(5):
total = total + i * 2
print(total)
`

]]> Pour suivre un accumulateur, on note la valeur ajoutée à chaque
tour et on additionne : ici 0, 2, 4, et ainsi de suite jusqu'à
8.

]]> 1.0 0.0 0 true true abc 8

]]> Erreur : 8 est seulement la dernière valeur ajoutée,
total accumule toutes les autres.

]]> 0

]]> Erreur : total part de 0 mais grandit à chaque tour.

]]> 10

]]> Erreur : 10 est la somme des valeurs de i sans le
doublement.

]]> 20

]]> Bonne réponse : les doubles de 0 à 4 s'additionnent : la
somme de 0 à 4 vaut 10, et son double 20.

]]> 5. Boucles bornées : for — Q28 : La somme des multiples de trois Qu'affiche ce programme ?
`python
s = 0
for i in range(10):
if i % 3 == 0:
s = s + i
print(s)
`

]]> Filtre et accumulateur se combinent : le if choisit les valeurs,
l'addition les cumule.

]]> 1.0 0.0 0 true true abc 18

]]> Bonne réponse : seuls les multiples de 3 inférieurs à 10 sont
ajoutés, 0 compris, et leur somme vaut 18.

]]> 45

]]> Erreur : 45 est la somme de toutes les valeurs de
range(10), sans le filtre.

]]> 10

]]> Erreur : 10 est la borne de la plage, elle n'est même pas
parcourue.

]]> 4

]]> Erreur : 4 est le nombre de multiples de 3 retenus, pas leur
somme.

]]> 5. Boucles bornées : for — Q29 : Un triangle d'étoiles Qu'affiche ce programme ? Les lignes sont données séparées par des
virgules.
`python
for i in range(3):
print("" (i + 1))
`

]]> Multiplier une chaîne par un entier la répète. Combiné à une
boucle, cela dessine des figures ligne par ligne.

]]> 1.0 0.0 0 true true abc *

]]> Erreur : chaque tour produit sa propre ligne, et "" k
colle les étoiles sans espace.

]]> , *

]]> Erreur : range(3) donne 3 tours, et le dernier affiche 3
étoiles grâce au + 1.

]]> , , ***

]]> Erreur : le nombre d'étoiles dépend de i, il change à chaque
tour.

]]> , ,

]]> Bonne réponse : au tour i, la chaîne "*" est répétée
i + 1 fois, donc 1, puis 2, et ainsi de suite jusqu'à 3.

]]> 5. Boucles bornées : for — Q30 : Des sommes affichées au fil de la boucle Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?
`python
y = 0
for x in range(4):
y = y + x
print(y)
`

]]> Afficher dans la boucle montre l'évolution de l'accumulateur ;
afficher après la boucle ne montre que sa valeur finale.

]]> 1.0 0.0 0 true true abc 1 3 6 10

]]> Erreur : range(4) commence à 0, donc la première somme vaut
0.

]]> 6

]]> Erreur : le print est dans la boucle, il y a une ligne par
tour.

]]> 0 1 2 3

]]> Erreur : c'est y qui est affiché, pas x.

]]> 0 1 3 6

]]> Bonne réponse : y cumule les valeurs de x et est affiché
après chaque ajout, d'où les sommes successives.

]]>