<?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<br/>
limitée</strong>. <code>0.1 + 0.2</code> ne donne pas exactement<br/>
<code>0.3</code> mais <code>0.30000000000000004</code> à cause de la<br/>
représentation binaire IEEE 754.</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> est un module spécialisé,<br/>
mais le type natif 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<br/>
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>0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 0 est le reste, 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 est impair, son reste modulo 2<br/>
est 1.</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 utile pour le <strong>débogage</strong> rapide.<br/>
Pour des programmes plus structurés, on<br/>
privilégie le module <code>logging</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>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<br/>
flexibilité mais on perd en sécurité. Les<br/>
annotations de type (<code>x: int = 5</code>) et <code>mypy</code><br/>
permettent une vérification statique<br/>
optionnelle.</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 redéclarer <code>x</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune « redéclaration » nécessaire<br/>
en Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Oui, mais Python affiche un avertissement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun avertissement par défaut.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Non, <code>x</code> est figé en entier</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, parce que Python est typé dynamiquement : une variable peut changer de type au cours du programme</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python autorise cette<br/>
réaffectation. Attention : c'est puissant<br/>
mais peut causer des 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 : protéger les conversions de<br/>
saisies utilisateur avec un <code>try/except</code>.<br/>
<pre><code>try:
    n = int(input())
except ValueError:
    print("Pas un entier")</code></pre></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>. À gérer avec un <code>try/except</code>.</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> est <strong>surchargé</strong> : addition pour les<br/>
