<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<question type="category">
  <category>
    <text>$course$/QCM de NSI/Première/Variables et types de base</text>
  </category>
  <info format="html">
    <text><![CDATA[<p>Variables Python, affectation, types primitifs (entier,<br/>
flottant, chaîne, booléen), conversions de types,<br/>
opérateurs arithmétiques et logiques, opérations de base<br/>
sur les chaînes.</p>]]></text>
  </info>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q01 : Affectation</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la signification de l'instruction<br/>
<code>x = 5</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'opérateur <code>=</code> est l'<strong>affectation</strong> (asymétrique :<br/>
gauche reçoit droite). À ne pas confondre avec<br/>
<code>==</code> qui est le <strong>test d'égalité</strong> (symétrique,<br/>
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="100" format="html">
    <text><![CDATA[<p>Affecter la valeur 5 à la variable <code>x</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on fait pointer le nom <code>x</code><br/>
vers la valeur <code>5</code>. Si <code>x</code> n'existait pas,<br/>
la variable est créée ; sinon, elle est mise<br/>
à jour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Tester si <code>x</code> est égal à 5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le test d'égalité s'écrit <code>==</code> (deux<br/>
signes égal). Avec un seul <code>=</code>, c'est une<br/>
<strong>affectation</strong>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Définir une fonction <code>x</code> qui renvoie 5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une fonction se définit avec <code>def</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Multiplier <code>x</code> par 5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la multiplication s'écrit <code>x * 5</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q02 : Type entier</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel est le type de la valeur <code>42</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Python distingue <code>int</code> (entiers, précision<br/>
arbitraire) et <code>float</code> (flottants, précision<br/>
finie). <code>42</code> et <code>42.0</code> sont distincts (mais<br/>
égaux par valeur).</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>int</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>42</code> est un <strong>entier</strong> (type<br/>
<code>int</code>). On peut le vérifier avec<br/>
<code>type(42)</code> qui renvoie <code>&lt;class 'int'&gt;</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>str</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>42</code> n'a pas de guillemets, ce n'est<br/>
pas une chaîne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>bool</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les booléens sont <code>True</code> et <code>False</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>float</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>42.0</code> serait un flottant. Sans<br/>
virgule, c'est un entier.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q03 : Type flottant</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>type(3.14)</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Attention : les flottants ont une <strong>précision limitée</strong>. <code>0.1 + 0.2</code> ne donne pas exactement<br/>
<code>0.3</code> mais <code>0.30000000000000004</code>, car ces nombres<br/>
n'ont pas d'écriture binaire exacte.</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>&lt;class 'int'&gt;</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>3.14</code> a une partie décimale, c'est<br/>
un flottant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>&lt;class 'decimal'&gt;</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>decimal</code> n'est pas un type natif de<br/>
Python ; le type des nombres à virgule est<br/>
<code>float</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>&lt;class 'float'&gt;</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : tout nombre avec un point<br/>
décimal est un flottant en Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>&lt;class 'str'&gt;</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas de guillemets.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q04 : Type chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel est le type de <code>"hello"</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Python n'a pas de type spécifique pour un seul<br/>
caractère : <code>'a'</code> est une chaîne de longueur 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="100" format="html">
    <text><![CDATA[<p><code>str</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les chaînes de caractères<br/>
sont du type <code>str</code> (string). On les écrit<br/>
entre guillemets simples (<code>'</code>) ou doubles<br/>
(<code>"</code>).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>int</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>"hello"</code> est entre guillemets,<br/>
c'est une chaîne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>bool</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un booléen est <code>True</code> ou <code>False</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>char</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas de type <code>char</code> en Python (à la<br/>
différence de C ou Java). Un caractère est<br/>
juste une chaîne de longueur 1.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q05 : Type booléen</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelles sont les <strong>deux seules</strong> valeurs du type<br/>
<code>bool</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Mnémonique : majuscule à <code>True</code> et <code>False</code>,<br/>
pas comme en JavaScript ou C.</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> et <code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : avec une <strong>majuscule obligatoire</strong>. <code>true</code> ou <code>false</code> (en<br/>
minuscules) provoqueraient une erreur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>oui</code> et <code>non</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python est en anglais, pas en<br/>
français.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>yes</code> et <code>no</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ces mots-clés n'existent pas en<br/>
Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>0</code> et <code>1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce sont des entiers. Ils sont<br/>
interprétés comme booléens (0 = faux, 1 =<br/>
vrai) mais leur type reste <code>int</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q06 : Conversion en entier</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>int("42")</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>int(x)</code> accepte : entiers (renvoie x), flottants<br/>
(tronque vers 0), chaînes représentant un entier.<br/>
Avec <code>int("3.14")</code>, ça lève <code>ValueError</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 chaîne <code>"42"</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int(...)</code> renvoie un entier, pas<br/>
une chaîne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>L'entier <code>42</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>int(s)</code> convertit la chaîne<br/>
<code>s</code> en son entier correspondant. Utile pour<br/>
lire une saisie utilisateur (<code>input()</code><br/>
renvoie toujours une chaîne).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>"42"</code> est convertible. Une chaîne<br/>
comme <code>"abc"</code> lèverait <code>ValueError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le flottant <code>42.0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int</code> produit un entier, pas un<br/>
flottant. Utiliser <code>float("42")</code> pour cela.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q07 : Opérateur de division</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>7 / 2</code> en Python 3 ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Distinction Python 3 : <code>/</code> = division flottante<br/>
(toujours <code>float</code>) ; <code>//</code> = division entière<br/>
(entier si les deux opérandes sont entiers).</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</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la division entière (<code>//</code>).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas d'arrondi.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>3.5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : en Python 3, <code>/</code> est la<br/>
division <strong>flottante</strong>. Toujours, même entre<br/>
deux entiers.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q08 : Division entière</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>7 // 2</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avec des <strong>négatifs</strong>, attention : <code>-7 // 2</code><br/>
vaut <code>-4</code> (arrondi vers le bas, pas vers 0).<br/>
Cohérent avec <code>a == (a // b) * b + a % b</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>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 1 est le reste (<code>%</code>), pas le quotient.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas d'arrondi à l'entier supérieur,<br/>
mais troncature vers le bas.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3.5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la division <strong>flottante</strong><br/>
(<code>/</code>).</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> est la division<br/>
<strong>entière</strong> (quotient sans le reste).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q09 : Modulo</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>7 % 2</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Très utile : <code>n % 2</code> permet de tester la parité<br/>
(<code>n % 2 == 0</code> ⇔ pair). De manière plus<br/>
générale, <code>n % k</code> regarde la classe modulo k.</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>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>%</code> calcule le <strong>reste</strong><br/>
de la division entière. 7 = 3 × 2 + 1, donc<br/>
7 % 2 = 1.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3.5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est <code>/</code>, pas <code>%</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 7 n'est pas un multiple de 2, son reste<br/>
n'est pas nul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 3 est le quotient (<code>//</code>), pas le<br/>
reste.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q10 : Print</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que fait l'instruction <code>print("bonjour")</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>print</code> est aussi utile pour la mise au point d'un<br/>
programme : afficher la valeur d'une variable aide<br/>
à repérer une 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="0" format="html">
    <text><![CDATA[<p>Définit une variable nommée <code>bonjour</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>print</code> affiche, ne définit pas.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Ne fait rien</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>print</code> produit un effet visible.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Affiche <code>bonjour</code> dans la console</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : c'est l'affichage standard.<br/>
Pour ajouter à la fin, utiliser<br/>
<code>print(x, end="")</code> ; pour séparer plusieurs<br/>
arguments, <code>print(a, b, sep=", ")</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Imprime sur l'imprimante de l'ordinateur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Confusion : <code>print</code> affiche dans la<br/>
<strong>console</strong> (sortie standard), pas sur une<br/>
imprimante physique.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q11 : Typage dynamique</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p><pre><code>x = 5
x = "hello"</code></pre><br/>
Cette suite d'instructions est-elle valide ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avec le typage dynamique, on gagne en souplesse<br/>
mais on perd en sûreté : une erreur de type<br/>
n'apparaît qu'au moment de l'exécution.</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>Non, il faut d'abord redéclarer la variable <code>x</code> avec son nouveau type</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune « redéclaration » n'existe<br/>
en Python, une simple affectation suffit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Oui, mais Python affiche un avertissement de changement de type</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun avertissement n'est émis par<br/>
défaut.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Non, <code>x</code> est figé en entier dès sa première affectation</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait le cas dans un langage à<br/>
<strong>typage statique</strong> (Java, C++, Rust),<br/>
mais pas en Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Oui : le typage de Python est dynamique</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : une variable peut désigner<br/>
successivement des objets de types<br/>
différents, Python autorise cette<br/>
réaffectation. C'est puissant mais source<br/>
de bugs subtils.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q12 : Conversion qui plante</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que se passe-t-il avec <code>int("abc")</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Bonne pratique : vérifier qu'une saisie ne<br/>
contient que des chiffres avant de la convertir.<br/>
<pre><code>s = input()
ok = len(s) &gt; 0
for c in s:
    if c not in "0123456789":
        ok = False
if ok:
    n = int(s)
else:
    print("Pas un entier")</code></pre><br/>
La gestion des exceptions, qui permet de<br/>
rattraper l'erreur après coup, est au programme<br/>
de terminale.</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>Renvoie <code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python ne renvoie pas une valeur<br/>
par défaut, il lève une exception.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Renvoie <code>None</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas de retour silencieux à <code>None</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Renvoie <code>"abc"</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int(...)</code> est censé renvoyer un<br/>
entier, pas une chaîne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Lève <code>ValueError</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python lève <code>ValueError:<br/>
invalid literal for int() with base 10:<br/>
'abc'</code>. Avant de convertir une saisie, on<br/>
vérifie donc qu'elle ne contient que des<br/>
chiffres.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q13 : Concaténation</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>"abc" + "def"</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>+</code> a un sens différent selon le type : addition<br/>
pour les nombres, concaténation pour les chaînes<br/>
et les listes. Mais pas de mélange : <code>"a" + 5</code><br/>
lève <code>TypeError</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>abc def</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun espace n'est ajouté<br/>
automatiquement par <code>+</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>9</code> (somme alphabétique)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune somme alphabétique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>abcdef</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>+</code> concatène deux chaînes.<br/>
Le résultat est <code>"abcdef"</code> (sans espace,<br/>
sauf indication explicite).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q14 : Répétition de chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>"ab" * 3</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Comme pour <code>+</code>, <code><em></code> est surchargé. Sur des<br/>
listes : <code>[0] </em> 5 == [0, 0, 0, 0, 0]</code>. Très<br/>
utile pour initialiser un tableau.</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>ababab</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code><em></code> répète une chaîne. C'est<br/>
un raccourci très pratique :<br/>
<code>"-" </em> 80</code> produit une ligne de tirets.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>6</code> (longueur)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>*</code> ne calcule pas la longueur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>ab3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>*</code> ne convertit pas l'entier en<br/>
chaîne pour concaténer.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q15 : Saisie utilisateur</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>input("Âge ?")</code> après que<br/>
l'utilisateur a tapé <code>17</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Piège classique : <code>n = input(); n + 1</code> lève<br/>
<code>TypeError</code> car <code>n</code> est une chaîne. Penser à<br/>
convertir explicitement.</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>Le flottant <code>17.0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas de conversion automatique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le booléen <code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>La fonction <code>input()</code> renvoie<br/>
systématiquement une chaîne<br/>
de caractères, indépendamment<br/>
de ce que l'utilisateur saisit.<br/>
Aucune conversion en booléen<br/>
n'est effectuée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'entier <code>17</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>input</code> renvoie <strong>toujours</strong> une<br/>
chaîne, même si l'utilisateur a tapé un<br/>
nombre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>La chaîne <code>"17"</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : pour obtenir un entier, il<br/>
faut convertir : <code>int(input("Âge ?"))</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q16 : Comparaison</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>2 &lt; 3 &lt; 5</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Particularité Python (rare dans les autres<br/>
langages) : <code>a &lt; b &lt; c</code> est correctement<br/>
interprété comme <code>a &lt; b and b &lt; c</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>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 &lt; 3 et 3 &lt; 5 sont les deux<br/>
vraies.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la comparaison renvoie un booléen,<br/>
pas une valeur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur de syntaxe</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python autorise la comparaison<br/>
chaînée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python permet d'enchaîner<br/>
les comparaisons : <code>2 &lt; 3 &lt; 5</code> équivaut à<br/>
<code>2 &lt; 3 and 3 &lt; 5</code>. C'est lisible et naturel<br/>
(« 3 est entre 2 et 5 »).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q17 : Conversion en booléen</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>bool(0)</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>bool</code> convertit un nombre en booléen : <code>0</code> et<br/>
<code>0.0</code> donnent <code>False</code>, tout autre nombre donne<br/>
<code>True</code>. On retrouve la convention des valeurs<br/>
booléennes 0 et 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><code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 0 est considéré comme faux en<br/>
Python.</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>bool(...)</code> renvoie un booléen,<br/>
pas le même entier.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : par convention, 0 (entier<br/>
ou flottant) est faux ; tout autre nombre<br/>
est vrai.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : conversion valide.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q18 : Longueur de chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>len("hello")</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>len</code> s'applique aussi aux listes, aux p-uplets<br/>
et aux dictionnaires : elle renvoie toujours un<br/>
nombre d'éléments.</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>hello</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>len</code> renvoie un entier, pas la<br/>
chaîne elle-même.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>len</code> ne renvoie pas le nombre de<br/>
mots ou de phrases.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>5.0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>len</code> renvoie un entier, pas un<br/>
flottant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>len</code> renvoie le nombre<br/>
de caractères. Pour une liste, c'est le<br/>
nombre d'éléments.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q19 : Conversion float → int</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>int(3.9)</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Distinguer quatre fonctions : <code>int(3.9)</code> vaut 3<br/>
(troncature vers zéro) ; <code>round(3.9)</code> vaut 4<br/>
(arrondi au plus proche) ; <code>math.floor(3.9)</code><br/>
vaut 3 (partie entière inférieure) ;<br/>
<code>math.ceil(3.9)</code> vaut 4 (partie entière<br/>
supérieure).</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</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int()</code> ne fait pas d'arrondi<br/>
mathématique ; c'est <code>round(3.9)</code> qui<br/>
donnerait 4.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : conversion valide.</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>int(x)</code> applique une<br/>
<strong>troncature vers 0</strong>, pas un arrondi.<br/>
<code>int(-3.9)</code> donnerait<br/>
<code>-3</code>, pas <code>-4</code>. Pour arrondir<br/>
mathématiquement, utiliser <code>round</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3.9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int()</code> renvoie un entier, pas un<br/>
flottant.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q20 : Indexation de chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>"hello"[0]</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Indexation négative : <code>"hello"[-1] = 'o'</code><br/>
(dernier). Tranche : <code>"hello"[1:4] = 'ell'</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="100" format="html">
    <text><![CDATA[<p><code>h</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python indexe à partir de<br/>
<strong>0</strong>. Le premier caractère est à l'indice<br/>
0, le dernier à l'indice n-1.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>e</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à l'indice 1, pas 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>hello</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>[0]</code> extrait un seul caractère,<br/>
pas la chaîne entière.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q21 : Précision flottante</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>0.1 + 0.2 == 0.3</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Bonne pratique : ne jamais comparer des<br/>
flottants avec <code>==</code>. On teste plutôt<br/>
<code>abs(a - b) &lt; epsilon</code>, avec <code>epsilon</code> un petit<br/>
seuil comme <code>1e-9</code> : ainsi<br/>
<code>abs(0.1 + 0.2 - 0.3) &lt; 1e-9</code> vaut <code>True</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>0.3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une comparaison renvoie toujours<br/>
un booléen.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à cause de la représentation IEEE<br/>
754, <code>0.1 + 0.2</code> ne donne pas exactement<br/>
<code>0.3</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas d'erreur, juste un résultat<br/>
contre-intuitif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>False</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>0.1 + 0.2</code> vaut en réalité<br/>
<code>0.30000000000000004</code>. C'est un piège<br/>
classique des flottants.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q22 : Opérateur puissance</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut <code>2 ** 10</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Syntaxe <code>a <strong> b</code> (parfois écrite <code>pow(a, b)</code>).<br/>
Astuce : <code>2 </strong> 0.5</code> donne la racine carrée de<br/>
2.</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>100</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait <code>10²</code>, pas <code>2</code> élevé à la puissance <code>10</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>1024</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>**</code> est l'opérateur<br/>
puissance. À retenir : <code>2¹⁰ = 1024</code>,<br/>
<code>2²⁰ ≈ 10⁶</code>, <code>2³⁰ ≈ 10⁹</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>**</code> est valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>20</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : confusion entre <code><em></code> (multiplication)<br/>
et <code></em>*</code> (puissance).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q23 : Affectation simultanée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p><pre><code>a, b = 1, 2
a, b = b, a</code></pre><br/>
Que valent <code>a</code> et <code>b</code> à la fin ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'affectation simultanée est l'un des grands<br/>
atouts de Python pour la lisibilité. Beaucoup<br/>
d'algorithmes (tri, recherche) en bénéficient.</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>a = 2, b = 2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait le résultat <strong>buggé</strong><br/>
d'un échange séquentiel mal écrit. Python<br/>
gère correctement.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : syntaxe valide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>a = 1, b = 2 (inchangé)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il y a bien échange.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>a = 2, b = 1 (échangés)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python crée d'abord le<br/>
tuple <code>(b, a) = (2, 1)</code>, puis le déballe<br/>
dans <code>a, b</code>. Les deux changent<br/>
<strong>simultanément</strong>, sans variable<br/>
temporaire.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q24 : Print avec virgule</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que renvoie <code>print("a", "b", "c")</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Paramètres utiles : <code>sep="..."</code> (séparateur<br/>
entre arguments) et <code>end="..."</code> (à la fin, par<br/>
défaut <code>\n</code>). Pour ne pas aller à la ligne :<br/>
<code>print("...", end="")</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>Affiche <code>[a, b, c]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun crochet ajouté<br/>
automatiquement.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Affiche <code>abc</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : par défaut, <code>print</code> insère un<br/>
espace entre les arguments.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Affiche <code>a b c</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>print</code> insère un espace<br/>
entre ses arguments, le séparateur par<br/>
défaut. On peut le changer avec<br/>
<code>sep="..."</code>. Ex. : <code>print("a", "b",<br/>
sep=" - ")</code> affiche <code>a - b</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Lève une exception</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>print</code> accepte plusieurs<br/>
arguments.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q25 : Synthèse</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Parmi les affirmations suivantes, laquelle est<br/>
<strong>fausse</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>À retenir : les flottants sont des valeurs<br/>
approchées, on évite donc de tester leur égalité<br/>
avec <code>==</code>. On compare plutôt leur écart à une<br/>
petite tolérance, par exemple<br/>
<code>abs(a - b) &lt; 0.000001</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>Le langage Python est typé dynamiquement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : une variable peut changer de type.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>0.1 + 0.2 == 0.3</code> vaut <code>True</code> en Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Faux (donc bonne réponse) : <code>0.1 + 0.2</code> vaut<br/>
<code>0.30000000000000004</code>, car ces nombres n'ont pas<br/>
d'écriture binaire exacte. La comparaison vaut<br/>
donc <code>False</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>/</code> produit toujours un flottant en Python 3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : différence par rapport à Python 2.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Les indices Python commencent à 0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : convention standard en informatique.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q26 : Échanger deux variables en Python</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la façon la plus idiomatique d'échanger<br/>
les valeurs de deux variables <code>a</code> et <code>b</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'affectation multiple <code>a, b = b, a</code> repose sur les<br/>
<em>p-uplets</em> implicites : Python crée d'abord le<br/>
couple <code>(b, a)</code> côté droit, puis le déballe à<br/>
gauche. Cette construction est plus claire et plus<br/>
courte que la version classique avec variable<br/>
temporaire (<code>tmp = a; a = b; b = tmp</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>swap(a, b)</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il n'existe pas de fonction native<br/>
<code>swap</code> en Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>a = b = a</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette instruction affecte la valeur<br/>
actuelle de <code>a</code> à <code>b</code>, puis cette même valeur à<br/>
<code>a</code> (sans changement). Aucun échange n'est<br/>
effectué.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>a = b</code> puis <code>b = a</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce code ne réalise pas un échange. Après<br/>
la première instruction, <code>a</code> perd sa valeur<br/>
d'origine et prend celle de <code>b</code>. La seconde<br/>
instruction recopie alors <code>b</code> dans... <code>b</code>. Les<br/>
deux variables se retrouvent égales à la valeur<br/>
initiale de <code>b</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>a, b = b, a</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python évalue d'abord le<br/>
membre de droite (le couple <code>(b, a)</code>) puis<br/>
affecte simultanément les deux composantes aux<br/>
variables de gauche. Aucune variable temporaire<br/>
n'est nécessaire.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q27 : Découper une date</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On exécute le code suivant :<br/>
<pre><code>date = "12/09/2026"
morceaux = date.split("/")
print(morceaux)</code></pre><br/>
Que va afficher le programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>split(sep)</code> découpe une chaîne selon un séparateur et renvoie une<br/>
liste de chaînes. C'est la méthode utilisée pour lire une ligne d'un<br/>
fichier CSV, avant de convertir les valeurs numériques avec <code>int</code> ou<br/>
<code>float</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>[12, 9, 2026]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>split</code> ne convertit rien, les morceaux restent des<br/>
chaînes de caractères. Pour obtenir le jour sous forme d'entier,<br/>
il faut écrire <code>int(morceaux[0])</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>['12/', '09/', '2026']</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le séparateur sert à couper la chaîne et disparaît du<br/>
résultat. Aucun morceau ne contient la barre oblique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>['12', '09', '2026']</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>split("/")</code> découpe la chaîne à chaque barre<br/>
oblique et renvoie la liste des morceaux. Ce sont des chaînes :<br/>
il faudrait <code>int</code> pour obtenir des nombres.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>'12092026'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>split</code> ne se contente pas de supprimer les barres<br/>
obliques, il renvoie une <strong>liste</strong> de morceaux, pas une chaîne<br/>
recollée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q28 : Méthodes de chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut l'expression <code>"NSI".lower()</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Méthodes de chaîne fréquentes : <code>upper()</code> (tout en<br/>
majuscules), <code>lower()</code> (tout en minuscules),<br/>
<code>strip()</code> (supprime les espaces de début et de fin),<br/>
<code>split(sep)</code> (découpe selon un séparateur). Ces<br/>
méthodes renvoient une <strong>nouvelle</strong> chaîne, sans<br/>
modifier la chaîne d'origine.</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>'Nsi'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : seule la première lettre serait alors<br/>
en majuscule. La méthode <code>lower</code> passe tous les<br/>
caractères en minuscules.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La méthode <code>lower</code> n'existe pas</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>lower</code> est une méthode standard des<br/>
chaînes Python, présente depuis les premières<br/>
versions du langage. Elle est très utilisée pour<br/>
comparer des chaînes sans tenir compte de la<br/>
casse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>'nsi'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>lower</code> renvoie une <strong>nouvelle chaîne</strong> où toutes les lettres ont été passées<br/>
en minuscules. La chaîne d'origine n'est pas<br/>
modifiée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>'NSI'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la méthode <code>lower</code> transforme la chaîne<br/>
en minuscules. Elle ne peut donc pas renvoyer la<br/>
chaîne d'origine inchangée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q29 : Une division par zéro évitée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On exécute le code suivant :</p>
<pre><code>x = 0
print(x != 0 and 10 / x &gt; 1)
print(x == 0 or 10 / x &gt; 1)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le caractère séquentiel de <code>and</code> et <code>or</code> permet de protéger une<br/>
opération risquée : dans <code>x != 0 and 10 / x &gt; 1</code>, la division n'est<br/>
tentée que si <code>x</code> est non nul.</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>False</code> puis une erreur <code>ZeroDivisionError</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>or</code> est lui aussi séquentiel. Son opérande gauche,<br/>
<code>x == 0</code>, est vrai : le résultat vaut <code>True</code> et la division<br/>
<code>10 / x</code> n'est jamais calculée.</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 : les deux résultats sont inversés. <code>x != 0</code> est faux pour<br/>
<code>x</code> nul, donc le <code>and</code> vaut <code>False</code> ; <code>x == 0</code> est vrai, donc le<br/>
<code>or</code> vaut <code>True</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur <code>ZeroDivisionError</code> dès le premier <code>print</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>and</code> n'évalue pas son opérande droit quand l'opérande<br/>
gauche est faux. Comme <code>x != 0</code> vaut <code>False</code>, la division par zéro<br/>
n'a jamais lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>False</code> puis <code>True</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>and</code> et <code>or</code> évaluent leurs opérandes de gauche à<br/>
droite et s'arrêtent dès que le résultat est connu. <code>x != 0</code> est<br/>
faux, donc le <code>and</code> vaut <code>False</code> sans calculer <code>10 / x</code> ; <code>x == 0</code><br/>
est vrai, donc le <code>or</code> vaut <code>True</code> sans calculer <code>10 / x</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q30 : Addition de deux chaînes</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut l'expression <code>"3" + "4"</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le même symbole <code>+</code> additionne deux nombres et concatène deux<br/>
chaînes. C'est le type des opérandes qui décide : <code>"3" + "4"</code><br/>
vaut <code>'34'</code>, alors que <code>3 + 4</code> vaut <code>7</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="100" format="html">
    <text><![CDATA[<p><code>'34'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : entre deux chaînes, <code>+</code> est la concaténation.<br/>
Les caractères de <code>"4"</code> sont ajoutés à la suite de ceux de<br/>
<code>"3"</code>, sans aucun calcul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les guillemets font de <code>"3"</code> et <code>"4"</code> des chaînes,<br/>
pas des nombres. Pour obtenir <code>7</code>, il faudrait convertir les<br/>
deux avec <code>int</code> avant d'additionner.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>'7'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python n'additionne pas le contenu des chaînes. Il les<br/>
met bout à bout, ce qui donne <code>'34'</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car <code>+</code> ne s'applique pas aux chaînes</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>+</code> s'applique bien à deux chaînes et les concatène.<br/>
L'erreur n'apparaît que si l'on mélange une chaîne et un nombre.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q31 : Multiplication d'une chaîne par un entier</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut l'expression <code>"ab" * 3</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avec une chaîne et un entier, <code>*</code> répète la chaîne. Avec deux<br/>
chaînes, l'opération n'a pas de sens et lève une 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>'ababab'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : multiplier une chaîne par un entier la répète.<br/>
<code>"ab"</code> est recopiée trois fois à la suite, sans séparateur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>'ab ab ab'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la répétition n'insère aucun espace. Les copies sont<br/>
collées les unes aux autres : <code>'ababab'</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>'ab3'</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>*</code> ne colle pas le nombre à la chaîne. Il répète la<br/>
chaîne, ce qui donne <code>'ababab'</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car on ne multiplie pas une chaîne par un entier</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette opération est permise et très utilisée, par<br/>
exemple <code>"-" * 20</code> pour tracer une ligne. Seule la<br/>
multiplication de deux chaînes entre elles est interdite.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q32 : Dernier caractère d'une chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>mot = "python"
print(mot[len(mot) - 1])</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Les indices d'une chaîne de longueur $n$ vont de $0$ à $n - 1$. Le<br/>
dernier caractère s'obtient donc avec <code>mot[len(mot) - 1]</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="100" format="html">
    <text><![CDATA[<p><code>n</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>len(mot)</code> vaut 6 et les indices vont de <code>0</code><br/>
à 5. L'indice <code>len(mot) - 1</code>, soit 5, désigne donc le<br/>
dernier caractère, <code>n</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>p</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le premier caractère est à l'indice <code>0</code>. L'indice<br/>
<code>len(mot) - 1</code> vaut 5 et désigne le dernier caractère.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>o</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'avant-dernier caractère est à l'indice<br/>
<code>len(mot) - 2</code>, soit 4. À l'indice 5 se trouve <code>n</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, car l'indice dépasse la longueur de la chaîne</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est <code>mot[len(mot)]</code>, d'indice 6, qui serait hors<br/>
limites. En retranchant <code>1</code>, on tombe exactement sur le dernier<br/>
indice valide.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q33 : Un nom de variable interdit</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que produit l'instruction <code>class = 3</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un nom de variable commence par une lettre ou un tiret bas, ne<br/>
contient ni espace ni accent de préférence, et n'est jamais un<br/>
mot-clé. <code>classe</code> ou <code>niveau</code> conviennent.</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 de syntaxe, <code>class</code> étant un mot réservé</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les mots-clés comme <code>class</code>, <code>if</code>, <code>for</code> ou<br/>
<code>def</code> sont réservés et ne peuvent pas servir de nom de variable.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La création d'une variable <code>class</code> valant $3$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python refuse ce nom avant même d'exécuter<br/>
l'affectation.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Un avertissement, puis la création de la variable</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il ne s'agit pas d'un avertissement mais d'une erreur<br/>
bloquante.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La création d'une classe nommée <code>3</code>, sans attribut</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : définir une classe demande une autre syntaxe, et <code>3</code><br/>
n'est pas un nom valide.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q34 : Trois affectations raccourcies</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>n = 10
n -= 4
n *= 2
print(n)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>n -= a</code> et <code>n <em>= b</code> abrègent <code>n = n - a</code> et <code>n = n </em> b</code> ; chaque<br/>
instruction part de la valeur courante.</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 : <code>n -= 4</code> retire 4, puis <code>n *= 2</code> multiplie<br/>
le résultat par 2 : $(10 - 4) \times 2 = 12$.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les deux instructions s'enchaînent ; la multiplication<br/>
porte sur la valeur déjà diminuée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : chaque écriture raccourcie modifie bien <code>n</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, <code>-=</code> n'existant pas en Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n -= 4</code> est l'abréviation de <code>n = n - 4</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q35 : Un signe moins devant une puissance</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut <code>-2 ** 2</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>*<em></code> passe avant le signe et avant <code></em></code> ; en cas de doute, on écrit<br/>
<code>(-2) <strong> 2</code> ou <code>-(2 </strong> 2)</code> pour lever l'ambiguïté.</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><strong></code> est prioritaire sur le signe moins.<br/>
L'expression se lit <code>-(2 </strong> 2)</code>, soit -4.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait <code>(-2) ** 2</code>. Sans parenthèses, le signe<br/>
s'applique après la puissance.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la puissance est bien calculée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur de syntaxe</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'expression est valide, seule sa lecture demande de<br/>
connaître les priorités.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q36 : Le reste d'un nombre négatif</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut <code>-7 % 3</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Python garantit <code>a == b * (a // b) + a % b</code> avec un reste compris<br/>
entre $0$ et $b - 1$ pour <code>b</code> positif, même quand <code>a</code> est négatif.</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</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : en Python, le reste a le signe du diviseur et<br/>
vérifie <code>-7 == 3 * (-7 // 3) + 2</code>, avec <code>-7 // 3</code><br/>
valant -3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : -1 est le reste au sens de certains autres langages,<br/>
qui gardent le signe du dividende. Python arrondit la division<br/>
entière vers le bas, ce qui donne un reste positif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 1 serait le reste de la valeur absolue ; le signe<br/>
du dividende change le résultat.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, le modulo n'acceptant pas un nombre négatif</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>%</code> accepte tous les entiers.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q37 : Modifier un caractère d'une chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que produit ce programme ?<br/>
<pre><code>s = "bonjour"
s[0] = "B"</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une chaîne ne change jamais : toute « modification » crée une<br/>
nouvelle chaîne, ce que font <code>upper</code>, <code>replace</code> ou la<br/>
concaténation.</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, les chaînes étant immuables</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les chaînes sont immuables ; pour obtenir<br/>
<code>Bonjour</code>, on construit une nouvelle chaîne, par exemple<br/>
<code>"B" + s[1:]</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>s</code> devient <code>Bonjour</code>, le premier caractère remplacé</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'affectation par indice est refusée sur une chaîne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>s</code> devient <code>B</code>, l'affectation écrasant le reste</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il n'y a ni remplacement ni raccourcissement, mais<br/>
une erreur.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Rien, la modification étant ignorée en silence</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python signale l'opération interdite par une<br/>
exception.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Variables et types de base — Q38 : Tester la présence d'une sous-chaîne</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut l'expression <code>"jour" in "bonjour"</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>sous in chaine</code> répond vrai si <code>sous</code> apparaît d'un seul tenant<br/>
dans <code>chaine</code>, sans dire où.</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>, <code>jour</code> figure d'un seul tenant dans <code>bonjour</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>in</code> teste si la chaîne de gauche apparaît<br/>
telle quelle, caractères consécutifs, dans celle de droite.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>False</code>, <code>in</code> ne cherchant qu'un caractère isolé</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>in</code> cherche la sous-chaîne entière, consécutive, pas<br/>
ses lettres une à une.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur, <code>in</code> ne s'appliquant qu'aux listes</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>in</code> fonctionne aussi sur les chaînes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Un entier, la position de <code>jour</code> dans <code>bonjour</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>in</code> renvoie un booléen ; la position s'obtient par<br/>
<code>find</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
