$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");
`

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

]]> `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")
`

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

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

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

]]> 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 simplement un alias pour le mot-clé if

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

]]> C'est un alias pour else

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

]]> 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 Une infinité

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

]]> 4

]]> Erreur : range(5) produit 5 valeurs (0, 1,
2, 3, 4).

]]> 5

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

]]> 6

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

]]> 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 [3, 4, 5, 6, 7]

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

]]> [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).

]]> [2, 7]

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

]]> 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 1 à 10 dans l'ordre croissant

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

]]> 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.

]]> 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.

]]> 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.

]]> 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 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.

]]> 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 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 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.

]]> 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 9

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

]]> 20

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

]]> 27

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

]]> 81

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

]]> 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 vrai pour n = 0 ou
n = 1, pas pour la parité.

]]> n % 2 == 0

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

]]> n / 2 == 0

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

]]> n == 2

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

]]> 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 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 ».

]]> Boucle infinie

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

]]> Affiche 4

]]> Erreur : on additionne plusieurs valeurs.

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

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

]]> 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 5

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

]]> 3

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

]]> 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).

]]> 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 la division par zéro est tolérée par Python

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

]]> Parce que les nombres entiers ne plantent jamais

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

]]> 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 : i = 0 → print(0) ; i = 1 →
print(1) ; i = 2 → print(2) ; i = 3 → fini
passe à True, puis le test not fini échoue.

]]> 1.0 0.0 0 true true abc 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.

]]> 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

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

]]> 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 Boucle infinie

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

]]> 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 et 3.

]]> 0 1 2 3 4

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

]]> 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.

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

]]> La conjecture de Syracuse (1937) demeure ouverte
en mathématiques : on ne sait pas prouver que la
suite atteint toujours 1 pour tout n entier
positif.

]]> 1.0 0.0 0 true true abc Boucle infinie systématique

]]> Erreur : pour tout n testé jusqu'à présent,
la suite atteint 1.

]]> Affiche la suite de Fibonacci

]]> Erreur : aucune relation avec Fibonacci.

]]> Calcule la suite de Syracuse jusqu'à atteindre 1

]]> Bonne réponse : c'est l'algorithme classique
dont la terminaison est une conjecture
(non démontrée, mais vérifiée pour de très
grandes valeurs).

]]> Lève systématiquement une exception à l'exécution

]]> Erreur : code valide.

]]> 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 Rien

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

]]> négatif ou nul

]]> Erreur : 5 est positif.

]]> moyen

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

]]> 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 0 < x or x < 100

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

]]> 0 < x and x < 100

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

]]> 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.

]]> Conditions et boucles — Q18 : Parcours de liste Quelle est la façon la plus pythonique d'afficher
les éléments d'une liste ?

]]> 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 : forme idiomatique Python.
Plus lisible et moins sujette aux erreurs
d'indice.

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

]]> Code correct mais peu pythonique. Préférer
la boucle directe sur les éléments.

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

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

]]> 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 = [10][i * i]

]]> Erreur : syntaxe invalide.

]]> 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é.

]]> 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.

]]> 0

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

]]> 2

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

]]> 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 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.

]]> Parce que while est toujours infini

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

]]> Parce que l'initialisation i = 0 serait fausse

]]> Erreur : 0 < 10 est vrai.

]]> 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.

]]> 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 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
trois tours (i vaut 0, 1 puis 2) et n est
incrémenté trois 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.

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

]]> Erreur : range(3) produit 0, 1 et 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.

]]> Conditions et boucles — Q23 : Modifier en parcourant Que se passe-t-il à l'exécution de ce code ?
`python
liste = [1, 2, 3]
for x in liste:
liste.append(x * 2)
`

]]> Règle de sécurité : ne jamais modifier une
collection pendant qu'on la parcourt. Parcourir
une copie (liste[:]) ou construire une nouvelle
liste.

]]> 1.0 0.0 0 true true abc La boucle ne s'arrête jamais, car la liste s'allonge à chaque tour

]]> Bonne réponse : la boucle for lit la liste
telle qu'elle est au moment de chaque tour ;
comme chaque tour ajoute un élément, la fin
n'est jamais atteinte. Ne jamais modifier une
liste pendant qu'on la parcourt.

]]> La boucle fait trois tours et la liste finale vaut [1, 2, 3, 2, 4, 6]

]]> Erreur : le for ne fige pas la liste au
départ ; il consulte sa longueur courante à
chaque tour et trouve toujours un élément de
plus. Ce résultat exigerait de parcourir une
copie, for x in liste[:]:.

]]> Python lève une erreur, car une liste ne peut pas être modifiée pendant son parcours

]]> Erreur : Python n'interdit rien ici, aucune
exception n'est levée ; c'est justement ce
silence qui rend le piège dangereux.

]]> La boucle fait trois tours, car append ne modifie pas liste mais en renvoie une copie

]]> Erreur : append modifie la liste sur
place (et renvoie None) : c'est bien la
liste parcourue qui grandit.

]]> 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 (cinq valeurs),
puis multiples de 5 restants (5 et 10).

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : cinq 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.

]]> 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.

]]> 5

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

]]> 7

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

]]> 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 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.

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

]]> Vrai : terminaison automatique.

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

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

]]> La boucle while peut être infinie si la condition ne devient jamais fausse

]]> Vrai : risque classique de bug.

]]> 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
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 = 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
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.

]]> `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.

]]> 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 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).

]]> 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.

]]> 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.

]]> 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
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.

]]> `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.

]]> 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 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.

]]> 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.

]]> 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.

]]> 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.

]]>