nombres, concaténation pour les chaînes et<br/>
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> (équivalent à <code>2 &lt; 3 and 3 &lt; 5</code>)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python permet d'enchaîner<br/>
les comparaisons. 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>Valeurs <strong>fausses</strong> en Python : <code>False</code>, <code>0</code>,<br/>
<code>0.0</code>, <code>""</code>, <code>[]</code>, <code>{}</code>, <code>None</code>. Tout le reste<br/>
est vrai. Permet d'écrire <code>if liste:</code> au lieu<br/>
de <code>if len(liste) &gt; 0:</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>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. La chaîne vide <code>""</code> et la liste<br/>
vide <code>[]</code> sont aussi fausses.</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> est polymorphe : marche sur les chaînes,<br/>
listes, tuples, dictionnaires, ensembles,<br/>
fichiers... Toujours en O(1) pour ces types.</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) = 3</code><br/>
(troncature vers zéro) ; <code>round(3.9) = 4</code><br/>
(arrondi au plus proche, avec départage au<br/>
pair seulement pour les valeurs à mi-chemin<br/>
du type $0{,}5$) ; <code>math.floor(3.9) = 3</code><br/>
(partie entière inférieure) ;<br/>
<code>math.ceil(3.9) = 4</code> (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 (arrondi)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>int()</code> ne fait pas d'arrondi<br/>
mathématique.</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 (troncature vers 0)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>int(x)</code> applique une<br/>
troncature vers 0. <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>. Utiliser<br/>
<code>abs(a - b) &lt; epsilon</code> pour une comparaison à<br/>
ε près, ou le module <code>math.isclose</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>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>1024 (= 2¹⁰)</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> (espaces entre les arguments)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : le séparateur par défaut<br/>
est un espace. 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>Mnémonique des valeurs fausses : « tout ce<br/>
qui est vide ou nul ». Cela permet des<br/>
idiomes concis comme <code>if liste:</code> (= « si la<br/>
liste n'est pas vide »).</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>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>La chaîne vide <code>""</code> est considérée comme vraie dans une condition</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Faux (donc bonne réponse) : la chaîne vide<br/>
est <strong>fausse</strong> en contexte booléen, comme<br/>
<code>0</code>, <code>[]</code>, <code>{}</code>, <code>None</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. De plus, comme les paramètres<br/>
sont passés par référence d'objet, une telle<br/>
fonction ne pourrait pas réaffecter les<br/>
variables d'origine.</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 : Affichage formaté avec une f-string</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On exécute le code suivant :</p>
<pre><code>prix = 12.5
quantite = 3
print(f"Total : {prix * quantite} €")</code></pre>
<p>Que va afficher le programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Quelques options pratiques des f-strings :<br/>
<code>f"{x:.2f}"</code> arrondit à deux chiffres après la<br/>
virgule, <code>f"{x:&gt;10}"</code> aligne à droite sur dix<br/>
caractères, <code>f"{x=}"</code> affiche à la fois le nom et<br/>
la valeur (<code>x=37.5</code>). C'est une syntaxe à privilégier<br/>
pour la plupart des affichages courants.</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>Total : 37.5 €</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la f-string remplace<br/>
<code>{prix * quantite}</code> par le résultat de<br/>
l'expression évaluée, soit<br/>
$12{,}5 \times 3 = 37{,}5$. Le reste de la<br/>
chaîne est laissé tel quel.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>Total : 12.5 * 3 €</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python évalue toujours l'expression<br/>
entre accolades, il n'affiche jamais l'opération<br/>
en clair. Le résultat affiché est<br/>
$37{,}5$, pas la formule.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>Total : {prix * quantite} €</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la lettre <code>f</code> placée devant la chaîne<br/>
active le formatage : les expressions entre<br/>
accolades sont <strong>évaluées</strong> avant l'affichage.<br/>
Sans le préfixe <code>f</code>, on aurait au contraire ce<br/>
rendu littéral.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le code provoque une erreur de syntaxe</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est correcte. Les f-strings<br/>
sont disponibles depuis Python $3{.}6$ et sont<br/>
aujourd'hui le moyen le plus simple d'insérer<br/>
des valeurs dans une chaîne.</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>replace(a, b)</code> (remplace <code>a</code> par <code>b</code>),<br/>
<code>split(sep)</code> (découpe selon un séparateur). Comme<br/>
les chaînes sont immuables, ces méthodes renvoient<br/>
toujours une <strong>nouvelle</strong> chaîne.</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 : ce serait l'effet de la méthode<br/>
<code>capitalize</code>, qui met seulement la première<br/>
lettre en majuscule et les autres en minuscules.<br/>
La méthode <code>lower</code> agit sur tous les caractères.</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<br/>
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 (les chaînes Python sont immuables).</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 : Différence entre `==` et `is`</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>En Python, quelle est la différence entre les<br/>
opérateurs <code>==</code> et <code>is</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Recommandation pratique : utiliser <code>==</code> pour<br/>
comparer des valeurs ordinaires, et réserver <code>is</code><br/>
aux comparaisons à des <strong>singletons</strong> (<code>x is None</code>,<br/>
<code>x is True</code>, <code>x is False</code>). La référence avec<br/>
<code>None</code> est en effet unique en mémoire, donc <code>is</code><br/>
est exact et plus rapide.</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>==</code> renvoie un nombre, <code>is</code> renvoie un booléen</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les deux opérateurs renvoient un<br/>
booléen (<code>True</code> ou <code>False</code>). Aucun ne produit<br/>
de valeur numérique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Les deux sont strictement équivalents</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ils ne testent pas la même chose. La<br/>
confusion entre les deux est une source classique<br/>
de bugs subtils, en particulier sur les listes<br/>
et les dictionnaires.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>==</code> ne fonctionne que sur les nombres ; <code>is</code> ne fonctionne que sur les chaînes</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les deux opérateurs s'appliquent à<br/>
<strong>toutes</strong> les valeurs Python. La distinction<br/>
entre eux est sémantique (égalité de valeur vs<br/>
identité d'objet), pas typologique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>==</code> compare les valeurs ; <code>is</code> teste si les deux références désignent le même objet en mémoire</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : deux listes peuvent contenir les<br/>
mêmes valeurs (<code>[1, 2] == [1, 2]</code> vaut <code>True</code>)<br/>
tout en étant des objets distincts en mémoire<br/>
(<code>[1, 2] is [1, 2]</code> vaut <code>False</code>). L'opérateur<br/>
<code>is</code> est plus strict que <code>==</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
