$course$/QCM de NSI/Première/Conditions et boucles Structures de contrôle Python : conditions
(if/elif/else), opérateurs booléens
(and/or/not), boucles bornées (for/range),
boucles non bornées (while), boucles imbriquées et
traces d'exécution.

]]> Conditions et boucles — Q01 : Syntaxe du if Quelle est la syntaxe correcte d'une condition
simple en Python ?

]]> Python utilise l'indentation significative.
Tous les blocs (if, for, while, def...)
se reconnaissent à leur indentation, pas à des
accolades.

]]> 1.0 0.0 0 true true abc `python
if x > 0:
print("positif")
`

]]> Bonne réponse : deux-points en fin de ligne,
indentation (4 espaces conventionnels) pour
le bloc.

]]> `python
if x > 0 then
print("positif")
end
`

]]> Erreur : then et end n'existent pas en
Python (Lua, Ruby).

]]> `python
if {x > 0} print("positif")
`

]]> Erreur : pas d'accolades en Python.

]]> `python
if (x > 0)
print("positif");
`

]]> Erreur : syntaxe à la C/Java. En Python, pas
de parenthèses obligatoires, deux-points
obligatoires, indentation à la place des
accolades.

]]> Conditions et boucles — Q02 : elif À quoi sert le mot-clé elif en Python ?

]]> Schéma général :
`python
if cond1:
...
elif cond2:
...
else:
...
`
Au plus un des blocs s'exécute (le premier
dont la condition est vraie).

]]> 1.0 0.0 0 true true abc C'est un alias pour else

]]> Erreur : else n'a pas de condition. elif
a une condition.

]]> C'est simplement un alias pour le mot-clé if

]]> Erreur : elif ne s'utilise qu'après un
if.

]]> Cela teste si une variable existe

]]> Erreur : aucun rapport avec l'existence.

]]> C'est l'équivalent du else if en C/Java.

]]> Bonne réponse : elif permet d'enchaîner
plusieurs conditions sans imbrication
excessive. Mot-clé Python spécifique.

]]> Conditions et boucles — Q03 : Opérateurs logiques Comment écrit-on « x est positif et pair »
en Python ?

]]> Trois opérateurs : and (et), or (ou
inclusif), not (négation). À noter :
évaluation paresseuse, False and ... ne
teste pas la suite.

]]> 1.0 0.0 0 true true abc x > 0 && x % 2 == 0

]]> Erreur : && n'existe pas en Python. C'est
la syntaxe C/Java.

]]> x > 0 and x % 2 == 0

]]> Bonne réponse : Python utilise les
mots-clés and, or, not.

]]> x > 0 et x % 2 == 0

]]> Erreur : Python est en anglais.

]]> x > 0, x % 2 == 0

]]> Erreur : la virgule produit un tuple, pas
une conjonction logique.

]]> Conditions et boucles — Q04 : Boucle for range Combien d'itérations effectue
for i in range(5): ?

]]> Convention Python : la borne supérieure est
exclue. range(5) = [0, 1, 2, 3, 4].

]]> 1.0 0.0 0 true true abc 6

]]> Erreur : 5 est exclu de la séquence.

]]> 5

]]> Bonne réponse : range(n) produit les
entiers de 0 à n-1, soit n valeurs au
total.

]]> 4

]]> Erreur : range(5) produit 5 valeurs, de 0
à 4.

]]> Une infinité

]]> Erreur : range(5) est borné.

]]> Conditions et boucles — Q05 : range avec deux arguments Que produit list(range(2, 7)) ?

]]> Trois formes : range(n) (0 à n-1),
range(a, b) (a à b-1),
range(a, b, pas) (a à b-1 par pas).

]]> 1.0 0.0 0 true true abc [2, 7]

]]> Erreur : ce serait range(2, 7, 5) qui
donne [2] seulement.

]]> [2, 3, 4, 5, 6, 7]

]]> Erreur : 7 est exclu.

]]> [2, 3, 4, 5, 6]

]]> Bonne réponse : range(a, b) produit les
entiers de a (inclus) à b (exclu).

]]> [3, 4, 5, 6, 7]

]]> Erreur : 2 est inclus, 7 est exclu.

]]> Conditions et boucles — Q06 : Boucle while Que fait la boucle suivante ?
`python
n = 10
while n > 0:
print(n)
n -= 1
`

]]> while est une boucle non bornée : on
teste une condition à chaque tour. Bien
vérifier que la condition finira par devenir
fausse pour éviter une boucle infinie.

]]> 1.0 0.0 0 true true abc Affiche les nombres de 10 à 1

]]> Bonne réponse : à chaque tour, on affiche
n, puis on le diminue de 1, d'où un
affichage décroissant. Quand n atteint 0,
on sort.

]]> Affiche les nombres de 1 à 10 dans l'ordre croissant

]]> Erreur : la boucle décrémente, donc affiche
en ordre décroissant.

]]> N'affiche rien, car la condition est fausse au départ

]]> Erreur : n vaut 10 au départ, donc n > 0
est vrai et la boucle s'exécute au moins une
fois.

]]> Tourne sans fin, car n reste toujours positif

]]> Erreur : n -= 1 fait décroître n à chaque
tour ; après dix tours, n vaut 0 et la
condition devient fausse.

]]> Conditions et boucles — Q07 : Indentation et corps de boucle Qu'affiche ce code ?
`python
for i in range(3):
print("a")
print("b")
`

]]> L'indentation délimite le corps de la boucle :
tout ce qui est décalé se répète, ce qui revient
au niveau de la ligne for ne s'exécute qu'une
fois, après le dernier tour.

]]> 1.0 0.0 0 true true abc a b

]]> Erreur : range(3) fournit trois valeurs, le
corps de la boucle s'exécute donc trois fois
et a est affiché trois fois.

]]> a b a b a b

]]> Erreur : print("b") n'est pas indenté, il ne
fait pas partie du corps de la boucle et n'est
exécuté qu'une seule fois, après les trois
tours.

]]> a a a

]]> Erreur : le programme ne s'arrête pas à la fin
de la boucle ; l'instruction print("b"), qui
la suit, est exécutée une fois.

]]> a a a b

]]> Bonne réponse : seule la ligne indentée fait
partie du corps de la boucle, donc a est
affiché trois fois ; print("b") n'est
exécuté qu'une fois, après la boucle.

]]> Conditions et boucles — Q08 : Valeur finale d'un while Que vaut x à la fin de ce code ?
`python
x = 1
while x < 20:
x = x * 3
`

]]> Une boucle while peut dépasser la borne de sa
condition : le corps s'exécute une dernière fois
quand la condition est encore vraie, et c'est
cette valeur qui reste à la sortie.

]]> 1.0 0.0 0 true true abc 20

]]> Erreur : x ne prend que les valeurs 1, 3, 9, 27 ;
rien ne l'arrête exactement sur la borne
20.

]]> 81

]]> Erreur : un tour de trop. Dès que x vaut 27,
la condition est fausse et le corps n'est plus
exécuté.

]]> 9

]]> Erreur : pour x = 9, la condition 9 < 20
est encore vraie, donc un tour supplémentaire
a lieu et x passe à 27.

]]> 27

]]> Bonne réponse : trace : 1 → 3 → 9 → 27. Pour
x = 27, la condition 27 < 20 est fausse,
la boucle s'arrête.

]]> Conditions et boucles — Q09 : Test de parité Quelle expression vaut True si et seulement
si n est pair ?

]]> Idiome très courant. Variante :
bool(n % 2) est True ⇔ n est impair.

]]> 1.0 0.0 0 true true abc n / 2 == 0

]]> Erreur : ce test est rarement vrai (n = 0
uniquement).

]]> n == 2

]]> Erreur : seulement vrai pour n = 2.

]]> n // 2 == 0

]]> Erreur : ce test est vrai pour n = 0 ou
n = 1, pas pour la parité.

]]> n % 2 == 0

]]> Bonne réponse : % donne le reste. Reste
nul ⇔ pair.

]]> Conditions et boucles — Q10 : Boucle simple Que fait ce code ?
`python
total = 0
for i in range(1, 5):
total += i
print(total)
`

]]> Schéma d'accumulation à connaître. En Python,
on peut aussi écrire sum(range(1, 5)).

]]> 1.0 0.0 0 true true abc Affiche 4

]]> Erreur : on additionne plusieurs valeurs.

]]> Affiche 10 (= 1+2+3+4)

]]> Bonne réponse : range(1, 5) produit
[1, 2, 3, 4]. La somme vaut 10. C'est
le schéma « accumulateur ».

]]> Affiche 15 (= 1+2+3+4+5)

]]> Erreur : 5 est exclu de range(1, 5).

]]> Boucle infinie

]]> Erreur : for sur un range est toujours
fini.

]]> Conditions et boucles — Q11 : Boucles imbriquées Combien de fois print(...) est-il exécuté ?
`python
for i in range(3):
for j in range(2):
print(i, j)
`

]]> Règle : pour des boucles imbriquées, le total
est le produit des nombres d'itérations.

]]> 1.0 0.0 0 true true abc 9

]]> Erreur : ce serait range(3) × range(3).

]]> 6

]]> Bonne réponse : 3 × 2 = 6 itérations.
Couples : (0,0), (0,1), (1,0), (1,1), (2,0), (2,1).

]]> 5

]]> Erreur : ce serait additif (3 + 2), mais
c'est multiplicatif.

]]> 3

]]> Erreur : la double boucle multiplie les
itérations.

]]> Conditions et boucles — Q12 : Évaluation paresseuse Pourquoi False and 1/0 == 0 ne lève-t-il pas
ZeroDivisionError en Python ?

]]> Évaluation paresseuse : and s'arrête au
premier False ; or s'arrête au premier
True. Très utile pour court-circuiter des
tests coûteux ou risqués.

]]> 1.0 0.0 0 true true abc Parce que == est prioritaire sur /, donc la division n'est jamais calculée

]]> Erreur : / est prioritaire sur ==. Évaluée
seule, l'expression 1/0 == 0 lève bien
ZeroDivisionError.

]]> Parce que les nombres entiers ne plantent jamais

]]> Erreur : 1/0 plante en général.

]]> Parce que la division par zéro est tolérée par Python

]]> Erreur : 1/0 lève bien ZeroDivisionError.

]]> Parce que and est paresseux : si le premier est False, le second est ignoré

]]> Bonne réponse : Python optimise. Cela permet
des idiomes comme if liste and liste[0] >
0: (test de non-vide avant d'accéder à
l'indice 0).

]]> Conditions et boucles — Q13 : Trace d'un arrêt anticipé Que produit ce code ?
`python
i = 0
fini = False
while i < 10 and not fini:
if i == 3:
fini = True
else:
print(i)
i = i + 1
`

]]> Tracer pas à pas : à chaque tour avec i inférieur
à 3, print(i) ; à i = 3, fini
passe à True, puis le test not fini échoue.

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

]]> Erreur : au tour i = 3, c'est la branche if
qui s'exécute, pas le else : le 3 n'est pas
affiché.

]]> 0 1 2

]]> Bonne réponse : on affiche 0 1 2 ; au tour
i = 3, la branche if met fini à True sans
afficher, puis la condition du while devient
fausse.

]]> 0 1 2 3 4 5 6 7 8 9

]]> Erreur : dès que fini passe à True, la
condition not fini devient fausse et la
boucle s'arrête, bien avant i = 10.

]]> Aucune sortie

]]> Erreur : au départ fini vaut False, donc
not fini vaut True et la boucle démarre ;
l'arrêt n'intervient qu'à i = 3.

]]> Conditions et boucles — Q14 : Trace avec négation Que produit ce code ?
`python
for i in range(5):
if not (i % 2 == 0):
print(i)
`

]]> not inverse un booléen : not (i % 2 == 0)
est vrai exactement quand i est impair.
Équivalent plus direct : if i % 2 != 0:.

]]> 1.0 0.0 0 true true abc 0 2 4 (les pairs)

]]> Erreur : c'est l'inverse, le not renverse le
test de parité : on affiche ceux qui ne sont
pas pairs.

]]> 1 3 (les impairs)

]]> Bonne réponse : pour i ∈ {0, 2, 4} (pairs),
i % 2 == 0 est vrai, donc sa négation est
fausse et le print est sauté. Restent 1, 3.

]]> Boucle infinie

]]> Erreur : for sur un range est borné.

]]> 0 1 2 3 4

]]> Erreur : la condition filtre les valeurs ;
l'affichage n'a lieu que pour les impairs.

]]> Conditions et boucles — Q15 : While et condition Que fait ce code, en supposant la saisie d'un entier strictement positif ?
`python
n = int(input())
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
print(n)
`

]]> Ce code calcule la suite de Syracuse : on divise n par 2 s'il est
pair, on le remplace par 3n + 1 sinon. La conjecture de Syracuse
affirme que cette suite atteint toujours 1, quel que soit l'entier de
départ ; elle n'est pas démontrée, si bien que personne ne sait prouver
que cette boucle s'arrête pour tout n.

]]> 1.0 0.0 0 true true abc Divise n par 2 jusqu'à obtenir 1, puis affiche le nombre de divisions

]]> Erreur : quand n est impair, le code le remplace par 3 * n + 1 au lieu
de le diviser, et aucun compteur n'est calculé : ce sont les valeurs de
n qui s'affichent.

]]> Affiche les valeurs successives de n, tant que n ne vaut pas 1

]]> Bonne réponse : tant que n ne vaut pas 1, la boucle calcule la valeur
suivante et l'affiche. Pour n = 6, on obtient 3, 10, 5, 16,
8, 4, 2, 1.

]]> Boucle sans fin dès que l'entier saisi est impair

]]> Erreur : un entier impair devient pair par 3 * n + 1, puis il est
divisé par 2. Pour n = 3, le programme affiche 10, 5, 16, 8,
4, 2, 1 puis s'arrête.

]]> Affiche uniquement la valeur finale de n, une fois la boucle terminée

]]> Erreur : print(n) est dans le corps de la boucle, donc exécuté à chaque
tour. Le programme affiche toutes les valeurs prises par n, pas
seulement la dernière.

]]> Conditions et boucles — Q16 : Bug d'imbrication `python
x = 5
if x > 0:
if x > 10:
print("grand")
else:
print("moyen")
else:
print("négatif ou nul")
`
Qu'affiche le code ?

]]> Important : l'else est toujours apparié au
if du même niveau d'indentation. Lecture
attentive nécessaire.

]]> 1.0 0.0 0 true true abc moyen

]]> Bonne réponse : x = 5 entre dans le premier
if (5 > 0) ; puis comme 5 ≤ 10, on
exécute le else interne.

]]> négatif ou nul

]]> Erreur : 5 est positif.

]]> Rien

]]> Erreur : un cas est forcément exécuté.

]]> grand

]]> Erreur : 5 n'est pas > 10.

]]> Conditions et boucles — Q17 : Chaînage L'expression 0 < x < 100 en Python est
équivalente à :

]]> Cas pratique : if 0 <= i < len(liste): pour
vérifier qu'un indice est valide. Bien plus
lisible que if i >= 0 and i < len(liste):.

]]> 1.0 0.0 0 true true abc Une erreur de syntaxe

]]> Erreur : la syntaxe est valide en Python.

]]> (0 < x) < 100

]]> Erreur : ce serait du C ou du JavaScript, pas
du Python.

]]> 0 < x and x < 100

]]> Bonne réponse : Python autorise le
chaînage. Idiomatique pour les bornes.

]]> 0 < x or x < 100

]]> Erreur : c'est and (et), pas or (ou).

]]> Conditions et boucles — Q18 : Parcours de liste Quel code affiche tous les éléments d'une
liste liste, un par ligne ?

]]> Bonne pratique : for x in liste: quand on
n'a pas besoin de l'indice. Si l'indice est
utile aussi, on parcourt les indices avec
for i in range(len(liste)): et on lit
l'élément par liste[i].

]]> 1.0 0.0 0 true true abc `python
while i in liste:
print(i)
`

]]> Erreur : i in liste est un test, pas une
itération. Et i n'est pas défini.

]]> `python
for x in liste:
print(x)
`

]]> Bonne réponse : la boucle parcourt
directement les éléments, du premier au
dernier, sans manipuler d'indice.

]]> `python
do print(x) for x in liste
`

]]> Erreur : syntaxe invalide en Python (peut-
être Ruby ou Perl).

]]> `python
for i in range(len(liste) - 1):
print(liste[i])
`

]]> Erreur : range(len(liste) - 1) s'arrête un
indice trop tôt, donc le dernier élément
n'est jamais affiché. Il faudrait
range(len(liste)).

]]> Conditions et boucles — Q19 : Compréhension de liste Quel est l'équivalent pythonique de :
`python
carres = []
for i in range(10):
carres.append(i * i)
`

]]> Compréhension de liste générale :
[expr for x in iterable if cond]. Très
utilisée en Python pour les transformations
simples.

]]> 1.0 0.0 0 true true abc carres = [i * i for i in range(10)]

]]> Bonne réponse : compréhension de liste,
plus concise et idiomatique.

]]> carres = [i * 2 for i in range(10)]

]]> Erreur : i * 2 calcule le double, pas le
carré : on obtient [0, 2, 4, ..., 18] au
lieu de [0, 1, 4, ..., 81].

]]> carres = range(10) ** 2

]]> Erreur : on ne peut pas élever un range au
carré.

]]> carres = [10][i * i]

]]> Erreur : syntaxe invalide.

]]> Conditions et boucles — Q20 : Trace de while Que vaut n à la fin de :
`python
n = 100
while n > 1:
n = n // 2
`

]]> Cette boucle calcule combien de fois on peut
diviser n par 2. C'est le logarithme entier
en base 2 (motif de complexité O(log n)).

]]> 1.0 0.0 0 true true abc Une infinité

]]> Erreur : n // 2 réduit n à chaque tour.

]]> 1

]]> Bonne réponse : trace : 100 → 50 → 25 → 12
→ 6 → 3 → 1. À ce moment, 1 > 1 est faux,
on sort.

]]> 2

]]> Erreur : 2 // 2 = 1, donc on continue.

]]> 0

]]> Erreur : la boucle s'arrête quand n ≤ 1, donc
n vaut au moins 1 à la fin.

]]> Conditions et boucles — Q21 : Boucle infinie Pourquoi cette boucle est-elle infinie ?
`python
i = 0
while i < 10:
print(i)
`

]]> Bug ultra-classique chez les débutants. Toujours
vérifier qu'un variant (ici, i) progresse
vers la condition de sortie.

]]> 1.0 0.0 0 true true abc Parce que l'initialisation i = 0 serait fausse

]]> Erreur : 0 < 10 est vrai.

]]> Parce que while est toujours infini

]]> Erreur : while peut très bien terminer.

]]> Parce que i n'est jamais modifié dans la boucle

]]> Bonne réponse : il faut ajouter i += 1
pour que la condition i < 10 finisse par
devenir fausse.

]]> Parce que print ne renvoie rien

]]> Le fait que print ne
renvoie pas de valeur
(autre que None) n'a
aucun lien avec la
terminaison de la boucle.
Ce qui pose problème ici,
c'est que i n'évolue
jamais.

]]> Conditions et boucles — Q22 : Borne d'un range modifiée en cours de boucle Qu'affiche ce code ?
`python
n = 3
for i in range(n):
n = n + 1
print(i, n)
`

]]> range(n) est construit une seule fois, à l'entrée
dans la boucle. Le nombre de tours est figé à ce
moment-là : modifier n ensuite n'allonge pas la
boucle, à la différence d'une liste que l'on
modifie pendant son parcours.

]]> 1.0 0.0 0 true true abc 3 6, car i termine à la valeur de la borne de départ, c'est-à-dire 3

]]> Erreur : range(3) produit 0, 1 puis 2, jamais 3.
La dernière valeur prise par i est 2, car la
borne d'un range est exclue.

]]> Une erreur à l'exécution, car n ne peut pas être modifiée pendant le parcours de range(n)

]]> Erreur : aucune règle n'interdit d'affecter n
dans le corps de la boucle ; le code s'exécute
sans erreur. Une fois la boucle lancée, n et
la suite range(3) sont indépendants.

]]> 2 6, car range(3) est calculé une fois pour toutes au début de la boucle

]]> Bonne réponse : range(n) est évalué une seule
fois, avec n valant 3 ; la boucle fait donc
3 tours (i vaut 0, 1 puis 2) et n est
incrémenté 3 fois, de 3 à 6.

]]> La boucle ne s'arrête jamais, car n augmente d'une unité à chaque tour

]]> Erreur : la borne n'est pas relue à chaque tour.
Modifier n dans le corps ne change pas la
suite range(3) déjà construite, contrairement
à une liste que l'on allonge en la parcourant.

]]> Conditions et boucles — Q23 : Deux conditions pour un même while Qu'affiche ce programme ?
`python
i = 0
total = 0
while i < 10 and total <= 12:
i = i + 1
if i % 2 == 0:
total = total + i
print(i, total)
`

]]> Une boucle while dont la condition relie
deux tests par and s'arrête dès que l'un
d'eux devient faux. La condition n'est évaluée
qu'au début de chaque tour : pour une trace, on
la vérifie après chaque tour complet.

]]> 1.0 0.0 0 true true abc 6 12

]]> Erreur : quand total vaut 12, la condition
total <= 12 est encore vraie, donc la
boucle continue : i passe à 7 puis à 8, et
total à 20.

]]> 8 20

]]> Bonne réponse : total vaut 2, 6 puis 12
après les tours où i vaut 2, 4 et 6. Comme
12 <= 12 est vrai, la boucle continue ; au
tour où i vaut 8, total passe à 20 et le
test suivant échoue.

]]> 10 30

]]> Erreur : ce résultat ignore la seconde
condition. Le and exige les deux : dès que
total dépasse 12, la boucle s'arrête, bien
avant que i atteigne 10.

]]> 8 12

]]> Erreur : la condition n'est testée qu'au
début de chaque tour, jamais au milieu. Le
tour où i vaut 8 s'exécute en entier et
total passe à 20 avant le test suivant.

]]> Conditions et boucles — Q24 : Compteur avec if et elif Qu'affiche ce code ?
`python
c = 0
for n in range(1, 16):
if n % 3 == 0:
c = c + 1
elif n % 5 == 0:
c = c + 2
print(c)
`

]]> Dans un if/elif, une seule branche s'exécute
par tour. Il faut donc trier chaque valeur de
range(1, 16) : multiples de 3 (5 valeurs),
puis multiples de 5 restants (5 et 10).

]]> 1.0 0.0 0 true true abc 11

]]> Erreur : 15 est compté deux fois, comme avec
deux if indépendants. Avec elif, la
seconde condition n'est pas testée quand la
première est vraie.

]]> 7

]]> Erreur : la branche elif ajoute 2, pas 1 ;
5 et 10 apportent donc 4 au total, et non 2.

]]> 5

]]> Erreur : la branche elif est ignorée ; 5 et 10, qui ne sont pas multiples de 3, y entrent
et ajoutent 2 chacun.

]]> 9

]]> Bonne réponse : 5 multiples de 3 (3, 6, 9, 12, 15) ajoutent 1 chacun ; 5 et 10 ajoutent 2
chacun ; 15, déjà pris par le if, n'entre
pas dans le elif. Total 5 + 4 = 9.

]]> Conditions et boucles — Q25 : Synthèse Parmi les affirmations suivantes, laquelle est
fausse ?

]]> Le while teste d'abord, exécute ensuite : une
boucle while peut ne faire aucun tour, alors
qu'une boucle for sur un range fini termine
toujours.

]]> 1.0 0.0 0 true true abc La boucle while peut être infinie si la condition ne devient jamais fausse

]]> Vrai : risque classique de bug.

]]> La boucle for sur un range fini termine toujours sans intervention

]]> Vrai : terminaison automatique.

]]> La condition d'un while n'est vérifiée qu'après chaque exécution du corps

]]> Faux (donc bonne réponse) : la condition est
testée avant chaque tour, y compris le
premier. Si elle est fausse d'emblée, le corps
ne s'exécute jamais.

]]> Les opérateurs logiques and, or, not permettent de combiner des conditions

]]> Vrai : ce sont les trois opérateurs
booléens.

]]> Conditions et boucles — Q26 : Boucle de saisie validée On veut que l'utilisateur saisisse un entier
strictement positif et redemander tant que la
réponse n'est pas correcte. Quel code convient le
mieux ?

]]> Schéma de validation de saisie : initialiser la
variable avec une valeur qui ne convient pas, pour
forcer un premier tour, puis répéter tant que la
valeur ne convient pas. La condition du while
dit exactement « tant que la saisie est mauvaise ».

]]> 1.0 0.0 0 true true abc `python
n = int(input("n ? "))
if n <= 0:
n = int(input("n ? "))
`

]]> Erreur : ce code ne redemande qu'une seule fois la valeur. Si l'utilisateur entre encore
une valeur invalide à la deuxième saisie, le
programme continue avec cette valeur erronée.

]]> `python
n = 0
while n <= 0:
n = int(input("n ? "))
`

]]> Bonne réponse : n est initialisé à une valeur
invalide (0 n'est pas strictement positif), ce
qui garantit un premier passage ; la boucle
redemande ensuite tant que la saisie reste
négative ou nulle.

]]> `python
for i in range(10):
n = int(input("n ? "))
`

]]> Erreur : ce code demande dix fois la valeur,
quelle que soit la qualité des saisies, et
conserve la dernière. Il ne s'arrête pas dès
qu'une bonne valeur est donnée.

]]> `python
n = -1
while n > 0:
n = int(input("n ? "))
`

]]> Erreur : la condition initiale n > 0 est
fausse (puisque n = -1), donc la boucle ne
s'exécute jamais. Aucune saisie n'est
réellement effectuée.

]]> Conditions et boucles — Q27 : if/elif vs plusieurs if Considérons les deux extraits suivants. En quoi
diffèrent-ils ?

``python
# Extrait A
if x > 0:
y = 1
elif x > 10:
y = 2

# Extrait B
if x > 0:
y = 1
if x > 10:
y = 2
``

]]> Règle pratique : utiliser elif lorsque les
branches s'excluent mutuellement (un seul cas est
vrai à la fois). Utiliser des if séparés
lorsqu'on veut vraiment que plusieurs
conditions puissent déclencher chacune leur action.

]]> 1.0 0.0 0 true true abc L'extrait A produit une erreur car elif ne fonctionne pas seul

]]> Erreur : elif est un mot-clé valide en Python
tant qu'il suit un if. Sa présence ne
provoque aucune erreur de syntaxe.

]]> A n'exécute qu'une seule branche ; B peut exécuter les deux

]]> Bonne réponse : elif indique que l'on
n'évalue cette branche que si la précédente
était fausse. Avec deux if séparés, les deux
conditions sont toujours vérifiées
indépendamment, ce qui peut conduire à des
réaffectations indésirables.

]]> Ils produisent toujours le même résultat, quelle que soit la valeur de x

]]> Erreur : ils diffèrent justement quand x est
strictement supérieur à 10. L'extrait A donne
y = 1 (la branche elif n'est pas testée
parce que la première est vraie), l'extrait B
donne y = 2 (les deux conditions s'évaluent).

]]> L'extrait B est plus rapide, car il évite le mot-clé elif

]]> Erreur : la différence ne porte pas sur la
vitesse mais sur la logique. L'extrait A
peut au contraire être plus rapide, car il
n'évalue pas la deuxième condition lorsque la
première est vraie.

]]> Conditions et boucles — Q28 : Parcours parallèle de deux listes Deux listes noms et notes de même longueur
rangent au même rang le nom d'un élève et sa note.
Quel code affiche chaque nom suivi de sa note ?

]]> Le parcours par indice for i in range(len(...))
est le moyen d'accéder au même rang dans deux
listes. L'hypothèse « de même longueur » garantit
que notes[i] existe pour tout indice valide de
noms.

]]> 1.0 0.0 0 true true abc `python
for nom in noms:
print(nom, notes[nom])
`

]]> Erreur : nom est une chaîne, pas un indice.
notes[nom] lève TypeError, car une liste ne
s'indexe qu'avec un entier. Pour retrouver le
rang, il faut parcourir les indices.

]]> `python
print(noms + notes)
`

]]> Erreur : la concaténation noms + notes produit
une seule liste juxtaposant les deux. Il n'y a
pas d'appariement, et tout est affiché en bloc.

]]> `python
for i in range(len(noms)):
print(noms[i], notes[i])
`

]]> Bonne réponse : l'indice i parcourt les
positions de 0 à len(noms) - 1 et sert à lire
au même rang le nom et la note qui lui
correspond.

]]> `python
for nom in noms:
for note in notes:
print(nom, note)
`

]]> Erreur : ces boucles imbriquées affichent
toutes les paires (nom, note), pas
uniquement celles de même rang. Pour deux
listes de longueur n, on obtient n²
lignes au lieu de n.

]]> Conditions et boucles — Q29 : Calcul d'une racine entière On exécute le code suivant :
`python
n = 30
r = 0
while r * r <= n:
r = r + 1

