<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<question type="category">
  <category>
    <text>$course$/QCM de NSI/SNT/9. Révision de fin d'année</text>
  </category>
  <info format="html">
    <text><![CDATA[<p>Toutes les notions des huit chapitres de programmation mêlées :<br/>
variables, types, entrées et sorties, conditions, boucles bornées et<br/>
non bornées, fonctions, listes, lecture d'un message d'erreur. Pour<br/>
réviser en fin d'année ou en début de première.</p>]]></text>
  </info>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q01 : Une suite d'affectations</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme note les dimensions d'une photographie, en pixels.<br/>
<pre><code>largeur = 1024
hauteur = 768
hauteur = largeur
largeur = 640</code></pre><br/>
Que vaut <code>hauteur</code> à la fin ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>En Python, le signe <code>=</code> n'énonce pas une égalité mathématique, il range<br/>
une valeur dans une variable. Une affectation se lit de droite à gauche,<br/>
et seule la variable écrite à gauche change.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>768</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la valeur du départ, mais la troisième ligne l'a<br/>
remplacée par celle de <code>largeur</code>. Une affectation écrase sans<br/>
prévenir ce que la variable contenait.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>1024</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la troisième ligne recopie dans <code>hauteur</code> la valeur<br/>
que <code>largeur</code> porte à cet instant, soit 1024. La ligne suivante ne<br/>
touche qu'à <code>largeur</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>640</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose qu'une affectation crée un lien durable entre les<br/>
deux variables. Elle recopie une valeur une fois pour toutes, puis<br/>
chaque variable vit de son côté.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1792</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : additionne les deux valeurs. Le signe <code>=</code> ne calcule rien,<br/>
il range dans la variable de gauche la valeur trouvée à droite.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q02 : Repérer une chaîne de caractères</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un objet connecté range quatre informations dans quatre variables.</p>
<pre><code>ville = "Lyon"
altitude = 173
humide = True
vitesse = 12.5</code></pre>
<p>Laquelle contient une chaîne de caractères ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Les quatre types de base se reconnaissent à l'écriture : guillemets pour<br/>
une chaîne, chiffres seuls pour un entier, point décimal pour un<br/>
flottant, <code>True</code> ou <code>False</code> pour un booléen.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>altitude</code>, qui contient <code>173</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 173 est un nombre entier. Il s'écrit sans guillemets et<br/>
sans point décimal, et se prête aux calculs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>humide</code>, qui contient <code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>True</code> est un booléen, l'une des deux seules valeurs de<br/>
vérité. Il s'écrit sans guillemets et ne peut valoir que vrai ou<br/>
faux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>vitesse</code>, qui contient <code>12.5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 12.5 est un nombre flottant, reconnaissable à son point<br/>
décimal. Les guillemets sont absents.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>ville</code>, qui contient <code>"Lyon"</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les guillemets font de <code>Lyon</code> une suite de<br/>
caractères, et non un nom de variable.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q03 : Un compteur de messages</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une application compte les messages reçus.<br/>
<pre><code>messages = 0
messages = messages + 3
messages = messages + 2
print(messages)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La ligne <code>messages = messages + 3</code> se lit en deux temps : on calcule<br/>
d'abord <code>messages + 3</code> avec la valeur actuelle, puis on range le<br/>
résultat dans <code>messages</code>. C'est le schéma de tout compteur.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la variable part de 0, reçoit 3, puis 2 de plus.<br/>
Chaque ligne lit la valeur courante, ajoute un nombre et range le<br/>
total au même endroit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ne retient que la première addition. La ligne d'après<br/>
repart de 3 et ajoute encore 2.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose que la dernière addition remplace tout ce qui a<br/>
été calculé avant. Elle ajoute 2 à ce que la variable contient<br/>
déjà.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : retient la valeur du départ. Les deux lignes qui suivent<br/>
modifient bel et bien la variable avant l'affichage.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q04 : Un échange de coordonnées manqué</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme voudrait échanger la latitude et la longitude relevées par<br/>
un récepteur.<br/>
<pre><code>lat = 45
lon = 4
lat = lon
lon = lat
print(lat, lon)</code></pre><br/>
Qu'affiche-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Échanger deux variables réclame une troisième variable, chargée de<br/>
garder la valeur qui va être écrasée. Sans elle, la première<br/>
affectation détruit ce que la seconde devait recopier.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>45 4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce sont les valeurs du départ, comme si les deux<br/>
affectations n'avaient rien fait. La troisième ligne modifie<br/>
pourtant <code>lat</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4 45</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'échange souhaité, mais le programme ne l'obtient<br/>
pas. La valeur 45 disparaît dès que <code>lat</code> reçoit celle de <code>lon</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4 4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>lat</code> prend la valeur 4, puis <code>lon</code> reçoit cette<br/>
même valeur 4. L'ancienne valeur de <code>lat</code> n'existe plus nulle part.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>45 45</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le résultat du même enchaînement mené dans l'autre<br/>
sens, où <code>lon</code> recevrait d'abord la valeur de <code>lat</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q05 : La division entière</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme range 7 photographies sur des pages de 2 photographies.<br/>
<pre><code>print(7 // 2)</code></pre><br/>
Qu'affiche-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Trois opérateurs cohabitent : <code>/</code> donne un quotient décimal, <code>//</code> le<br/>
quotient entier, <code>%</code> le reste. Ici, 7 vaut 3 fois 2, plus 1.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3.5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le résultat de <code>7 / 2</code>, la division ordinaire, qui<br/>
donne un flottant. La barre doublée demande le quotient entier.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>//</code> donne le nombre de fois que 2 tient dans 7,<br/>
soit 3, en abandonnant la partie décimale.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le résultat de <code>7 % 2</code>, qui donne le reste de la<br/>
division et non le quotient.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : arrondit 3.5 au plus proche. La division entière<br/>
n'arrondit pas, elle abandonne la partie décimale.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q06 : Une condition avec and</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>L'éclairage d'un escalier lit deux capteurs.</p>
<pre><code>sombre = True
presence = False
print(sombre and presence)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>and</code> exige les deux conditions, <code>or</code> se contente d'une seule, <code>not</code><br/>
inverse. Ces trois mots suffisent à écrire la règle de commande d'un<br/>
objet connecté.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>and</code> n'est vrai que si ses deux côtés le sont. Le<br/>
second vaut ici <code>False</code>, donc le résultat aussi.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait le résultat de <code>or</code>, vrai dès qu'un seul côté<br/>
l'est. Avec <code>and</code>, les deux sont exigés en même temps.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>True False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose que <code>print</code> affiche les deux variables. Il ne<br/>
reçoit qu'une seule valeur, celle que <code>and</code> vient de calculer.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>None</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>None</code> marque l'absence de valeur. Une opération entre<br/>
booléens donne toujours <code>True</code> ou <code>False</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q07 : La bonne condition d'alerte</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un capteur sur pile doit lancer une alerte lorsque son niveau de<br/>
batterie est strictement inférieur à 20 et que l'appareil n'est pas en<br/>
charge. La variable <code>en_charge</code> vaut <code>True</code> pendant une recharge.<br/>
Quelle ligne convient ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Traduire une phrase en condition demande de repérer le mot de liaison,<br/>
ici « et », et la négation, ici « n'est pas ». <code>and</code> traduit le premier,<br/>
<code>not</code> la seconde.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if niveau &lt; 20 or not en_charge:</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : avec <code>or</code>, une seule des deux conditions suffit. L'alerte<br/>
partirait pour un capteur chargé à 80 %, au seul motif qu'il n'est<br/>
pas branché.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if niveau &lt; 20 and en_charge:</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette ligne réclame l'inverse, une batterie basse pendant<br/>
la recharge. L'alerte ne partirait jamais pour un appareil<br/>
débranché.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if not niveau &lt; 20 and not en_charge:</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>not niveau &lt; 20</code> exige un niveau d'au moins 20. La<br/>
condition serait vraie pour un capteur plein et débranché, jamais<br/>
pour un capteur vide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>if niveau &lt; 20 and not en_charge:</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>and</code> réunit les deux exigences et <code>not</code> inverse la<br/>
valeur de <code>en_charge</code>, ce qui traduit « pas en charge ».</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q08 : Ce que renvoie input</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un questionnaire en ligne réclame un nombre.</p>
<pre><code>reponse = input("Combien de messages as-tu reçus ? ")</code></pre>
<p>L'utilisateur tape 12. Que contient <code>reponse</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>input</code> rend toujours une chaîne de caractères. Pour calculer avec la<br/>
saisie, il faut la convertir, par exemple avec <code>int(reponse)</code> pour<br/>
obtenir un entier.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'entier 12, converti par Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune conversion n'a lieu d'elle-même. Obtenir un entier<br/>
demande de l'écrire, avec <code>int(reponse)</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le flottant 12.0, issu du clavier</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun point décimal n'a été saisi, et le clavier ne<br/>
convertit rien. La saisie arrive telle qu'elle a été tapée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>La chaîne de caractères « 12 »</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>input</code> rend toujours une chaîne, faite ici des deux<br/>
caractères 1 et 2, même quand la saisie ressemble à un nombre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le booléen True, la saisie n'étant pas vide</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un booléen ne sert qu'à répondre par vrai ou faux. <code>input</code><br/>
rend le texte saisi, sans le juger.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q09 : Une addition qui échoue</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme s'arrête sur une erreur.</p>
<pre><code>reponse = input("Nombre de messages : ")
total = reponse + 1
print(total)</code></pre>
<p>Pourquoi ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le signe <code>+</code> additionne deux nombres et met deux chaînes bout à bout,<br/>
mais ne mélange pas les deux genres. Toute saisie destinée à un calcul<br/>
doit d'abord être convertie.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la variable <code>total</code> n'a pas été créée avant d'être<br/>
utilisée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la deuxième ligne crée justement <code>total</code>. Une variable naît<br/>
de sa première affectation, elle n'a pas à être annoncée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce que <code>input</code> renvoie une chaîne, et non un entier</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python refuse d'ajouter un entier à une chaîne et<br/>
signale <code>TypeError: can only concatenate str (not "int") to str</code>.<br/>
Il faut écrire <code>int(reponse) + 1</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que le texte affiché par <code>input</code> contient un deux-points</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le texte passé à <code>input</code> est un simple message d'invite.<br/>
Son contenu n'a aucun effet sur le calcul qui suit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que <code>print</code> ne sait afficher que des chaînes de caractères</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>print</code> affiche aussi bien un entier qu'une chaîne.<br/>
L'erreur survient avant l'affichage, sur la ligne de l'addition.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q10 : Tester une égalité</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un thermostat doit réagir quand la température relevée vaut exactement<br/>
30. Quelle ligne écrit ce test ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un signe simple affecte, un signe doublé compare. La confusion est si<br/>
répandue que Python propose lui-même la correction dans son message<br/>
d'erreur.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>if temperature == 30:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : le signe doublé compare deux valeurs et donne <code>True</code><br/>
ou <code>False</code>. C'est exactement ce qu'une condition attend.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>if temperature = 30:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le signe simple range une valeur dans une variable, il ne<br/>
compare rien. Python refuse la ligne et signale une <code>SyntaxError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>if temperature === 30:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le signe triplé vient d'un autre langage. Python ne le<br/>
connaît pas et signale <code>SyntaxError: invalid syntax</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>if egale(temperature, 30):</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune fonction de ce nom n'existe. Python signale<br/>
<code>NameError: name 'egale' is not defined</code> au moment de l'appel.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q11 : La branche retenue</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un capteur de qualité de l'air range son relevé en trois catégories.</p>
<pre><code>indice = 55
if indice &lt; 50:
    print("bon")
elif indice &lt; 100:
    print("moyen")
else:
    print("mauvais")</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Les conditions sont examinées de haut en bas et la première vraie<br/>
l'emporte. Celles qui la suivent ne sont même pas évaluées.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>bon</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 55 n'est pas inférieur à 50. La première condition est<br/>
donc fausse et sa branche est sautée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>mauvais</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la branche <code>else</code> ne sert que si aucune condition n'a été<br/>
trouvée vraie. Celle du <code>elif</code> l'est ici.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>moyen</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la première condition est fausse, la deuxième est<br/>
vraie puisque 55 est inférieur à 100. Seule sa branche s'exécute.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>bon</code> puis <code>moyen</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose que plusieurs branches peuvent s'exécuter. Un<br/>
enchaînement <code>if</code>, <code>elif</code>, <code>else</code> n'en retient jamais qu'une.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q12 : Une branche jamais atteinte</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme classe une vitesse relevée par un radar, mais il n'affiche<br/>
jamais « autoroute », quelle que soit la vitesse.</p>
<pre><code>vitesse = 120
if vitesse &gt; 50:
    print("hors agglomération")
elif vitesse &gt; 110:
    print("autoroute")
else:
    print("agglomération")</code></pre>
<p>Comment l'expliquer ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Dans un enchaînement de conditions, l'ordre compte autant que les<br/>
seuils. Quand les intervalles se recouvrent, la condition la plus<br/>
exigeante doit venir en tête.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce qu'une instruction <code>elif</code> ne peut pas tester deux fois la<br/>
même variable</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : rien n'interdit de tester plusieurs fois la même variable.<br/>
C'est même le procédé habituel pour découper un intervalle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la branche <code>else</code> est choisie dès que deux conditions<br/>
sont vraies</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>else</code> n'entre en jeu que si toutes les conditions sont<br/>
fausses. La première étant vraie, <code>else</code> est écarté.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce qu'il manque un <code>if</code> devant la seconde condition, qui n'est<br/>
jamais lue</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>elif</code> joue déjà le rôle d'un <code>if</code> rattaché au premier<br/>
test. La ligne est correctement écrite, c'est son rang qui pose<br/>
problème.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce que toute vitesse dépassant 110 dépasse déjà 50, si bien que<br/>
la première branche l'emporte</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 120 est supérieur à 50, donc la première branche est<br/>
retenue et le reste de l'enchaînement est ignoré. Il faudrait<br/>
tester d'abord le seuil le plus élevé.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q13 : Le nombre de tours d'une boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme de test envoie plusieurs requêtes à un serveur.</p>
<pre><code>for i in range(5):
    print("requête envoyée")</code></pre>
<p>Combien de fois le message est-il affiché ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>range(n)</code> parcourt les entiers de 0 à <code>n - 1</code>, soit exactement <code>n</code><br/>
valeurs. Le nombre de tours se lit donc directement sur l'argument.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4 fois, la valeur 0 ne comptant pas pour un tour</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(5)</code> commence bel et bien à 0, et ce premier passage<br/>
exécute la ligne comme tous les autres.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>5 fois, une par valeur parcourue</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>range(5)</code> fournit 0, 1, 2, 3 et 4, soit cinq<br/>
valeurs, donc cinq tours de boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>6 fois, les valeurs allant de 0 à 5 comprises</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la borne écrite est exclue. <code>range(5)</code> s'arrête à 4 et ne<br/>
fournit jamais la valeur 5.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1 fois, seul le dernier tour affichant le message</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la ligne indentée est exécutée à chaque tour, et non au<br/>
seul dernier. C'est tout l'intérêt d'une boucle.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q14 : Une plage de valeurs</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un objet connecté effectue un relevé à chaque heure d'une plage<br/>
horaire.<br/>
<pre><code>compte = 0
for heure in range(2, 8):
    compte = compte + 1
print(compte)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>range(a, b)</code> parcourt les entiers de <code>a</code> à <code>b - 1</code>, soit <code>b - a</code><br/>
valeurs. Ici, 8 moins 2 donne bien 6 tours.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>6</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle parcourt 2, 3, 4, 5, 6 et 7, soit 6<br/>
valeurs. La borne 8 est exclue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : retire une valeur de trop. La borne de départ, elle, est<br/>
bien parcourue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>7</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : compte la borne 8, qui est pourtant exclue. La boucle<br/>
s'arrête à 7.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>8</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : prend la borne de fin pour le nombre de tours. Le départ<br/>
à 2 retire 2 valeurs au compte.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q15 : Une file de signalements traitée par lots</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une équipe de modération traite 100 signalements par lots de 30.<br/>
<pre><code>restants = 100
tours = 0
while restants &gt; 0:
    restants = restants - 30
    tours = tours + 1
print(tours, restants)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une boucle <code>while</code> examine sa condition avant chaque tour, jamais au<br/>
milieu. Le dernier lot est donc entamé en entier, même s'il dépasse ce<br/>
qui restait à traiter.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3 10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 3 tours il reste 10 signalements, ce qui est<br/>
strictement supérieur à 0. La condition est encore vraie et un<br/>
tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la soustraction retire 30 à chaque tour, sans s'ajuster au<br/>
reste. Le dernier tour fait passer le total sous zéro.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4 -20</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les valeurs passent par 70, 40, 10 puis -20, soit<br/>
4 tours. La condition n'est examinée qu'en début de tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5 -50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ajoute un tour de trop. Dès que <code>restants</code> vaut -20, la<br/>
condition est fausse et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q16 : Une boucle qui ne s'arrête pas</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme doit décompter les blocs d'un fichier restant à recevoir.</p>
<pre><code>restants = 10
while restants &gt; 0:
    print(restants)</code></pre>
<p>Que fait-il réellement ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Toute boucle <code>while</code> réclame une instruction qui rapproche la condition<br/>
de sa fin. Sans elle, le programme tourne sans terme et il faut<br/>
l'interrompre à la main.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 10 une seule fois, puis passe à la suite</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>while</code> n'exécute pas son bloc une fois pour toutes. Il le<br/>
répète tant que la condition reste vraie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il n'affiche rien, la condition étant fausse au départ</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 10 est bien supérieur à 0. La condition est donc vraie dès<br/>
le premier examen et la boucle démarre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche les nombres de 10 jusqu'à 1, puis s'arrête</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le comportement attendu, mais aucune ligne ne<br/>
diminue <code>restants</code>. Il faudrait ajouter <code>restants = restants - 1</code><br/>
dans le bloc.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Il affiche 10 sans jamais s'arrêter</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : rien ne modifie <code>restants</code>, qui vaut 10 à chaque<br/>
examen de la condition. Le même nombre défile indéfiniment.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q17 : Une mémoire qui se remplit</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Le nombre de relevés stockés par un capteur est multiplié par trois<br/>
chaque jour.<br/>
<pre><code>releves = 5
jours = 0
while releves &lt; 100:
    releves = releves * 3
    jours = jours + 1
print(jours, releves)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une multiplication répétée fait grimper une valeur très vite : 3<br/>
tours suffisent à passer de 5 à 135. La boucle s'arrête au premier<br/>
examen où la condition devient fausse.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>3 135</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les valeurs passent par 15, 45 puis 135, soit 3<br/>
tours. Le dernier a lieu parce que 45 est encore inférieur à 100.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2 45</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : s'arrête à 45, qui est pourtant inférieur à 100. La<br/>
condition reste vraie, donc un tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3 45</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : compte 3 tours mais garde la valeur du tour précédent. Le<br/>
dernier tour multiplie encore par 3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4 135</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ajoute un tour de trop. Une fois <code>releves</code> à 135, la<br/>
condition est fausse et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q18 : Une boucle de cinq en cinq</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme de cartographie place un repère tous les cinq<br/>
kilomètres le long d'un parcours.<br/>
<pre><code>compteur = 0
for borne in range(5, 31, 5):
    compteur = compteur + 1
print(compteur)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Dans <code>range(debut, fin, pas)</code>, la boucle part de <code>debut</code>, avance<br/>
de <code>pas</code> à chaque tour et s'arrête avant <code>fin</code>. Ici elle prend les<br/>
6 valeurs 5, 10, 15, 20, 25 et 30.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle parcourt 5, 10, 15, 20, 25 et 30,<br/>
soit 6 valeurs, car le pas de 5 part de 5 et s'arrête avant<br/>
31. Le compteur est donc incrémenté 6 fois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu as oublié la première valeur, 5, ou la dernière,<br/>
30. Les valeurs parcourues sont 5, 10, 15, 20, 25 et 30.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>26</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu as compté les entiers de 5 à 30 en ignorant le<br/>
pas. Le troisième nombre de <code>range</code> fixe justement l'écart<br/>
entre deux valeurs successives.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>31</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu as pris la borne de fin pour le nombre de tours.<br/>
Cette borne est exclue, et le pas de 5 ne retient que 6<br/>
valeurs.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q19 : La branche d'un relevé doux</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une station météo qualifie la température relevée.<br/>
<pre><code>temp = 19
if temp &lt; 5:
    resultat = "gel"
elif temp &lt; 18:
    resultat = "frais"
elif temp &lt; 25:
    resultat = "doux"
else:
    resultat = "chaud"
print(resultat)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Les conditions d'une suite <code>if</code>, <code>elif</code>, <code>else</code> sont examinées<br/>
dans l'ordre, et la première qui est vraie emporte tout : son bloc<br/>
s'exécute, les suivants sont abandonnés.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>frais</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition <code>temp &lt; 18</code> est fausse pour 19, donc<br/>
cette branche est ignorée et l'examen se poursuit avec la<br/>
suivante.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>doux</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 19 n'est ni inférieur à 5 ni inférieur à 18,<br/>
mais il est inférieur à 25. C'est donc la troisième branche<br/>
qui s'exécute.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>chaud</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la branche <code>else</code> ne s'exécute que si toutes les<br/>
conditions précédentes sont fausses. Or <code>temp &lt; 25</code> est vraie<br/>
pour 19.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>frais</code> puis <code>doux</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dans une suite <code>if</code>, <code>elif</code>, <code>else</code>, une seule<br/>
branche s'exécute. Dès qu'une condition est vraie, les autres<br/>
ne sont plus examinées.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q20 : Un partage répété par deux</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme réduit de moitié la taille d'une image tant qu'elle<br/>
dépasse dix unités.<br/>
<pre><code>reste = 100
tours = 0
while reste &gt; 10:
    reste = reste // 2
    tours = tours + 1
print(tours)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une boucle non bornée répète son bloc tant que sa condition est<br/>
vraie, sans qu'on sache d'avance combien de tours auront lieu.<br/>
Ici, la division entière par deux mène de 100 à 6 en 4 tours.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>reste</code> prend successivement 50, 25, 12 puis 6. À ce moment la condition devient fausse, après 4<br/>
tours.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu t'es arrêté à 12, qui dépasse encore 10. Un tour<br/>
supplémentaire a lieu et ramène <code>reste</code> à 6.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu as compté un tour de trop. Une fois <code>reste</code> à 6,<br/>
la condition est fausse et la boucle s'arrête sans exécuter<br/>
son bloc.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tu as pris le seuil de la condition pour le nombre<br/>
de tours. Comme la valeur est divisée par deux à chaque fois,<br/>
elle descend bien plus vite.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q21 : Un argument manquant</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme calcule le coût d'un trajet.<br/>
<pre><code>def cout(distance, prix_km):
    return distance * prix_km

print(cout(12))</code></pre><br/>
Que se passe-t-il à l'exécution ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un appel doit fournir autant d'arguments que la définition compte<br/>
de paramètres, dans le même ordre. Ici, <code>cout(12, 3)</code> renverrait<br/>
36, tandis que <code>cout(12)</code> est refusé.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Python signale une erreur, car il manque un argument<br/>
à l'appel</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la fonction attend deux arguments et n'en<br/>
reçoit qu'un. Python refuse l'appel en signalant l'argument<br/>
absent, ici <code>prix_km</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le programme affiche <code>12</code>, la valeur du seul<br/>
argument fourni</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fonction ne peut pas calculer son produit sans<br/>
connaître le prix. Aucun calcul n'a lieu, l'appel est refusé<br/>
avant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le programme affiche <code>0</code>, le paramètre absent<br/>
valant zéro</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un paramètre sans argument ne prend aucune valeur. Il faut<br/>
fournir l'argument au moment de l'appel, sinon Python refuse<br/>
d'exécuter la fonction.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le programme demande la valeur manquante à<br/>
l'utilisateur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une fonction ne dialogue jamais d'elle-même avec<br/>
l'utilisateur. Elle reçoit ses arguments au moment de l'appel,<br/>
et seulement là.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q22 : Le cumul de relevés croissants</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans ce modèle, un capteur relève une température toutes les heures,<br/>
et elle monte de 2 degrés entre deux relevés.<br/>
<pre><code>temperature = 18
total = 0
for heure in range(4):
    total = total + temperature
    temperature = temperature + 2
print(total, temperature)</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le schéma de l'accumulateur revient sans cesse : une variable mise à<br/>
0 avant la boucle, augmentée à chaque tour. L'ordre des instructions<br/>
compte : ajouter puis augmenter ne donne pas le même total<br/>
qu'augmenter puis ajouter.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>84 24</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 24 est la dernière température ajoutée au total. Mais la<br/>
ligne suivante l'augmente encore de 2 avant la fin du dernier<br/>
tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>92 26</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce total correspond à 20, 22, 24 et 26. Or l'ajout au<br/>
total a lieu avant l'augmentation, donc la première température<br/>
comptée vaut 18.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>84 26</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle ajoute 18, 20, 22 puis 24, ce qui fait<br/>
84. Après le dernier ajout, <code>temperature</code> augmente encore une fois<br/>
et vaut 26.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>60 24</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(4)</code> fait bien 4 tours, pour <code>heure</code> valant de 0<br/>
à 3. Ce résultat correspondrait à 3 tours seulement.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q23 : Un maximum jamais trouvé</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme modélise une nuit d'hiver où la température baisse de<br/>
2 degrés entre deux relevés, puis cherche la plus haute.</p>
<pre><code>maxi = 0
for releve in range(4):
    t = -1 - 2 * releve
    if t &gt; maxi:
        maxi = t
print(maxi)</code></pre>
<p>Qu'affiche-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Initialiser un maximum à 0 revient à supposer qu'au moins une valeur<br/>
est positive. Mieux vaut partir de la première valeur réellement<br/>
calculée, puis la comparer aux suivantes.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la réponse attendue, mais le programme ne la trouve<br/>
pas. Les températures valent -1, -3, -5 et -7, et aucune ne dépasse<br/>
la valeur de départ de <code>maxi</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les quatre températures sont négatives, donc aucune<br/>
n'est supérieure à 0. La variable <code>maxi</code> garde la valeur de son<br/>
initialisation.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la dernière température calculée, et la plus basse.<br/>
La variable <code>maxi</code> ne change que si le test <code>t &gt; maxi</code> est vrai, ce<br/>
qui n'arrive jamais.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car <code>maxi</code> n'est jamais modifiée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une variable qui garde sa valeur ne provoque aucune<br/>
erreur. Le programme s'exécute normalement et affiche la valeur<br/>
initiale de <code>maxi</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q24 : Compter les mesures fortes</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme doit afficher le nombre de mesures strictement supérieures<br/>
à 25. L'utilisateur saisit successivement 12, 31, 8, 45 et 27.</p>
<pre><code>compte = 0
for i in range(5):
    m = int(input())
    ...
print(compte)</code></pre>
<p>Par quoi remplacer les points de suspension ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un compteur avance toujours de 1, quelle que soit la valeur examinée.<br/>
C'est ce qui le distingue d'un accumulateur, qui ajoute la valeur<br/>
elle-même.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if m &gt; 25:
    compte = m</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : range la mesure elle-même dans le compteur au lieu de<br/>
l'augmenter. Le programme afficherait 27, la dernière mesure<br/>
retenue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if compte &gt; 25:
    compte = compte + 1</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : teste le compteur au lieu de la mesure. Comme il part de 0<br/>
et n'atteint jamais 25, le programme afficherait 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if m &gt; 25:
    compte = compte + m</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ajoute la valeur de la mesure au lieu d'ajouter 1. Le<br/>
programme afficherait 103, la somme des mesures retenues.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>if m &gt; 25:
    compte = compte + 1</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque mesure supérieure à 25, le compteur avance<br/>
de 1. Le programme affiche 3, pour 31, 45 et 27.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q25 : Le volume d'un groupe de discussion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans un groupe de discussion, chaque membre envoie le même nombre de<br/>
messages, et chaque message pèse 2 kilo-octets.<br/>
<pre><code>def volume(membres, messages):
    return membres * messages * 2
print(volume(20, 15))</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un appel de fonction remplace les paramètres par les arguments donnés,<br/>
exécute le corps, puis rend la valeur écrite après <code>return</code>. C'est<br/>
cette valeur que <code>print</code> affiche.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>600</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 20 membres envoient chacun 15 messages, soit 300<br/>
messages, et chacun pèse 2 kilo-octets.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>300</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : oublie les 2 kilo-octets par message. C'est le nombre de<br/>
messages, et non le volume échangé.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>70</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : additionne les deux paramètres au lieu de les multiplier,<br/>
avant de multiplier par 2.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>40</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ne tient compte que du nombre de membres. Les deux<br/>
paramètres interviennent dans le calcul.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q26 : L'ordre des arguments</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Cette fonction calcule l'écart entre deux bornes kilométriques.<br/>
<pre><code>def ecart(depart, arrivee):
    return arrivee - depart
print(ecart(12, 5), ecart(5, 12))</code></pre><br/>
Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Les arguments d'un appel prennent la place des paramètres dans l'ordre<br/>
où ils sont écrits. Deux appels aux mêmes valeurs rangées autrement ne<br/>
donnent donc pas le même résultat.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7 -7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : intervertit les deux résultats. Au premier appel, <code>depart</code><br/>
vaut 12 et <code>arrivee</code> vaut 5, donc la soustraction donne un nombre<br/>
négatif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7 7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose que la fonction rend toujours un écart positif.<br/>
Elle applique la soustraction telle qu'elle est écrite, sans<br/>
corriger le signe.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>-7 7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les arguments prennent la place des paramètres dans<br/>
l'ordre, d'où 5 moins 12 au premier appel et 12 moins 5 au second.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-7 -7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : donne le même signe aux deux appels. Échanger les<br/>
arguments change bien le signe du résultat.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q27 : Afficher ou renvoyer</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme emploie une fonction qui double une valeur.</p>
<pre><code>def doubler(valeur):
    print(valeur * 2)

resultat = doubler(5)
print(resultat)</code></pre>
<p>Qu'affiche-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Afficher et renvoyer sont deux actions distinctes. <code>print</code> montre une<br/>
valeur à l'écran, <code>return</code> la rend au programme qui a fait l'appel. Une<br/>
fonction sans <code>return</code> rend <code>None</code>.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code> puis <code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : suppose que la fonction rend ce qu'elle affiche. Sans<br/>
<code>return</code>, l'appel ne rapporte aucune valeur utilisable.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>10</code> puis <code>None</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la fonction affiche 10, puis <code>resultat</code> reçoit<br/>
<code>None</code>, faute de <code>return</code>. La dernière ligne montre cette absence<br/>
de valeur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code> seulement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : oublie la dernière ligne, qui affiche <code>resultat</code>. Elle<br/>
s'exécute et montre ce que l'appel a rapporté.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>None</code> puis <code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : inverse l'ordre. L'affichage écrit dans le corps de la<br/>
fonction a lieu pendant l'appel, donc avant la dernière ligne.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q28 : Un résultat qui se perd</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme veut doubler la largeur d'une image.<br/>
<pre><code>def agrandir(valeur):
    valeur = valeur * 2
    return valeur
largeur = 640
agrandir(largeur)
print(largeur)</code></pre><br/>
Qu'affiche-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une fonction travaille sur ses propres variables. Pour conserver ce<br/>
qu'elle calcule, il faut ranger la valeur rendue dans une variable au<br/>
moment de l'appel.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1280</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la valeur calculée par la fonction, mais personne ne<br/>
la recueille. Il faudrait écrire <code>largeur = agrandir(largeur)</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>None</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fonction contient bien un <code>return</code>, et de toute façon la<br/>
dernière ligne affiche <code>largeur</code>, pas le résultat de l'appel.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la variable n'est jamais remise à zéro. Elle garde la<br/>
valeur reçue au moment de sa création.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>640</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : le paramètre <code>valeur</code> est une variable propre à la<br/>
fonction. La modifier ne change rien à <code>largeur</code>, et le résultat<br/>
rendu n'est rangé nulle part.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q29 : Une fonction qui renvoie un booléen</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une moyenne n'a de sens qu'à partir de trois relevés. Les variables<br/>
<code>matin</code> et <code>journee</code> contiennent des nombres de relevés.</p>
<pre><code>def assez(nombre):
    return nombre &gt;= 3

matin = 2
journee = 4
print(assez(matin), assez(journee), assez(matin) or assez(journee))</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une fonction peut rendre un booléen, qui s'emploie alors comme une<br/>
condition ou se combine avec <code>and</code>, <code>or</code> et <code>not</code>. La comparaison<br/>
écrite après <code>return</code> est évaluée avant d'être rendue.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>False True True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>matin</code> vaut 2 et <code>journee</code> vaut 4. Le <code>or</code> est vrai<br/>
dès qu'un seul des deux appels l'est.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>False True False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>or</code> est vrai dès qu'une des deux valeurs l'est, et<br/>
l'appel sur <code>journee</code> rend justement <code>True</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>True False True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : intervertit les deux valeurs. C'est <code>journee</code>, avec ses<br/>
quatre relevés, qui atteint le seuil de trois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>False False True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>journee</code> vaut 4, ce qui est bien supérieur ou égal à 3.<br/>
Le deuxième appel rend <code>True</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q30 : Un appel incomplet</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Ce programme s'arrête sur une erreur au moment de l'appel.</p>
<pre><code>def surface(largeur, hauteur):
    return largeur * hauteur

print(surface(12))</code></pre>
<p>Que reproche Python à ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un appel doit fournir une valeur pour chaque paramètre, dans l'ordre.<br/>
Le message d'erreur nomme même le paramètre qui manque, ici <code>hauteur</code>.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La fonction est appelée avant d'avoir été définie dans le fichier</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la définition est bien écrite avant l'appel. Ce reproche<br/>
vaudrait pour un appel placé plus haut dans le fichier, et Python<br/>
signalerait alors une <code>NameError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La valeur 12 n'est pas d'un type admis pour une multiplication</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 12 est un entier, parfaitement multipliable. Le calcul n'a<br/>
même pas lieu, l'appel échouant avant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>La fonction attend deux paramètres, or un seul argument est fourni</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python signale <code>TypeError: surface() missing 1<br/>
required positional argument: 'hauteur'</code>. Il faut fournir autant<br/>
d'arguments que de paramètres.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La fonction ne renvoie rien, donc <code>print</code> n'a rien à afficher</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fonction contient un <code>return</code> et rendrait bien une<br/>
valeur si l'appel aboutissait. L'erreur survient avant.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q31 : Le niveau de la batterie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>batterie = 80
batterie = batterie - 15
print(batterie)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>batterie = batterie - 15</code> se lit de droite à gauche : on calcule<br/>
avec la valeur actuelle, puis on range le résultat dans la variable.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>65</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la seconde ligne calcule <code>80 - 15</code> puis range<br/>
le résultat dans <code>batterie</code>, qui vaut désormais 65.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>80</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la seconde ligne modifie bien <code>batterie</code>. L'ancienne<br/>
valeur est remplacée par le résultat du calcul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>15</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 15 est la quantité retirée, pas le niveau restant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car une variable ne peut pas être réaffectée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : réaffecter une variable est l'opération la plus<br/>
courante en programmation. Sa valeur change, son nom reste.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q32 : Une durée en minutes et secondes</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un chronomètre a mesuré 125 secondes. Qu'affiche ce programme ?<br/>
<pre><code>secondes = 125
minutes = secondes // 60
reste = secondes % 60
print(minutes, reste)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>//</code> et <code>%</code> vont de pair : le premier compte les parts entières, le<br/>
second ce qui reste. Ensemble ils convertissent des secondes en<br/>
minutes et secondes.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>2 5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>//</code> donne le quotient entier de la division par<br/>
60, soit 2 minutes, et <code>%</code> le reste, soit 5 secondes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2 65</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le reste n'est pas <code>secondes - 60</code>. Il faut retirer<br/>
2 fois 60, ce que <code>%</code> fait directement : 5.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2 125</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>%</code> ne renvoie pas le nombre de départ mais ce qui<br/>
reste une fois les minutes entières retirées.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car <code>%</code> n'existe pas en Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>%</code> est l'opérateur modulo, qui calcule le reste d'une<br/>
division entière.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q33 : Une valeur recopiée puis modifiée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>capteur = 10
memoire = capteur
capteur = 20
print(memoire)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une affectation recopie une valeur à un instant donné. Les deux<br/>
variables vivent ensuite leur vie séparément.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>memoire = capteur</code> recopie la valeur 10 au<br/>
moment de l'affectation. Changer <code>capteur</code> ensuite ne touche pas<br/>
<code>memoire</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>20</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les deux variables ne restent pas liées. <code>memoire</code> a<br/>
reçu une copie de la valeur, pas un lien vers <code>capteur</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>30</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune addition n'a lieu dans ce programme.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car <code>memoire</code> n'a jamais reçu de nombre</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>memoire = capteur</code> lui donne bien un nombre, celui que<br/>
<code>capteur</code> contenait alors.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q34 : Le tarif selon l'âge</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>age = 16
if age &lt; 18:
    prix = 5
else:
    prix = 8
print(prix)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>if</code> et <code>else</code> partagent les cas : la condition vraie conduit à la<br/>
première branche, fausse à la seconde. Attention à la frontière,<br/>
ici 18 n'est pas strictement inférieur à 18.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : avec <code>age</code> égal à 16, la condition <code>age &lt; 18</code><br/>
décide de la branche exécutée, et <code>prix</code> reçoit 5.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la valeur de l'autre branche. Relis la condition<br/>
<code>age &lt; 18</code> avec <code>age</code> égal à 16.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code> puis <code>8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une seule des deux branches est exécutée, jamais les<br/>
deux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Rien, <code>prix</code> n'étant affiché dans aucune branche</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le <code>print</code> est placé après le bloc <code>if</code>, il s'exécute<br/>
dans tous les cas.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q35 : Une mention selon la note</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>note = 14
if note &gt;= 16:
    mention = "TB"
elif note &gt;= 12:
    mention = "B"
elif note &gt;= 8:
    mention = "AB"
else:
    mention = "I"
print(mention)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une chaîne <code>if</code>, <code>elif</code>, <code>else</code> s'arrête à la première condition<br/>
vraie. L'ordre des conditions est donc essentiel.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>B</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les conditions sont testées dans l'ordre, et la<br/>
première vraie l'emporte. Avec 14, c'est celle qui donne<br/>
<code>B</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>TB</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : vérifie quelle condition est la première vraie en<br/>
partant du haut, avec <code>note</code> égale à 14.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>AB</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dès qu'une condition est vraie, les suivantes ne sont<br/>
plus examinées, et une condition précédente n'est pas rattrapée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Les quatre mentions, les conditions étant toutes testées</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une seule branche d'une chaîne <code>if</code>, <code>elif</code>, <code>else</code><br/>
s'exécute.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q36 : Une alerte de température</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une serre déclenche une alerte quand la température est inférieure<br/>
à $5$ ou supérieure à $35$, avec la condition<br/>
<code>temperature &lt; 5 or temperature &gt; 35</code>. Parmi les relevés $3$,<br/>
$20$ et $40$, lesquels déclenchent l'alerte ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>or</code> déclenche dès qu'une des conditions est vraie ; <code>and</code><br/>
exigerait les deux, ce qui serait ici impossible.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>$3$ et $40$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : $3$ vérifie la première comparaison, $40$ la<br/>
seconde, et <code>or</code> se contente d'une comparaison vraie. $20$ ne<br/>
vérifie ni l'une ni l'autre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>$20$ seulement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : $20$ est la seule valeur qui ne déclenche rien, étant<br/>
ni trop froide ni trop chaude.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Aucun, une valeur ne pouvant être à la fois inférieure à $5$ et supérieure à $35$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>or</code> n'exige pas les deux comparaisons à la fois, une<br/>
seule suffit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Les trois, la condition étant toujours vraie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour $20$, les deux comparaisons sont fausses, donc la<br/>
condition est fausse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q37 : La négation d'une comparaison</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un programme contient <code>if not (vitesse &gt; 50):</code>. Quelle condition,<br/>
écrite sans <code>not</code>, est exactement équivalente ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La négation de <code>&gt;</code> est <code>&lt;=</code>, celle de <code>&lt;</code> est <code>&gt;=</code>. La valeur<br/>
frontière change de camp, c'est là que se cachent les erreurs.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>vitesse &lt;= 50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : ne pas être strictement supérieur à $50$, c'est<br/>
être inférieur ou égal à $50$. La valeur $50$ elle-même rend la<br/>
condition vraie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>vitesse &lt; 50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour <code>vitesse</code> égale à $50$, <code>vitesse &gt; 50</code> est faux,<br/>
donc <code>not (vitesse &gt; 50)</code> est vrai, alors que <code>vitesse &lt; 50</code><br/>
est faux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>vitesse &gt;= 50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette condition est presque l'opposé de celle<br/>
attendue. La négation renverse le sens de la comparaison.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>vitesse == 50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition attendue est vraie pour toutes les<br/>
vitesses jusqu'à $50$, pas seulement pour $50$.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q38 : Un bonus accordé sous condition</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>score = 50
if score &gt; 40:
    score = score + 10
print(score)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un <code>if</code> sans <code>else</code> est fréquent : on agit seulement si la condition<br/>
est vraie, et dans tous les cas la suite du programme s'exécute.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>60</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 50 est supérieur à 40, le bloc s'exécute<br/>
et ajoute 10. Le <code>print</code>, placé après le <code>if</code>, affiche la<br/>
nouvelle valeur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition est vraie, le bloc modifie donc <code>score</code><br/>
avant l'affichage.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>score + 10</code> ajoute 10 à la valeur existante, il ne la<br/>
remplace pas par 10.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car il manque un <code>else</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>else</code> est facultatif. Sans lui, rien ne se passe quand<br/>
la condition est fausse, et le programme continue.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q39 : Deux conditions imbriquées en une seule</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Le programme d'un portail affiche l'état d'ouverture :<br/>
<pre><code>if heure &gt;= 8:
    if heure &lt; 18:
        etat = "ouvert"
    else:
        etat = "fermé"
else:
    etat = "fermé"</code></pre><br/>
Quelle condition unique donne <code>"ouvert"</code> exactement dans les mêmes<br/>
cas ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Imbriquer deux <code>if</code> revient à exiger les deux conditions. Les<br/>
écrire avec <code>and</code> rend le programme plus court et plus lisible.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>heure &gt;= 8 and heure &lt; 18</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la branche <code>"ouvert"</code> n'est atteinte que si la<br/>
première condition est vraie et la seconde aussi. Deux <code>if</code><br/>
emboîtés équivalent à un <code>and</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>heure &gt;= 8 or heure &lt; 18</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : avec <code>or</code>, toute heure conviendrait, puisque chaque<br/>
heure vérifie au moins l'une des deux comparaisons.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>heure &lt; 8 and heure &gt;= 18</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune heure n'est à la fois avant 8 et après 18. Cette<br/>
condition est toujours fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>heure &gt;= 8 or heure &gt;= 18</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette condition revient à <code>heure &gt;= 8</code> et donnerait<br/>
<code>"ouvert"</code> aussi le soir, après 18 heures.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q40 : Le total d'une semaine de pas</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>total = 0
for pas in [4000, 6500, 5200]:
    total = total + pas
print(total)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un accumulateur part de zéro et grossit à chaque tour. C'est le<br/>
schéma de toute somme calculée par une boucle.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>15700</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque tour, la valeur courante est ajoutée à<br/>
<code>total</code>, qui finit par contenir la somme des trois relevés.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5200</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>total</code> ne garde pas la dernière valeur, il accumule<br/>
toutes les valeurs lues.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 3 est le nombre de tours de boucle, pas la somme des<br/>
valeurs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>total</code> vaut 0 avant la boucle, mais chaque tour<br/>
l'augmente.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q41 : Une surface qui double</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une bactérie double de population à chaque heure. Qu'affiche ce<br/>
programme ?<br/>
<pre><code>population = 1
while population * 2 &lt;= 100:
    population = population * 2
print(population)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La condition d'un <code>while</code> est vérifiée avant chaque tour. Ici, elle<br/>
regarde ce que donnerait le prochain doublement avant de l'autoriser.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>64</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la population double tant que le double ne<br/>
dépasse pas 100. Elle s'arrête à 64, car 128 dépasserait 100.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>128</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 128 dépasse 100, la condition <code>population * 2 &lt;= 100</code><br/>
est fausse avant ce doublement, et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la population ne prend que des puissances de 2, elle<br/>
n'atteint pas 100 exactement.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Rien, la boucle ne s'arrêtant jamais</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la population grandit à chaque tour, donc la condition<br/>
finit par devenir fausse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q42 : Un drapeau levé dans une boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Des relevés de vent sont stockés dans une liste. Qu'affiche ce<br/>
programme ?<br/>
<pre><code>releves = [3, 8, 12, 5]
tempete = False
for v in releves:
    if v &gt; 10:
        tempete = True
print(tempete)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un drapeau est une variable booléenne que la boucle lève dès qu'une<br/>
condition est rencontrée. Après la boucle, il dit si cela s'est<br/>
produit au moins une fois.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>tempete</code> part de <code>False</code> et passe à <code>True</code> dès<br/>
qu'un relevé dépasse 10. La liste contient une telle valeur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : parcours la liste [3, 8, 12, 5] et regarde si un relevé dépasse<br/>
strictement 10. Le plus grand est 12.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>12</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le programme affiche <code>tempete</code>, un booléen, pas un<br/>
relevé.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>True</code> puis <code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il n'y a qu'un seul <code>print</code>, après la boucle, donc une<br/>
seule valeur affichée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q43 : Une conversion en kilomètres</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>def en_km(metres):
    return metres / 1000

print(en_km(2500))</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>return</code> renvoie un résultat à l'endroit de l'appel ; <code>print</code><br/>
l'affiche. Les deux rôles sont distincts et se combinent.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>2.5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : l'appel <code>en_km(2500)</code> remplace <code>metres</code> par 2500,<br/>
et la division par 1000 donne 2.5, un flottant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2500000</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fonction divise par 1000, elle ne multiplie pas.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2500</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la valeur renvoyée est le résultat du calcul, pas<br/>
l'argument reçu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Rien, la fonction ne contenant pas de <code>print</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le <code>print</code> est à l'extérieur, autour de l'appel. Il<br/>
affiche la valeur renvoyée par <code>return</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q44 : Une variable née dans la fonction</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>def calcul(x):
    resultat = x * 3
    return resultat

calcul(4)
print(resultat)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour utiliser le résultat d'une fonction, on récupère ce que<br/>
<code>return</code> renvoie, par exemple <code>r = calcul(4)</code>. Les variables<br/>
internes, elles, restent invisibles.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Une erreur, <code>resultat</code> étant inconnu à l'extérieur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>resultat</code> est une variable locale, créée à<br/>
chaque appel et détruite à la fin. Hors de la fonction, ce nom<br/>
est inconnu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche <code>12</code>, le résultat du calcul</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 12 est bien calculé, mais la valeur renvoyée par<br/>
<code>calcul(4)</code> n'est rangée nulle part, et <code>resultat</code> reste<br/>
interne à la fonction.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche <code>4</code>, l'argument de l'appel</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 4 est l'argument de l'appel, pas une variable nommée<br/>
<code>resultat</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche <code>0</code>, valeur par défaut d'une variable non définie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune variable <code>resultat</code> n'existe à l'extérieur, pas<br/>
même avec la valeur 0.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>9. Révision de fin d'année — Q45 : Une fonction appelée dans une boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>def double(x):
    return 2 * x

total = 0
for v in [1, 2, 3]:
    total = total + double(v)
print(total)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une fonction s'appelle autant de fois que nécessaire, y compris à<br/>
chaque tour d'une boucle. Chaque appel renvoie son résultat, aussitôt<br/>
utilisé.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>12</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : chaque valeur est doublée par la fonction avant<br/>
d'être ajoutée. La somme des valeurs vaut 6, celle des doubles<br/>
12.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 6 est la somme des valeurs sans le doublement. La<br/>
fonction est appelée à chaque tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>24</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : chaque valeur est doublée une seule fois, pas deux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, une fonction ne pouvant être appelée dans une boucle</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : appeler une fonction dans une boucle est tout à fait<br/>
permis, et très courant.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