Quelle est la valeur de r` à la sortie de la boucle ?

]]> Cet algorithme calcule le plus petit entier r
tel que r² > n. À la sortie, r - 1 est la
partie entière de √n. Pour n = 30, on
obtient r = 6, et r - 1 = 5, conforme à
\lfloor\sqrt{30}\rfloor = 5.

]]> 1.0 0.0 0 true true abc 30

]]> Erreur : confusion entre la valeur cible n et
la variable r. La boucle calcule la racine carrée entière par majorant, pas la valeur de
n.

]]> 6

]]> Bonne réponse : la boucle s'arrête dès que
r × r > n. Pour r = 5, 25 ≤ 30 :
on incrémente. Pour r = 6, 36 > 30 : on
sort. La valeur finale est donc r = 6.

]]> 7

]]> Erreur : la boucle s'arrête dès que la condition
devient fausse, sans incrémenter une fois de
plus. Pour r = 6, on a déjà 36 > 30 : la
boucle est sortie avec r = 6.

]]> 5

]]> Erreur : pour r = 5, on a r × r = 25 ≤ 30, donc la condition est encore vraie.
La boucle fait au moins une itération de plus.

]]> Conditions et boucles — Q30 : Combien de branches s'exécutent Dans une structure if ... elif ... elif ... else, combien de
branches sont exécutées lors d'un passage ?

]]> elif enchaîne des cas exclusifs : un seul bloc s'exécute, ce qui
distingue cette structure d'une suite de if.

]]> 1.0 0.0 0 true true abc Au moins deux, le else s'exécutant toujours

]]> Erreur : le else n'est atteint que si toutes les conditions
sont fausses.

]]> Exactement une, la première vraie ou le else

]]> Bonne réponse : les conditions sont testées dans l'ordre et la
première vraie l'emporte ; si aucune ne l'est, le else
s'exécute.

]]> Aucune, si plusieurs conditions sont vraies à la fois

]]> Erreur : plusieurs conditions vraies ne bloquent rien ; la
première l'emporte.

]]> Toutes celles dont la condition est vraie, dans l'ordre

]]> Erreur : ce serait le comportement de plusieurs if
indépendants, pas d'une chaîne elif.

]]> Conditions et boucles — Q31 : Trois issues pour un nombre Qu'affiche ce programme ?
`python
x = 5
if x > 0:
if x < 10:
print("A")
else:
print("B")
else:
print("C")
`

]]> Deux if imbriqués découpent les cas en arbre ; lire
l'indentation dit quel else répond à quel if.

]]> 1.0 0.0 0 true true abc Rien, aucune branche ne convenant à 5

]]> Erreur : tout nombre tombe dans une des trois branches.

]]> A

]]> Bonne réponse : le premier test sépare les positifs des autres,
le second, imbriqué, sépare les positifs inférieurs à 10 des
autres. Pour 5, c'est A.

]]> B

]]> Erreur : suis les tests dans l'ordre, en respectant
l'indentation de chaque else.

]]> C

]]> Erreur : chaque else est rattaché au if de même niveau.

]]> Conditions et boucles — Q32 : Une double inégalité en Python Python accepte l'écriture 0 < x < 10. À quelle condition est-elle
équivalente ?

]]> Les comparaisons chaînées traduisent directement les doubles
inégalités mathématiques, avec la sémantique du and.

]]> 1.0 0.0 0 true true abc 0 < x < 10 n'est pas une expression valide

]]> Erreur : l'écriture est valide et très lisible pour un
intervalle.

]]> (0 < x) < 10

]]> Erreur : cette lecture comparerait un booléen à 10, ce qui est
toujours vrai ; Python ne lit pas ainsi.

]]> 0 < x and x < 10

]]> Bonne réponse : une comparaison chaînée vérifie chaque
inégalité, reliées par un and implicite.

]]> 0 < x or x < 10

]]> Erreur : avec or, tout nombre conviendrait.

]]> Conditions et boucles — Q33 : Diviser par deux jusqu'à un Combien de tours effectue cette boucle ?
`python
n = 20
while n > 1:
n = n // 2
`

]]> Une boucle qui divise par deux fait environ \log_2 n tours : c'est
le schéma de la dichotomie.

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : dès que n vaut 1, la condition n > 1 est fausse
et aucun tour supplémentaire n'a lieu.

]]> 4

]]> Bonne réponse : n prend les valeurs 20, 10, 5, 2, 1 ; chaque division
entière est un tour, et la boucle s'arrête dès que n vaut 1.

]]> 20

]]> Erreur : n est divisé par deux à chaque tour, pas diminué de
un.

]]> 3

]]> Erreur : le tour qui fait passer n à 1 compte aussi.

]]> Conditions et boucles — Q34 : Deux boucles while imbriquées Qu'affiche ce programme ?
`python
i = 0
total = 0
while i < 4:
j = 0
while j < i:
total = total + 1
j = j + 1
i = i + 1
print(total)
`

]]> Deux boucles imbriquées se comptent en additionnant les tours de la
boucle intérieure pour chaque valeur de la boucle extérieure.

]]> 1.0 0.0 0 true true abc 16

]]> Erreur : la boucle intérieure ne fait pas toujours 4 tours,
elle en fait i.

]]> 4

]]> Erreur : total est incrémenté dans la boucle intérieure, bien
plus de 4 fois au total.

]]> 0

]]> Erreur : dès que i vaut 1, la boucle intérieure tourne au
moins une fois.

]]> 6

]]> Bonne réponse : la boucle intérieure fait i tours à chaque
passage, soit 0, puis 1, jusqu'à 4 - 1. Leur somme vaut
6.

]]> Conditions et boucles — Q35 : Le premier multiple qui dépasse Qu'affiche ce programme ?
`python
k = 1
while k 7 < 50:
k = k + 1
print(k 7)
`

]]> La valeur affichée est celle qui rend la condition fausse pour la
première fois : un while s'arrête juste après avoir dépassé le
seuil.

]]> 1.0 0.0 0 true true abc 7

]]> Erreur : 7 est la valeur initiale de k * 7, et la condition
est vraie au départ.

]]> 49

]]> Erreur : 49 est encore inférieur à 50, la boucle fait
un tour de plus.

]]> 50

]]> Erreur : 50 n'est pas un multiple de 7, k * 7 ne peut pas
valoir 50.

]]> 56

]]> Bonne réponse : k augmente tant que k 7 reste inférieur à
50 ; à la sortie, k 7 est le premier multiple de 7 qui
atteint ou dépasse 50.

]]> Conditions et boucles — Q36 : Un range qui descend par pas de trois Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?
`python
for i in range(10, 0, -3):
print(i)
`

]]> range(debut, fin, pas) accepte un pas négatif : les valeurs
descendent de debut vers fin, exclue.

]]> 1.0 0.0 0 true true abc 10 7 4 1 -2

]]> Erreur : la borne 0 est exclue, et aucune valeur négative n'est
produite.

]]> 10 7 4 1

]]> Bonne réponse : i part de 10 et diminue de 3 à chaque
tour, tant qu'il reste strictement supérieur à 0, borne
exclue.

]]> 10 7 4

]]> Erreur : la dernière valeur positive est encore produite.

]]> 1 4 7 10

]]> Erreur : un pas négatif parcourt les valeurs en descendant.

]]>