{ "chapter": { "id": "python-types", "level": "snt", "theme": "Programmation", "title": "2. Types de base et calculs", "description": "Entiers, flottants, chaînes de caractères et booléens ; la fonction\ntype ; les opérateurs arithmétiques dont la division entière, le reste\net la puissance ; la priorité des opérations ; les conversions entre\ntypes ; la concaténation et la répétition de chaînes.", "prerequisites": [], "references": [] }, "questions": [ { "id": "q01", "difficulty": 1, "skills": [ "types", "entier", "flottant" ], "title": "Entier ou flottant", "statement": "Quel est le type de la valeur `19.0` en Python ?", "options": [ { "text": "`float`, un nombre à virgule", "correct": true, "feedback": "Bonne réponse : la présence du point fait de `19.0` un flottant,\nmême si sa partie décimale est nulle.\n" }, { "text": "`int`, un nombre entier", "correct": false, "feedback": "Erreur : `19` serait un entier. Avec le point, `19.0` est un\nflottant, et `19 == 19.0` est vrai mais les types diffèrent.\n" }, { "text": "`str`, une chaîne de caractères", "correct": false, "feedback": "Erreur : une chaîne s'écrit entre guillemets, comme `\"19.0\"`.\nSans guillemets, c'est un nombre.\n" }, { "text": "`bool`, un booléen", "correct": false, "feedback": "Erreur : les booléens sont seulement `True` et `False`.\n" } ], "explanation": "Python distingue les entiers (`int`) des nombres à virgule (`float`).\nLe point décimal suffit à faire un flottant : `19.0` est un `float`,\n`19` un `int`." }, { "id": "q02", "difficulty": 1, "skills": [ "types", "chaine" ], "title": "Des chiffres entre guillemets", "statement": "```python\ncode = \"2026\"\n```\n\nQuel est le type de `code` ?", "options": [ { "text": "`str`", "correct": true, "feedback": "Bonne réponse : les guillemets font une chaîne de caractères,\nmême si elle ne contient que des chiffres. On ne peut pas\ncalculer avec sans la convertir.\n" }, { "text": "`int`", "correct": false, "feedback": "Erreur : sans guillemets, `2026` serait un entier. Entre\nguillemets, c'est un texte de quatre caractères.\n" }, { "text": "`float`", "correct": false, "feedback": "Erreur : il n'y a ni point décimal ni nombre : c'est un texte.\n" }, { "text": "`bool`", "correct": false, "feedback": "Erreur : un booléen ne vaut que `True` ou `False`.\n" } ], "explanation": "Les guillemets décident du type : `\"2026\"` est une chaîne, `2026` un\nentier. Une chaîne de chiffres ne permet pas de calculer tant qu'on\nne l'a pas convertie avec `int`." }, { "id": "q03", "difficulty": 1, "skills": [ "type", "flottant", "operateurs" ], "title": "Le type d'une division", "statement": "```python\nprint(type(7 / 2))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "``", "correct": true, "feedback": "Bonne réponse : la division `/` donne toujours un flottant, ici\n3.5.\n" }, { "text": "``", "correct": false, "feedback": "Erreur : même `8 / 2` donne le flottant `4.0`. Seule la division\nentière `//` donne un entier.\n" }, { "text": "`3.5`", "correct": false, "feedback": "Erreur : 3.5 est le résultat de la division, mais `type` affiche\nle type de ce résultat, pas sa valeur.\n" }, { "text": "``", "correct": false, "feedback": "Erreur : aucune chaîne n'intervient, seulement des nombres.\n" } ], "explanation": "La fonction `type` renvoie le type d'une valeur. La division `/`\nproduit toujours un `float`, même quand le résultat tombe juste." }, { "id": "q04", "difficulty": 1, "skills": [ "division-entiere", "modulo" ], "title": "Quotient et reste", "statement": "```python\nprint(17 // 5, 17 % 5)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`3 2`", "correct": true, "feedback": "Bonne réponse : 17 contient 3 fois 5, et il reste 2. C'est la\ndivision euclidienne.\n" }, { "text": "`3.4 2`", "correct": false, "feedback": "Erreur : 3.4 est le résultat de `17 / 5`. La division entière\n`//` ne garde que le quotient entier.\n" }, { "text": "`2 3`", "correct": false, "feedback": "Erreur : le quotient est 3 et le reste 2, dans cet ordre.\n" }, { "text": "`3 0`", "correct": false, "feedback": "Erreur : 3 fois 5 font 15, il reste 2 pour atteindre 17.\n" } ], "explanation": "`//` donne le quotient entier et `%` le reste de la division\neuclidienne. Ce sont deux opérateurs très utiles pour compter des\npaquets ou tester la divisibilité.", "variants": [ { "statement": "```python\nprint(17 // 5, 17 % 5)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`3 2`", "correct": true, "feedback": "Bonne réponse : 17 contient 3 fois 5, et il reste 2. C'est la\ndivision euclidienne.\n" }, { "text": "`3.4 2`", "correct": false, "feedback": "Erreur : 3.4 est le résultat de `17 / 5`. La division entière\n`//` ne garde que le quotient entier.\n" }, { "text": "`2 3`", "correct": false, "feedback": "Erreur : le quotient est 3 et le reste 2, dans cet ordre.\n" }, { "text": "`3 0`", "correct": false, "feedback": "Erreur : 3 fois 5 font 15, il reste 2 pour atteindre 17.\n" } ], "explanation": "`//` donne le quotient entier et `%` le reste de la division\neuclidienne. Ce sont deux opérateurs très utiles pour compter des\npaquets ou tester la divisibilité." }, { "statement": "```python\nprint(23 // 4, 23 % 4)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`5 3`", "correct": true, "feedback": "Bonne réponse : 23 contient 5 fois 4, et il reste 3. C'est la\ndivision euclidienne.\n" }, { "text": "`5.75 3`", "correct": false, "feedback": "Erreur : 5.75 est le résultat de `23 / 4`. La division entière\n`//` ne garde que le quotient entier.\n" }, { "text": "`3 5`", "correct": false, "feedback": "Erreur : le quotient est 5 et le reste 3, dans cet ordre.\n" }, { "text": "`5 0`", "correct": false, "feedback": "Erreur : 5 fois 4 font 20, il reste 3 pour atteindre 23.\n" } ], "explanation": "`//` donne le quotient entier et `%` le reste de la division\neuclidienne. Ce sont deux opérateurs très utiles pour compter des\npaquets ou tester la divisibilité." }, { "statement": "```python\nprint(29 // 6, 29 % 6)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`4 5`", "correct": true, "feedback": "Bonne réponse : 29 contient 4 fois 6, et il reste 5. C'est la\ndivision euclidienne.\n" }, { "text": "`4.83 5`", "correct": false, "feedback": "Erreur : 4.83 est le résultat de `29 / 6`. La division entière\n`//` ne garde que le quotient entier.\n" }, { "text": "`5 4`", "correct": false, "feedback": "Erreur : le quotient est 4 et le reste 5, dans cet ordre.\n" }, { "text": "`4 0`", "correct": false, "feedback": "Erreur : 4 fois 6 font 24, il reste 5 pour atteindre 29.\n" } ], "explanation": "`//` donne le quotient entier et `%` le reste de la division\neuclidienne. Ce sont deux opérateurs très utiles pour compter des\npaquets ou tester la divisibilité." } ] }, { "id": "q05", "difficulty": 2, "skills": [ "modulo", "calcul", "booleens" ], "title": "Reconnaître un nombre pair", "statement": "Quelle expression vaut `True` exactement quand l'entier `n` est\npair ?", "options": [ { "text": "`n % 2 == 0`", "correct": true, "feedback": "Bonne réponse : un nombre pair a un reste nul dans la division\npar 2.\n" }, { "text": "`n // 2 == 0`", "correct": false, "feedback": "Erreur : `n // 2` est le quotient. Il vaut 0 seulement pour 0 et\n1, ce qui ne dit rien de la parité.\n" }, { "text": "`n / 2 == 0`", "correct": false, "feedback": "Erreur : `n / 2` vaut 0 seulement si `n` vaut 0.\n" }, { "text": "`n % 2 == 1`", "correct": false, "feedback": "Erreur : un reste de 1 dans la division par 2 caractérise un\nnombre impair.\n" } ], "explanation": "Le reste `%` teste la divisibilité : `n % k == 0` signifie que `n` est\nun multiple de `k`. Pour la parité, on prend `k` égal à 2." }, { "id": "q06", "difficulty": 1, "skills": [ "puissance", "operateurs" ], "title": "La puissance", "statement": "Un kibioctet contient `2 ** 10` octets.\n\n```python\nprint(2 ** 10)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`1024`", "correct": true, "feedback": "Bonne réponse : `**` est l'opérateur puissance, 2 multiplié dix\nfois par lui-même donne 1024.\n" }, { "text": "`20`", "correct": false, "feedback": "Erreur : 20 serait `2 * 10`. L'opérateur `**` élève à la\npuissance.\n" }, { "text": "`100`", "correct": false, "feedback": "Erreur : 100 serait `10 ** 2`. Ici la base est 2 et l'exposant\n10.\n" }, { "text": "`2048`", "correct": false, "feedback": "Erreur : 2048 est `2 ** 11`. Dix facteurs 2 donnent 1024.\n" } ], "explanation": "L'opérateur `**` calcule une puissance : `2 ** 10` vaut 1024. On le\nretrouve partout en informatique, où les tailles sont des puissances\nde 2." }, { "id": "q07", "difficulty": 2, "skills": [ "priorite", "calcul" ], "title": "La priorité des opérations", "statement": "```python\nprint(2 + 3 * 4 ** 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`50`", "correct": true, "feedback": "Bonne réponse : la puissance d'abord, `4 ** 2` vaut 16, puis la\nmultiplication, 48, puis l'addition, 50.\n" }, { "text": "`80`", "correct": false, "feedback": "Erreur : 80 serait `(2 + 3) * 16`. Sans parenthèses, la\nmultiplication passe avant l'addition.\n" }, { "text": "`196`", "correct": false, "feedback": "Erreur : 196 serait `(2 + 3 * 4) ** 2`. La puissance est\ncalculée en premier, sur 4 seulement.\n" }, { "text": "`26`", "correct": false, "feedback": "Erreur : 26 serait `2 + 3 * 8`, comme si `4 ** 2`\nvalait 8. Une puissance n'est pas une multiplication.\n" } ], "explanation": "Python suit les priorités usuelles : puissance, puis multiplication et\ndivision, puis addition et soustraction. Les parenthèses forcent un\nautre ordre.", "variants": [ { "statement": "```python\nprint(2 + 3 * 4 ** 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`50`", "correct": true, "feedback": "Bonne réponse : la puissance d'abord, `4 ** 2` vaut 16, puis la\nmultiplication, 48, puis l'addition, 50.\n" }, { "text": "`80`", "correct": false, "feedback": "Erreur : 80 serait `(2 + 3) * 16`. Sans parenthèses, la\nmultiplication passe avant l'addition.\n" }, { "text": "`196`", "correct": false, "feedback": "Erreur : 196 serait `(2 + 3 * 4) ** 2`. La puissance est\ncalculée en premier, sur 4 seulement.\n" }, { "text": "`26`", "correct": false, "feedback": "Erreur : 26 serait `2 + 3 * 8`, comme si `4 ** 2`\nvalait 8. Une puissance n'est pas une multiplication.\n" } ], "explanation": "Python suit les priorités usuelles : puissance, puis multiplication et\ndivision, puis addition et soustraction. Les parenthèses forcent un\nautre ordre." }, { "statement": "```python\nprint(5 + 2 * 3 ** 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`23`", "correct": true, "feedback": "Bonne réponse : la puissance d'abord, `3 ** 2` vaut 9, puis la\nmultiplication, 18, puis l'addition, 23.\n" }, { "text": "`63`", "correct": false, "feedback": "Erreur : 63 serait `(5 + 2) * 9`. Sans parenthèses, la\nmultiplication passe avant l'addition.\n" }, { "text": "`121`", "correct": false, "feedback": "Erreur : 121 serait `(5 + 2 * 3) ** 2`. La puissance est\ncalculée en premier, sur 3 seulement.\n" }, { "text": "`17`", "correct": false, "feedback": "Erreur : 17 serait `5 + 2 * 6`, comme si `3 ** 2`\nvalait 6. Une puissance n'est pas une multiplication.\n" } ], "explanation": "Python suit les priorités usuelles : puissance, puis multiplication et\ndivision, puis addition et soustraction. Les parenthèses forcent un\nautre ordre." }, { "statement": "```python\nprint(1 + 4 * 5 ** 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`101`", "correct": true, "feedback": "Bonne réponse : la puissance d'abord, `5 ** 2` vaut 25, puis la\nmultiplication, 100, puis l'addition, 101.\n" }, { "text": "`125`", "correct": false, "feedback": "Erreur : 125 serait `(1 + 4) * 25`. Sans parenthèses, la\nmultiplication passe avant l'addition.\n" }, { "text": "`441`", "correct": false, "feedback": "Erreur : 441 serait `(1 + 4 * 5) ** 2`. La puissance est\ncalculée en premier, sur 5 seulement.\n" }, { "text": "`41`", "correct": false, "feedback": "Erreur : 41 serait `1 + 4 * 10`, comme si `5 ** 2`\nvalait 10. Une puissance n'est pas une multiplication.\n" } ], "explanation": "Python suit les priorités usuelles : puissance, puis multiplication et\ndivision, puis addition et soustraction. Les parenthèses forcent un\nautre ordre." } ] }, { "id": "q08", "difficulty": 2, "skills": [ "concatenation", "chaine" ], "title": "Additionner deux chaînes", "statement": "```python\na = \"12\"\nb = \"3\"\nprint(a + b)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`123`", "correct": true, "feedback": "Bonne réponse : entre deux chaînes, `+` colle les textes bout à\nbout. C'est la concaténation.\n" }, { "text": "`15`", "correct": false, "feedback": "Erreur : 15 serait la somme des nombres 12 et 3. Ici ce sont des\nchaînes, `+` les concatène.\n" }, { "text": "`12 3`", "correct": false, "feedback": "Erreur : la concaténation ne place aucun espace entre les deux\nchaînes.\n" }, { "text": "Une erreur, on n'additionne pas des textes", "correct": false, "feedback": "Erreur : `+` est défini entre chaînes, il les met bout à bout.\n" } ], "explanation": "Le même signe `+` additionne des nombres et concatène des chaînes.\nLe type des valeurs décide de l'opération : `\"12\" + \"3\"` donne\n`\"123\"`.", "variants": [ { "statement": "```python\na = \"12\"\nb = \"3\"\nprint(a + b)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`123`", "correct": true, "feedback": "Bonne réponse : entre deux chaînes, `+` colle les textes bout à\nbout. C'est la concaténation.\n" }, { "text": "`15`", "correct": false, "feedback": "Erreur : 15 serait la somme des nombres 12 et 3. Ici ce sont des\nchaînes, `+` les concatène.\n" }, { "text": "`12 3`", "correct": false, "feedback": "Erreur : la concaténation ne place aucun espace entre les deux\nchaînes.\n" }, { "text": "Une erreur, on n'additionne pas des textes", "correct": false, "feedback": "Erreur : `+` est défini entre chaînes, il les met bout à bout.\n" } ], "explanation": "Le même signe `+` additionne des nombres et concatène des chaînes.\nLe type des valeurs décide de l'opération : `\"12\" + \"3\"` donne\n`\"123\"`." }, { "statement": "```python\na = \"45\"\nb = \"6\"\nprint(a + b)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`456`", "correct": true, "feedback": "Bonne réponse : entre deux chaînes, `+` colle les textes bout à\nbout. C'est la concaténation.\n" }, { "text": "`51`", "correct": false, "feedback": "Erreur : 51 serait la somme des nombres 45 et 6. Ici ce sont des\nchaînes, `+` les concatène.\n" }, { "text": "`45 6`", "correct": false, "feedback": "Erreur : la concaténation ne place aucun espace entre les deux\nchaînes.\n" }, { "text": "Une erreur, on n'additionne pas des textes", "correct": false, "feedback": "Erreur : `+` est défini entre chaînes, il les met bout à bout.\n" } ], "explanation": "Le même signe `+` additionne des nombres et concatène des chaînes.\nLe type des valeurs décide de l'opération : `\"45\" + \"6\"` donne\n`\"456\"`." }, { "statement": "```python\na = \"7\"\nb = \"80\"\nprint(a + b)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`780`", "correct": true, "feedback": "Bonne réponse : entre deux chaînes, `+` colle les textes bout à\nbout. C'est la concaténation.\n" }, { "text": "`87`", "correct": false, "feedback": "Erreur : 87 serait la somme des nombres 7 et 80. Ici ce sont des\nchaînes, `+` les concatène.\n" }, { "text": "`7 80`", "correct": false, "feedback": "Erreur : la concaténation ne place aucun espace entre les deux\nchaînes.\n" }, { "text": "Une erreur, on n'additionne pas des textes", "correct": false, "feedback": "Erreur : `+` est défini entre chaînes, il les met bout à bout.\n" } ], "explanation": "Le même signe `+` additionne des nombres et concatène des chaînes.\nLe type des valeurs décide de l'opération : `\"7\" + \"80\"` donne\n`\"780\"`." } ] }, { "id": "q09", "difficulty": 2, "skills": [ "types", "erreur", "concatenation" ], "title": "Mélanger texte et nombre", "statement": "```python\nage = 15\nprint(\"Âge : \" + age)\n```\n\nQue se passe-t-il ?", "options": [ { "text": "Python affiche `Âge : 15`, l'entier est converti tout seul", "correct": false, "feedback": "Erreur : Python ne convertit pas automatiquement un entier en\nchaîne. Il refuse le `+` entre une chaîne et un entier.\n" }, { "text": "Python signale une erreur, `+` ne colle pas une chaîne et un entier", "correct": true, "feedback": "Bonne réponse : le message est `TypeError`. Il faut écrire\n`\"Âge : \" + str(age)`, ou `print(\"Âge :\", age)`.\n" }, { "text": "Python affiche `Âge : ` puis 15 sur la ligne suivante", "correct": false, "feedback": "Erreur : `+` ne produit pas deux affichages. L'opération est\nrefusée avant tout affichage.\n" }, { "text": "Python affiche `Âge : age`, le nom de la variable", "correct": false, "feedback": "Erreur : sans guillemets, `age` désigne la valeur 15, et\nl'opération entre chaîne et entier échoue.\n" } ], "explanation": "`+` exige deux valeurs de même nature : deux nombres ou deux chaînes.\nPour insérer un nombre dans un texte, on le convertit avec `str`, ou\non passe plusieurs arguments à `print`." }, { "id": "q10", "difficulty": 2, "skills": [ "conversion", "chaine" ], "title": "Convertir pour concaténer", "statement": "`age` vaut 15. Quelle ligne affiche `Âge : 15` sans erreur ?", "options": [ { "text": "`print(\"Âge : \" + str(age))`", "correct": true, "feedback": "Bonne réponse : `str(age)` donne la chaîne `\"15\"`, que l'on peut\ncoller à `\"Âge : \"`.\n" }, { "text": "`print(\"Âge : \" + int(age))`", "correct": false, "feedback": "Erreur : `int(age)` reste un entier, et le `+` entre chaîne et\nentier échoue.\n" }, { "text": "`print(\"Âge : \" + age)`", "correct": false, "feedback": "Erreur : `age` est un entier, la concaténation avec une chaîne\nprovoque une erreur.\n" }, { "text": "`print(\"Âge : \" + float(age))`", "correct": false, "feedback": "Erreur : `float(age)` est un nombre à virgule, toujours pas une\nchaîne.\n" } ], "explanation": "`str` convertit une valeur en chaîne, `int` en entier, `float` en\nflottant. Avant de concaténer un nombre à un texte, on le passe par\n`str`." }, { "id": "q11", "difficulty": 1, "skills": [ "conversion", "entier" ], "title": "De la chaîne au nombre", "statement": "```python\nn = int(\"40\") + 2\nprint(n)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`42`", "correct": true, "feedback": "Bonne réponse : `int(\"40\")` donne l'entier 40, auquel on ajoute\n2.\n" }, { "text": "`402`", "correct": false, "feedback": "Erreur : 402 serait la concaténation de deux chaînes. Ici `int`\na transformé `\"40\"` en nombre avant l'addition.\n" }, { "text": "Une erreur, on n'additionne pas une chaîne et un entier", "correct": false, "feedback": "Erreur : ce serait le cas sans `int`. La conversion rend\nl'addition possible.\n" }, { "text": "`\"42\"`", "correct": false, "feedback": "Erreur : le résultat est un entier, `print` l'affiche sans\nguillemets.\n" } ], "explanation": "`int(\"40\")` lit la chaîne et renvoie l'entier 40. Le résultat d'une\nconversion est un nombre ordinaire, avec lequel on calcule.", "variants": [ { "statement": "```python\nn = int(\"40\") + 2\nprint(n)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`42`", "correct": true, "feedback": "Bonne réponse : `int(\"40\")` donne l'entier 40, auquel on ajoute\n2.\n" }, { "text": "`402`", "correct": false, "feedback": "Erreur : 402 serait la concaténation de deux chaînes. Ici `int`\na transformé `\"40\"` en nombre avant l'addition.\n" }, { "text": "Une erreur, on n'additionne pas une chaîne et un entier", "correct": false, "feedback": "Erreur : ce serait le cas sans `int`. La conversion rend\nl'addition possible.\n" }, { "text": "`\"42\"`", "correct": false, "feedback": "Erreur : le résultat est un entier, `print` l'affiche sans\nguillemets.\n" } ], "explanation": "`int(\"40\")` lit la chaîne et renvoie l'entier 40. Le résultat d'une\nconversion est un nombre ordinaire, avec lequel on calcule." }, { "statement": "```python\nn = int(\"15\") + 7\nprint(n)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`22`", "correct": true, "feedback": "Bonne réponse : `int(\"15\")` donne l'entier 15, auquel on ajoute\n7.\n" }, { "text": "`157`", "correct": false, "feedback": "Erreur : 157 serait la concaténation de deux chaînes. Ici `int`\na transformé `\"15\"` en nombre avant l'addition.\n" }, { "text": "Une erreur, on n'additionne pas une chaîne et un entier", "correct": false, "feedback": "Erreur : ce serait le cas sans `int`. La conversion rend\nl'addition possible.\n" }, { "text": "`\"22\"`", "correct": false, "feedback": "Erreur : le résultat est un entier, `print` l'affiche sans\nguillemets.\n" } ], "explanation": "`int(\"15\")` lit la chaîne et renvoie l'entier 15. Le résultat d'une\nconversion est un nombre ordinaire, avec lequel on calcule." }, { "statement": "```python\nn = int(\"90\") + 5\nprint(n)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`95`", "correct": true, "feedback": "Bonne réponse : `int(\"90\")` donne l'entier 90, auquel on ajoute\n5.\n" }, { "text": "`905`", "correct": false, "feedback": "Erreur : 905 serait la concaténation de deux chaînes. Ici `int`\na transformé `\"90\"` en nombre avant l'addition.\n" }, { "text": "Une erreur, on n'additionne pas une chaîne et un entier", "correct": false, "feedback": "Erreur : ce serait le cas sans `int`. La conversion rend\nl'addition possible.\n" }, { "text": "`\"95\"`", "correct": false, "feedback": "Erreur : le résultat est un entier, `print` l'affiche sans\nguillemets.\n" } ], "explanation": "`int(\"90\")` lit la chaîne et renvoie l'entier 90. Le résultat d'une\nconversion est un nombre ordinaire, avec lequel on calcule." } ] }, { "id": "q12", "difficulty": 2, "skills": [ "conversion", "flottant", "entier" ], "title": "Un flottant converti en entier", "statement": "```python\nprint(int(7.9))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`7`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, il n'arrondit\npas au plus proche.\n" }, { "text": "`8`", "correct": false, "feedback": "Erreur : 8 serait un arrondi. `int` tronque : il garde la partie\nentière 7.\n" }, { "text": "`7.9`", "correct": false, "feedback": "Erreur : `int` renvoie un entier, la partie décimale disparaît.\n" }, { "text": "Une erreur, 7.9 n'est pas un entier", "correct": false, "feedback": "Erreur : `int` accepte un flottant et en garde la partie entière.\n" } ], "explanation": "`int(7.9)` vaut 7 : la conversion vers l'entier supprime les\ndécimales. Pour arrondir au plus proche, on utilise `round`.", "variants": [ { "statement": "```python\nprint(int(7.9))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`7`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, il n'arrondit\npas au plus proche.\n" }, { "text": "`8`", "correct": false, "feedback": "Erreur : 8 serait un arrondi. `int` tronque : il garde la partie\nentière 7.\n" }, { "text": "`7.9`", "correct": false, "feedback": "Erreur : `int` renvoie un entier, la partie décimale disparaît.\n" }, { "text": "Une erreur, 7.9 n'est pas un entier", "correct": false, "feedback": "Erreur : `int` accepte un flottant et en garde la partie entière.\n" } ], "explanation": "`int(7.9)` vaut 7 : la conversion vers l'entier supprime les\ndécimales. Pour arrondir au plus proche, on utilise `round`." }, { "statement": "```python\nprint(int(3.6))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`3`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, il n'arrondit\npas au plus proche.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : 4 serait un arrondi. `int` tronque : il garde la partie\nentière 3.\n" }, { "text": "`3.6`", "correct": false, "feedback": "Erreur : `int` renvoie un entier, la partie décimale disparaît.\n" }, { "text": "Une erreur, 3.6 n'est pas un entier", "correct": false, "feedback": "Erreur : `int` accepte un flottant et en garde la partie entière.\n" } ], "explanation": "`int(3.6)` vaut 3 : la conversion vers l'entier supprime les\ndécimales. Pour arrondir au plus proche, on utilise `round`." }, { "statement": "```python\nprint(int(12.7))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`12`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, il n'arrondit\npas au plus proche.\n" }, { "text": "`13`", "correct": false, "feedback": "Erreur : 13 serait un arrondi. `int` tronque : il garde la partie\nentière 12.\n" }, { "text": "`12.7`", "correct": false, "feedback": "Erreur : `int` renvoie un entier, la partie décimale disparaît.\n" }, { "text": "Une erreur, 12.7 n'est pas un entier", "correct": false, "feedback": "Erreur : `int` accepte un flottant et en garde la partie entière.\n" } ], "explanation": "`int(12.7)` vaut 12 : la conversion vers l'entier supprime les\ndécimales. Pour arrondir au plus proche, on utilise `round`." } ] }, { "id": "q13", "difficulty": 2, "skills": [ "booleens", "comparaison" ], "title": "Le résultat d'une comparaison", "statement": "```python\nx = 10\nprint(x > 3)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`True`", "correct": true, "feedback": "Bonne réponse : une comparaison produit un booléen. Comme 10 est\nplus grand que 3, elle vaut `True`.\n" }, { "text": "`10`", "correct": false, "feedback": "Erreur : `print` affiche le résultat de la comparaison, pas la\nvaleur de `x`.\n" }, { "text": "`x > 3`", "correct": false, "feedback": "Erreur : sans guillemets, `x > 3` est évalué, pas affiché tel\nquel.\n" }, { "text": "Une erreur, on ne peut pas afficher une comparaison", "correct": false, "feedback": "Erreur : une comparaison est une valeur comme une autre, un\nbooléen, que `print` affiche.\n" } ], "explanation": "Une comparaison est un calcul dont le résultat est un booléen, `True`\nou `False`. On peut l'afficher, le ranger dans une variable ou s'en\nservir dans une condition." }, { "id": "q14", "difficulty": 2, "skills": [ "operateurs", "flottant" ], "title": "Une division qui tombe juste", "statement": "```python\nprint(8 / 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`4.0`", "correct": true, "feedback": "Bonne réponse : `/` renvoie toujours un flottant, même quand la\ndivision est exacte.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : 4 serait le résultat de `8 // 2`. La division `/` donne\nun flottant, affiché `4.0`.\n" }, { "text": "`4,0`", "correct": false, "feedback": "Erreur : Python écrit les décimales avec un point, jamais avec\nune virgule.\n" }, { "text": "`04`", "correct": false, "feedback": "Erreur : le résultat est le flottant 4.0.\n" } ], "explanation": "Il existe deux divisions : `/` renvoie un flottant, `//` un quotient\nentier. `8 / 2` vaut `4.0` et `8 // 2` vaut `4`.", "variants": [ { "statement": "```python\nprint(8 / 2)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`4.0`", "correct": true, "feedback": "Bonne réponse : `/` renvoie toujours un flottant, même quand la\ndivision est exacte.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : 4 serait le résultat de `8 // 2`. La division `/` donne\nun flottant, affiché `4.0`.\n" }, { "text": "`4,0`", "correct": false, "feedback": "Erreur : Python écrit les décimales avec un point, jamais avec\nune virgule.\n" }, { "text": "`04`", "correct": false, "feedback": "Erreur : le résultat est le flottant 4.0.\n" } ], "explanation": "Il existe deux divisions : `/` renvoie un flottant, `//` un quotient\nentier. `8 / 2` vaut `4.0` et `8 // 2` vaut `4`." }, { "statement": "```python\nprint(9 / 3)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`3.0`", "correct": true, "feedback": "Bonne réponse : `/` renvoie toujours un flottant, même quand la\ndivision est exacte.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 serait le résultat de `9 // 3`. La division `/` donne\nun flottant, affiché `3.0`.\n" }, { "text": "`3,0`", "correct": false, "feedback": "Erreur : Python écrit les décimales avec un point, jamais avec\nune virgule.\n" }, { "text": "`03`", "correct": false, "feedback": "Erreur : le résultat est le flottant 3.0.\n" } ], "explanation": "Il existe deux divisions : `/` renvoie un flottant, `//` un quotient\nentier. `9 / 3` vaut `3.0` et `9 // 3` vaut `3`." }, { "statement": "```python\nprint(10 / 5)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`2.0`", "correct": true, "feedback": "Bonne réponse : `/` renvoie toujours un flottant, même quand la\ndivision est exacte.\n" }, { "text": "`2`", "correct": false, "feedback": "Erreur : 2 serait le résultat de `10 // 5`. La division `/` donne\nun flottant, affiché `2.0`.\n" }, { "text": "`2,0`", "correct": false, "feedback": "Erreur : Python écrit les décimales avec un point, jamais avec\nune virgule.\n" }, { "text": "`02`", "correct": false, "feedback": "Erreur : le résultat est le flottant 2.0.\n" } ], "explanation": "Il existe deux divisions : `/` renvoie un flottant, `//` un quotient\nentier. `10 / 5` vaut `2.0` et `10 // 5` vaut `2`." } ] }, { "id": "q15", "difficulty": 3, "skills": [ "division-entiere", "modulo", "calcul" ], "title": "Convertir des secondes", "statement": "```python\nduree = 125\nminutes = duree // 60\nsecondes = duree % 60\nprint(minutes, secondes)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`2 5`", "correct": true, "feedback": "Bonne réponse : 125 secondes font 2 minutes entières, et il\nreste 5 secondes.\n" }, { "text": "`2.08 5`", "correct": false, "feedback": "Erreur : `//` donne un quotient entier, sans décimales.\n" }, { "text": "`2 05`", "correct": false, "feedback": "Erreur : le reste est le nombre 5, affiché sans zéro devant.\n" }, { "text": "`2 25`", "correct": false, "feedback": "Erreur : 2 minutes font 120 secondes, il en reste 5, pas\n25 ; une minute ne fait pas cent secondes.\n" } ], "explanation": "Le couple quotient et reste convertit une durée : `//` donne les\nminutes entières, `%` les secondes restantes. C'est le même calcul\npour les heures, les jours ou les paquets.", "variants": [ { "statement": "```python\nduree = 125\nminutes = duree // 60\nsecondes = duree % 60\nprint(minutes, secondes)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`2 5`", "correct": true, "feedback": "Bonne réponse : 125 secondes font 2 minutes entières, et il\nreste 5 secondes.\n" }, { "text": "`2.08 5`", "correct": false, "feedback": "Erreur : `//` donne un quotient entier, sans décimales.\n" }, { "text": "`2 05`", "correct": false, "feedback": "Erreur : le reste est le nombre 5, affiché sans zéro devant.\n" }, { "text": "`2 25`", "correct": false, "feedback": "Erreur : 2 minutes font 120 secondes, il en reste 5, pas\n25 ; une minute ne fait pas cent secondes.\n" } ], "explanation": "Le couple quotient et reste convertit une durée : `//` donne les\nminutes entières, `%` les secondes restantes. C'est le même calcul\npour les heures, les jours ou les paquets." }, { "statement": "```python\nduree = 185\nminutes = duree // 60\nsecondes = duree % 60\nprint(minutes, secondes)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`3 5`", "correct": true, "feedback": "Bonne réponse : 185 secondes font 3 minutes entières, et il\nreste 5 secondes.\n" }, { "text": "`3.08 5`", "correct": false, "feedback": "Erreur : `//` donne un quotient entier, sans décimales.\n" }, { "text": "`3 05`", "correct": false, "feedback": "Erreur : le reste est le nombre 5, affiché sans zéro devant.\n" }, { "text": "`3 85`", "correct": false, "feedback": "Erreur : 3 minutes font 180 secondes, il en reste 5, pas\n85 ; une minute ne fait pas cent secondes.\n" } ], "explanation": "Le couple quotient et reste convertit une durée : `//` donne les\nminutes entières, `%` les secondes restantes. C'est le même calcul\npour les heures, les jours ou les paquets." }, { "statement": "```python\nduree = 247\nminutes = duree // 60\nsecondes = duree % 60\nprint(minutes, secondes)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`4 7`", "correct": true, "feedback": "Bonne réponse : 247 secondes font 4 minutes entières, et il\nreste 7 secondes.\n" }, { "text": "`4.12 7`", "correct": false, "feedback": "Erreur : `//` donne un quotient entier, sans décimales.\n" }, { "text": "`4 07`", "correct": false, "feedback": "Erreur : le reste est le nombre 7, affiché sans zéro devant.\n" }, { "text": "`4 47`", "correct": false, "feedback": "Erreur : 4 minutes font 240 secondes, il en reste 7, pas\n47 ; une minute ne fait pas cent secondes.\n" } ], "explanation": "Le couple quotient et reste convertit une durée : `//` donne les\nminutes entières, `%` les secondes restantes. C'est le même calcul\npour les heures, les jours ou les paquets." } ] }, { "id": "q16", "difficulty": 2, "skills": [ "chaine", "len" ], "title": "Longueur d'une chaîne", "statement": "```python\nmot = \"SNT 2026\"\nprint(len(mot))\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`8`", "correct": true, "feedback": "Bonne réponse : trois lettres, une espace et quatre chiffres\nfont huit caractères.\n" }, { "text": "`7`", "correct": false, "feedback": "Erreur : l'espace est un caractère comme un autre, il compte.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : `len` compte les caractères, pas les lettres du premier\nmot.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : `len` ne compte pas seulement les chiffres.\n" } ], "explanation": "`len` renvoie le nombre de caractères d'une chaîne, espaces compris.\nOn la retrouvera pour compter les éléments d'une liste." }, { "id": "q17", "difficulty": 3, "skills": [ "concatenation", "priorite", "chaine" ], "title": "Répéter une chaîne", "statement": "```python\nprint(\"ab\" * 3 + \"c\")\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`abababc`", "correct": true, "feedback": "Bonne réponse : `*` répète la chaîne trois fois, puis `+` colle\n`c` à la fin. La multiplication passe avant l'addition.\n" }, { "text": "`ababab c`", "correct": false, "feedback": "Erreur : la concaténation n'ajoute aucune espace.\n" }, { "text": "`abcabcabc`", "correct": false, "feedback": "Erreur : ce serait `(\"ab\" + \"c\") * 3`. Sans parenthèses, la\nrépétition est faite d'abord.\n" }, { "text": "Une erreur, on ne multiplie pas une chaîne", "correct": false, "feedback": "Erreur : entre une chaîne et un entier, `*` répète la chaîne.\n" } ], "explanation": "Entre une chaîne et un entier, `*` répète le texte. Les priorités\nsont les mêmes qu'avec les nombres : `*` avant `+`." }, { "id": "q18", "difficulty": 3, "skills": [ "types", "conversion", "trace" ], "title": "Deux conversions successives", "statement": "```python\nx = \"7\"\ny = int(x) * 2\nz = str(y) + \"0\"\nprint(z)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`140`", "correct": true, "feedback": "Bonne réponse : `y` vaut l'entier 14, puis `str(y)` donne\n`\"14\"`, collé à `\"0\"`.\n" }, { "text": "`14`", "correct": false, "feedback": "Erreur : 14 est `y`. La dernière ligne lui colle encore le\ncaractère `0`.\n" }, { "text": "`770`", "correct": false, "feedback": "Erreur : 770 supposerait que `\"7\" * 2` répète la chaîne. Mais\n`int(x)` en a fait un nombre avant la multiplication.\n" }, { "text": "`7070`", "correct": false, "feedback": "Erreur : la multiplication porte sur l'entier 7, pas sur la\nchaîne.\n" } ], "explanation": "Suivre le type de chaque variable est aussi important que sa valeur :\n`x` est une chaîne, `y` un entier, `z` une chaîne. Chaque conversion\nchange l'effet des opérateurs.", "variants": [ { "statement": "```python\nx = \"7\"\ny = int(x) * 2\nz = str(y) + \"0\"\nprint(z)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`140`", "correct": true, "feedback": "Bonne réponse : `y` vaut l'entier 14, puis `str(y)` donne\n`\"14\"`, collé à `\"0\"`.\n" }, { "text": "`14`", "correct": false, "feedback": "Erreur : 14 est `y`. La dernière ligne lui colle encore le\ncaractère `0`.\n" }, { "text": "`770`", "correct": false, "feedback": "Erreur : 770 supposerait que `\"7\" * 2` répète la chaîne. Mais\n`int(x)` en a fait un nombre avant la multiplication.\n" }, { "text": "`7070`", "correct": false, "feedback": "Erreur : la multiplication porte sur l'entier 7, pas sur la\nchaîne.\n" } ], "explanation": "Suivre le type de chaque variable est aussi important que sa valeur :\n`x` est une chaîne, `y` un entier, `z` une chaîne. Chaque conversion\nchange l'effet des opérateurs." }, { "statement": "```python\nx = \"4\"\ny = int(x) * 3\nz = str(y) + \"0\"\nprint(z)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`120`", "correct": true, "feedback": "Bonne réponse : `y` vaut l'entier 12, puis `str(y)` donne\n`\"12\"`, collé à `\"0\"`.\n" }, { "text": "`12`", "correct": false, "feedback": "Erreur : 12 est `y`. La dernière ligne lui colle encore le\ncaractère `0`.\n" }, { "text": "`4440`", "correct": false, "feedback": "Erreur : 4440 supposerait que `\"4\" * 3` répète la chaîne. Mais\n`int(x)` en a fait un nombre avant la multiplication.\n" }, { "text": "`404040`", "correct": false, "feedback": "Erreur : la multiplication porte sur l'entier 4, pas sur la\nchaîne.\n" } ], "explanation": "Suivre le type de chaque variable est aussi important que sa valeur :\n`x` est une chaîne, `y` un entier, `z` une chaîne. Chaque conversion\nchange l'effet des opérateurs." }, { "statement": "```python\nx = \"9\"\ny = int(x) * 5\nz = str(y) + \"0\"\nprint(z)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`450`", "correct": true, "feedback": "Bonne réponse : `y` vaut l'entier 45, puis `str(y)` donne\n`\"45\"`, collé à `\"0\"`.\n" }, { "text": "`45`", "correct": false, "feedback": "Erreur : 45 est `y`. La dernière ligne lui colle encore le\ncaractère `0`.\n" }, { "text": "`999990`", "correct": false, "feedback": "Erreur : 999990 supposerait que `\"9\" * 5` répète la chaîne. Mais\n`int(x)` en a fait un nombre avant la multiplication.\n" }, { "text": "`9090909090`", "correct": false, "feedback": "Erreur : la multiplication porte sur l'entier 9, pas sur la\nchaîne.\n" } ], "explanation": "Suivre le type de chaque variable est aussi important que sa valeur :\n`x` est une chaîne, `y` un entier, `z` une chaîne. Chaque conversion\nchange l'effet des opérateurs." } ] }, { "id": "q19", "difficulty": 3, "skills": [ "flottant", "calcul", "priorite" ], "title": "Une moyenne mal écrite", "statement": "```python\na = 12\nb = 15\nmoyenne = a + b / 2\nprint(moyenne)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`19.5`", "correct": true, "feedback": "Bonne réponse : la division passe avant l'addition, donc Python\ncalcule 12 plus 7.5. Il manquait des parenthèses.\n" }, { "text": "`13.5`", "correct": false, "feedback": "Erreur : 13.5 est la moyenne attendue, mais il faudrait écrire\n`(a + b) / 2`.\n" }, { "text": "`13`", "correct": false, "feedback": "Erreur : ni les parenthèses ni la division entière ne sont là.\n" }, { "text": "`27`", "correct": false, "feedback": "Erreur : 27 est la somme seule, or une division a bien lieu, sur\n`b`.\n" } ], "explanation": "Sans parenthèses, `a + b / 2` divise seulement `b`. Une moyenne\ns'écrit `(a + b) / 2`. Toujours vérifier les priorités quand un\nrésultat surprend.", "variants": [ { "statement": "```python\na = 12\nb = 15\nmoyenne = a + b / 2\nprint(moyenne)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`19.5`", "correct": true, "feedback": "Bonne réponse : la division passe avant l'addition, donc Python\ncalcule 12 plus 7.5. Il manquait des parenthèses.\n" }, { "text": "`13.5`", "correct": false, "feedback": "Erreur : 13.5 est la moyenne attendue, mais il faudrait écrire\n`(a + b) / 2`.\n" }, { "text": "`13`", "correct": false, "feedback": "Erreur : ni les parenthèses ni la division entière ne sont là.\n" }, { "text": "`27`", "correct": false, "feedback": "Erreur : 27 est la somme seule, or une division a bien lieu, sur\n`b`.\n" } ], "explanation": "Sans parenthèses, `a + b / 2` divise seulement `b`. Une moyenne\ns'écrit `(a + b) / 2`. Toujours vérifier les priorités quand un\nrésultat surprend." }, { "statement": "```python\na = 8\nb = 13\nmoyenne = a + b / 2\nprint(moyenne)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`14.5`", "correct": true, "feedback": "Bonne réponse : la division passe avant l'addition, donc Python\ncalcule 8 plus 6.5. Il manquait des parenthèses.\n" }, { "text": "`10.5`", "correct": false, "feedback": "Erreur : 10.5 est la moyenne attendue, mais il faudrait écrire\n`(a + b) / 2`.\n" }, { "text": "`10`", "correct": false, "feedback": "Erreur : ni les parenthèses ni la division entière ne sont là.\n" }, { "text": "`21`", "correct": false, "feedback": "Erreur : 21 est la somme seule, or une division a bien lieu, sur\n`b`.\n" } ], "explanation": "Sans parenthèses, `a + b / 2` divise seulement `b`. Une moyenne\ns'écrit `(a + b) / 2`. Toujours vérifier les priorités quand un\nrésultat surprend." }, { "statement": "```python\na = 16\nb = 9\nmoyenne = a + b / 2\nprint(moyenne)\n```\n\nQu'affiche ce programme ?", "options": [ { "text": "`20.5`", "correct": true, "feedback": "Bonne réponse : la division passe avant l'addition, donc Python\ncalcule 16 plus 4.5. Il manquait des parenthèses.\n" }, { "text": "`12.5`", "correct": false, "feedback": "Erreur : 12.5 est la moyenne attendue, mais il faudrait écrire\n`(a + b) / 2`.\n" }, { "text": "`12`", "correct": false, "feedback": "Erreur : ni les parenthèses ni la division entière ne sont là.\n" }, { "text": "`25`", "correct": false, "feedback": "Erreur : 25 est la somme seule, or une division a bien lieu, sur\n`b`.\n" } ], "explanation": "Sans parenthèses, `a + b / 2` divise seulement `b`. Une moyenne\ns'écrit `(a + b) / 2`. Toujours vérifier les priorités quand un\nrésultat surprend." } ] }, { "id": "q20", "difficulty": 1, "skills": [ "types", "booleens" ], "title": "Reconnaître un booléen", "statement": "Laquelle de ces valeurs est un booléen ?", "options": [ { "text": "`True`", "correct": true, "feedback": "Bonne réponse : `True` et `False`, avec la majuscule, sont les\ndeux seules valeurs du type `bool`.\n" }, { "text": "`\"True\"`", "correct": false, "feedback": "Erreur : entre guillemets, c'est une chaîne de quatre lettres.\n" }, { "text": "`1`", "correct": false, "feedback": "Erreur : `1` est un entier. Il se comporte parfois comme `True`,\nmais son type est `int`.\n" }, { "text": "`vrai`", "correct": false, "feedback": "Erreur : sans guillemets, `vrai` serait un nom de variable, et\nPython n'a pas de mot-clé `vrai`.\n" } ], "explanation": "Le type `bool` n'a que deux valeurs, `True` et `False`, écrites avec\nune majuscule. Elles résultent des comparaisons et pilotent les\nconditions." }, { "id": "q21", "difficulty": 1, "skills": [ "type", "float", "int" ], "title": "Le type d'un nombre à virgule", "statement": "Que renvoie `type(3.0)` ?", "options": [ { "text": "``, à cause du point décimal", "correct": true, "feedback": "Bonne réponse : `3.0` s'écrit avec un point décimal, c'est donc\nun flottant, même si sa valeur est entière.\n" }, { "text": "``, car sa valeur est entière", "correct": false, "feedback": "Erreur : le type dépend de l'écriture, pas de la valeur. `3` est\nun entier, `3.0` un flottant.\n" }, { "text": "``, car il contient un point", "correct": false, "feedback": "Erreur : une chaîne s'écrit entre guillemets. Sans guillemets,\n`3.0` est un nombre.\n" }, { "text": "Une erreur, `3.0` n'étant pas une écriture valide", "correct": false, "feedback": "Erreur : `3.0` est une écriture tout à fait valide d'un\nflottant.\n" } ], "explanation": "`int` et `float` sont deux types distincts : le point décimal fait\nla différence, pas la valeur." }, { "id": "q22", "difficulty": 1, "skills": [ "modulo", "reste" ], "title": "Le reste d'une division", "statement": "Que vaut `10 % 3` ?", "options": [ { "text": "`1`", "correct": true, "feedback": "Bonne réponse : `%` donne le reste de la division entière. 3\nentre 3 fois dans 10, et il reste 1.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 est le quotient entier, donné par `//`.\n" }, { "text": "`3.3333333333333335`", "correct": false, "feedback": "Erreur : 3.3333333333333335 est le résultat de la division `/`, pas le reste.\n" }, { "text": "`10`", "correct": false, "feedback": "Erreur : le reste est toujours plus petit que le diviseur 3.\n" } ], "explanation": "`//` et `%` décomposent une division : quotient entier d'un côté,\nreste de l'autre. Ici 10 = 3 × 3 + 1.", "variants": [ { "statement": "Que vaut `10 % 3` ?", "options": [ { "text": "`1`", "correct": true, "feedback": "Bonne réponse : `%` donne le reste de la division entière. 3\nentre 3 fois dans 10, et il reste 1.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 est le quotient entier, donné par `//`.\n" }, { "text": "`3.3333333333333335`", "correct": false, "feedback": "Erreur : 3.3333333333333335 est le résultat de la division `/`, pas le reste.\n" }, { "text": "`10`", "correct": false, "feedback": "Erreur : le reste est toujours plus petit que le diviseur 3.\n" } ], "explanation": "`//` et `%` décomposent une division : quotient entier d'un côté,\nreste de l'autre. Ici 10 = 3 × 3 + 1." }, { "statement": "Que vaut `17 % 5` ?", "options": [ { "text": "`2`", "correct": true, "feedback": "Bonne réponse : `%` donne le reste de la division entière. 5\nentre 3 fois dans 17, et il reste 2.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 est le quotient entier, donné par `//`.\n" }, { "text": "`3.4`", "correct": false, "feedback": "Erreur : 3.4 est le résultat de la division `/`, pas le reste.\n" }, { "text": "`17`", "correct": false, "feedback": "Erreur : le reste est toujours plus petit que le diviseur 5.\n" } ], "explanation": "`//` et `%` décomposent une division : quotient entier d'un côté,\nreste de l'autre. Ici 17 = 5 × 3 + 2." }, { "statement": "Que vaut `23 % 6` ?", "options": [ { "text": "`5`", "correct": true, "feedback": "Bonne réponse : `%` donne le reste de la division entière. 6\nentre 3 fois dans 23, et il reste 5.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 est le quotient entier, donné par `//`.\n" }, { "text": "`3.8333333333333335`", "correct": false, "feedback": "Erreur : 3.8333333333333335 est le résultat de la division `/`, pas le reste.\n" }, { "text": "`23`", "correct": false, "feedback": "Erreur : le reste est toujours plus petit que le diviseur 6.\n" } ], "explanation": "`//` et `%` décomposent une division : quotient entier d'un côté,\nreste de l'autre. Ici 23 = 6 × 3 + 5." } ] }, { "id": "q23", "difficulty": 1, "skills": [ "conversion", "int", "addition" ], "title": "Une chaîne convertie puis additionnée", "statement": "Que vaut `int(\"12\") + 3` ?", "options": [ { "text": "`15`", "correct": true, "feedback": "Bonne réponse : `int(\"12\")` transforme la chaîne en l'entier\n12, qui s'additionne normalement avec 3.\n" }, { "text": "`123`", "correct": false, "feedback": "Erreur : après conversion en entier, `+` additionne, il ne colle\nplus les chiffres.\n" }, { "text": "`'123'`", "correct": false, "feedback": "Erreur : le résultat est un entier, pas une chaîne.\n" }, { "text": "Une erreur, une chaîne ne pouvant être additionnée à un nombre", "correct": false, "feedback": "Erreur : c'est précisément le rôle de `int` d'éviter cette\nerreur en convertissant la chaîne avant l'addition.\n" } ], "explanation": "`int` convertit une chaîne de chiffres en entier. Après conversion,\nles opérations sont celles des nombres.", "variants": [ { "statement": "Que vaut `int(\"12\") + 3` ?", "options": [ { "text": "`15`", "correct": true, "feedback": "Bonne réponse : `int(\"12\")` transforme la chaîne en l'entier\n12, qui s'additionne normalement avec 3.\n" }, { "text": "`123`", "correct": false, "feedback": "Erreur : après conversion en entier, `+` additionne, il ne colle\nplus les chiffres.\n" }, { "text": "`'123'`", "correct": false, "feedback": "Erreur : le résultat est un entier, pas une chaîne.\n" }, { "text": "Une erreur, une chaîne ne pouvant être additionnée à un nombre", "correct": false, "feedback": "Erreur : c'est précisément le rôle de `int` d'éviter cette\nerreur en convertissant la chaîne avant l'addition.\n" } ], "explanation": "`int` convertit une chaîne de chiffres en entier. Après conversion,\nles opérations sont celles des nombres." }, { "statement": "Que vaut `int(\"40\") + 2` ?", "options": [ { "text": "`42`", "correct": true, "feedback": "Bonne réponse : `int(\"40\")` transforme la chaîne en l'entier\n40, qui s'additionne normalement avec 2.\n" }, { "text": "`402`", "correct": false, "feedback": "Erreur : après conversion en entier, `+` additionne, il ne colle\nplus les chiffres.\n" }, { "text": "`'402'`", "correct": false, "feedback": "Erreur : le résultat est un entier, pas une chaîne.\n" }, { "text": "Une erreur, une chaîne ne pouvant être additionnée à un nombre", "correct": false, "feedback": "Erreur : c'est précisément le rôle de `int` d'éviter cette\nerreur en convertissant la chaîne avant l'addition.\n" } ], "explanation": "`int` convertit une chaîne de chiffres en entier. Après conversion,\nles opérations sont celles des nombres." }, { "statement": "Que vaut `int(\"7\") + 9` ?", "options": [ { "text": "`16`", "correct": true, "feedback": "Bonne réponse : `int(\"7\")` transforme la chaîne en l'entier\n7, qui s'additionne normalement avec 9.\n" }, { "text": "`79`", "correct": false, "feedback": "Erreur : après conversion en entier, `+` additionne, il ne colle\nplus les chiffres.\n" }, { "text": "`'79'`", "correct": false, "feedback": "Erreur : le résultat est un entier, pas une chaîne.\n" }, { "text": "Une erreur, une chaîne ne pouvant être additionnée à un nombre", "correct": false, "feedback": "Erreur : c'est précisément le rôle de `int` d'éviter cette\nerreur en convertissant la chaîne avant l'addition.\n" } ], "explanation": "`int` convertit une chaîne de chiffres en entier. Après conversion,\nles opérations sont celles des nombres." } ] }, { "id": "q24", "difficulty": 2, "skills": [ "conversion", "float", "erreur" ], "title": "Une virgule qui gêne la conversion", "statement": "Que produit `float(\"3,5\")` ?", "options": [ { "text": "Une erreur, le point décimal étant obligatoire", "correct": true, "feedback": "Bonne réponse : pour Python, `\"3,5\"` n'est pas l'écriture d'un\nnombre. Seul `\"3.5\"` se convertit en flottant.\n" }, { "text": "`3.5`, la virgule étant acceptée comme séparateur", "correct": false, "feedback": "Erreur : la conversion échoue à cause de la virgule. Il faudrait\nla chaîne `\"3.5\"`.\n" }, { "text": "`35`, la virgule étant simplement ignorée", "correct": false, "feedback": "Erreur : Python ne supprime pas la virgule, il refuse la\nchaîne.\n" }, { "text": "`3`, la partie après la virgule étant tronquée", "correct": false, "feedback": "Erreur : rien n'est tronqué, la conversion n'a pas lieu du tout.\n" } ], "explanation": "En Python, le séparateur décimal est le point. Une saisie française\navec virgule doit être transformée avant conversion." }, { "id": "q25", "difficulty": 2, "skills": [ "arrondi", "round", "float" ], "title": "Un arrondi", "statement": "Que vaut `round(3.7)` ?", "options": [ { "text": "`4`", "correct": true, "feedback": "Bonne réponse : `round` arrondit à l'entier le plus proche et\nrenvoie un entier.\n" }, { "text": "`4.0`", "correct": false, "feedback": "Erreur : sans second argument, `round` renvoie un entier, pas\nun flottant.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 serait le résultat de `int(3.7)`, qui coupe la\npartie décimale au lieu d'arrondir.\n" }, { "text": "`3.7`", "correct": false, "feedback": "Erreur : `round` change la valeur dès qu'il y a une partie\ndécimale.\n" } ], "explanation": "`round` arrondit, `int` tronque. Les deux ne donnent pas toujours\nle même résultat.", "variants": [ { "statement": "Que vaut `round(3.7)` ?", "options": [ { "text": "`4`", "correct": true, "feedback": "Bonne réponse : `round` arrondit à l'entier le plus proche et\nrenvoie un entier.\n" }, { "text": "`4.0`", "correct": false, "feedback": "Erreur : sans second argument, `round` renvoie un entier, pas\nun flottant.\n" }, { "text": "`3`", "correct": false, "feedback": "Erreur : 3 serait le résultat de `int(3.7)`, qui coupe la\npartie décimale au lieu d'arrondir.\n" }, { "text": "`3.7`", "correct": false, "feedback": "Erreur : `round` change la valeur dès qu'il y a une partie\ndécimale.\n" } ], "explanation": "`round` arrondit, `int` tronque. Les deux ne donnent pas toujours\nle même résultat." }, { "statement": "Que vaut `round(8.6)` ?", "options": [ { "text": "`9`", "correct": true, "feedback": "Bonne réponse : `round` arrondit à l'entier le plus proche et\nrenvoie un entier.\n" }, { "text": "`9.0`", "correct": false, "feedback": "Erreur : sans second argument, `round` renvoie un entier, pas\nun flottant.\n" }, { "text": "`8`", "correct": false, "feedback": "Erreur : 8 serait le résultat de `int(8.6)`, qui coupe la\npartie décimale au lieu d'arrondir.\n" }, { "text": "`8.6`", "correct": false, "feedback": "Erreur : `round` change la valeur dès qu'il y a une partie\ndécimale.\n" } ], "explanation": "`round` arrondit, `int` tronque. Les deux ne donnent pas toujours\nle même résultat." }, { "statement": "Que vaut `round(5.5)` ?", "options": [ { "text": "`6`", "correct": true, "feedback": "Bonne réponse : `round` arrondit à l'entier le plus proche et\nrenvoie un entier.\n" }, { "text": "`6.0`", "correct": false, "feedback": "Erreur : sans second argument, `round` renvoie un entier, pas\nun flottant.\n" }, { "text": "`5`", "correct": false, "feedback": "Erreur : 5 serait le résultat de `int(5.5)`, qui coupe la\npartie décimale au lieu d'arrondir.\n" }, { "text": "`5.5`", "correct": false, "feedback": "Erreur : `round` change la valeur dès qu'il y a une partie\ndécimale.\n" } ], "explanation": "`round` arrondit, `int` tronque. Les deux ne donnent pas toujours\nle même résultat." } ] }, { "id": "q26", "difficulty": 2, "skills": [ "comparaison", "type", "egalite" ], "title": "Une chaîne comparée à un nombre", "statement": "Que vaut `\"5\" == 5` ?", "options": [ { "text": "`False`, les types étant différents", "correct": true, "feedback": "Bonne réponse : `\"5\"` est un texte, 5 un nombre. Deux valeurs\nde types différents ne sont jamais égales, même si elles se\nressemblent.\n" }, { "text": "`True`, les deux écritures désignant cinq", "correct": false, "feedback": "Erreur : Python ne convertit pas les types pour comparer. Le\ntexte `\"5\"` et le nombre 5 restent différents.\n" }, { "text": "Une erreur, les types étant incompatibles", "correct": false, "feedback": "Erreur : la comparaison est permise, elle répond simplement\n`False`.\n" }, { "text": "`5`, la valeur commune aux deux écritures", "correct": false, "feedback": "Erreur : une comparaison renvoie un booléen, `True` ou `False`.\n" } ], "explanation": "L'égalité tient compte du type. C'est pourquoi une saisie, toujours\nune chaîne, doit être convertie avant d'être comparée à un nombre." }, { "id": "q27", "difficulty": 2, "skills": [ "str", "len", "conversion" ], "title": "Compter les chiffres d'un nombre", "statement": "Que vaut `len(str(1234))` ?", "options": [ { "text": "`4`", "correct": true, "feedback": "Bonne réponse : `str(1234)` donne la chaîne `\"1234\"`, dont `len`\ncompte les caractères, c'est-à-dire les chiffres.\n" }, { "text": "`1234`", "correct": false, "feedback": "Erreur : `len` ne renvoie pas le nombre lui-même mais sa\nlongueur une fois écrit.\n" }, { "text": "Une erreur, `len` ne s'appliquant pas aux nombres", "correct": false, "feedback": "Erreur : c'est vrai pour un entier, mais `str` l'a d'abord\ntransformé en chaîne.\n" }, { "text": "`1`", "correct": false, "feedback": "Erreur : la chaîne contient autant de caractères que le nombre\na de chiffres.\n" } ], "explanation": "Convertir un nombre en chaîne permet de le traiter comme du texte :\ncompter ses chiffres, lire le premier, et ainsi de suite.", "variants": [ { "statement": "Que vaut `len(str(1234))` ?", "options": [ { "text": "`4`", "correct": true, "feedback": "Bonne réponse : `str(1234)` donne la chaîne `\"1234\"`, dont `len`\ncompte les caractères, c'est-à-dire les chiffres.\n" }, { "text": "`1234`", "correct": false, "feedback": "Erreur : `len` ne renvoie pas le nombre lui-même mais sa\nlongueur une fois écrit.\n" }, { "text": "Une erreur, `len` ne s'appliquant pas aux nombres", "correct": false, "feedback": "Erreur : c'est vrai pour un entier, mais `str` l'a d'abord\ntransformé en chaîne.\n" }, { "text": "`1`", "correct": false, "feedback": "Erreur : la chaîne contient autant de caractères que le nombre\na de chiffres.\n" } ], "explanation": "Convertir un nombre en chaîne permet de le traiter comme du texte :\ncompter ses chiffres, lire le premier, et ainsi de suite." }, { "statement": "Que vaut `len(str(98))` ?", "options": [ { "text": "`2`", "correct": true, "feedback": "Bonne réponse : `str(98)` donne la chaîne `\"98\"`, dont `len`\ncompte les caractères, c'est-à-dire les chiffres.\n" }, { "text": "`98`", "correct": false, "feedback": "Erreur : `len` ne renvoie pas le nombre lui-même mais sa\nlongueur une fois écrit.\n" }, { "text": "Une erreur, `len` ne s'appliquant pas aux nombres", "correct": false, "feedback": "Erreur : c'est vrai pour un entier, mais `str` l'a d'abord\ntransformé en chaîne.\n" }, { "text": "`1`", "correct": false, "feedback": "Erreur : la chaîne contient autant de caractères que le nombre\na de chiffres.\n" } ], "explanation": "Convertir un nombre en chaîne permet de le traiter comme du texte :\ncompter ses chiffres, lire le premier, et ainsi de suite." }, { "statement": "Que vaut `len(str(500000))` ?", "options": [ { "text": "`6`", "correct": true, "feedback": "Bonne réponse : `str(500000)` donne la chaîne `\"500000\"`, dont `len`\ncompte les caractères, c'est-à-dire les chiffres.\n" }, { "text": "`500000`", "correct": false, "feedback": "Erreur : `len` ne renvoie pas le nombre lui-même mais sa\nlongueur une fois écrit.\n" }, { "text": "Une erreur, `len` ne s'appliquant pas aux nombres", "correct": false, "feedback": "Erreur : c'est vrai pour un entier, mais `str` l'a d'abord\ntransformé en chaîne.\n" }, { "text": "`1`", "correct": false, "feedback": "Erreur : la chaîne contient autant de caractères que le nombre\na de chiffres.\n" } ], "explanation": "Convertir un nombre en chaîne permet de le traiter comme du texte :\ncompter ses chiffres, lire le premier, et ainsi de suite." } ] }, { "id": "q28", "difficulty": 3, "skills": [ "int", "troncature", "negatif" ], "title": "Un flottant négatif converti en entier", "statement": "Que vaut `int(-3.7)` ?", "options": [ { "text": "`-3`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, sans\narrondir. Pour un négatif, cela rapproche de zéro.\n" }, { "text": "`-4`", "correct": false, "feedback": "Erreur : -4 serait l'entier inférieur. `int` ne descend pas, il\ncoupe les décimales.\n" }, { "text": "`-3.7`", "correct": false, "feedback": "Erreur : `int` renvoie toujours un entier.\n" }, { "text": "Une erreur, `int` ne s'appliquant pas aux négatifs", "correct": false, "feedback": "Erreur : `int` accepte tout flottant, positif ou négatif.\n" } ], "explanation": "`int` tronque vers zéro : `int(3.7)` donne `3` et `int(-3.7)` donne\n`-3`. Pour arrondir, on utilise `round`.", "variants": [ { "statement": "Que vaut `int(-3.7)` ?", "options": [ { "text": "`-3`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, sans\narrondir. Pour un négatif, cela rapproche de zéro.\n" }, { "text": "`-4`", "correct": false, "feedback": "Erreur : -4 serait l'entier inférieur. `int` ne descend pas, il\ncoupe les décimales.\n" }, { "text": "`-3.7`", "correct": false, "feedback": "Erreur : `int` renvoie toujours un entier.\n" }, { "text": "Une erreur, `int` ne s'appliquant pas aux négatifs", "correct": false, "feedback": "Erreur : `int` accepte tout flottant, positif ou négatif.\n" } ], "explanation": "`int` tronque vers zéro : `int(3.7)` donne `3` et `int(-3.7)` donne\n`-3`. Pour arrondir, on utilise `round`." }, { "statement": "Que vaut `int(-2.2)` ?", "options": [ { "text": "`-2`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, sans\narrondir. Pour un négatif, cela rapproche de zéro.\n" }, { "text": "`-3`", "correct": false, "feedback": "Erreur : -3 serait l'entier inférieur. `int` ne descend pas, il\ncoupe les décimales.\n" }, { "text": "`-2.2`", "correct": false, "feedback": "Erreur : `int` renvoie toujours un entier.\n" }, { "text": "Une erreur, `int` ne s'appliquant pas aux négatifs", "correct": false, "feedback": "Erreur : `int` accepte tout flottant, positif ou négatif.\n" } ], "explanation": "`int` tronque vers zéro : `int(3.7)` donne `3` et `int(-3.7)` donne\n`-3`. Pour arrondir, on utilise `round`." }, { "statement": "Que vaut `int(-9.5)` ?", "options": [ { "text": "`-9`", "correct": true, "feedback": "Bonne réponse : `int` supprime la partie décimale, sans\narrondir. Pour un négatif, cela rapproche de zéro.\n" }, { "text": "`-10`", "correct": false, "feedback": "Erreur : -10 serait l'entier inférieur. `int` ne descend pas, il\ncoupe les décimales.\n" }, { "text": "`-9.5`", "correct": false, "feedback": "Erreur : `int` renvoie toujours un entier.\n" }, { "text": "Une erreur, `int` ne s'appliquant pas aux négatifs", "correct": false, "feedback": "Erreur : `int` accepte tout flottant, positif ou négatif.\n" } ], "explanation": "`int` tronque vers zéro : `int(3.7)` donne `3` et `int(-3.7)` donne\n`-3`. Pour arrondir, on utilise `round`." } ] }, { "id": "q29", "difficulty": 3, "skills": [ "priorite", "division", "multiplication" ], "title": "Division et multiplication à la suite", "statement": "Que vaut `10 / 4 * 2` ?", "options": [ { "text": "`5.0`", "correct": true, "feedback": "Bonne réponse : `/` et `*` ont la même priorité et s'évaluent de\ngauche à droite : d'abord `10 / 4`, puis le résultat\nmultiplié par 2.\n" }, { "text": "`1.25`", "correct": false, "feedback": "Erreur : ce résultat correspond à `10 / (4 * 2)`. Sans\nparenthèses, la division est faite en premier.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : `/` est la division réelle, le résultat est un\nflottant.\n" }, { "text": "Une erreur, car on ne peut pas enchaîner deux opérateurs", "correct": false, "feedback": "Erreur : enchaîner des opérateurs est permis, l'ordre\nd'évaluation suit les règles de priorité.\n" } ], "explanation": "À priorité égale, Python évalue de gauche à droite. Des\nparenthèses lèvent toute ambiguïté.", "variants": [ { "statement": "Que vaut `10 / 4 * 2` ?", "options": [ { "text": "`5.0`", "correct": true, "feedback": "Bonne réponse : `/` et `*` ont la même priorité et s'évaluent de\ngauche à droite : d'abord `10 / 4`, puis le résultat\nmultiplié par 2.\n" }, { "text": "`1.25`", "correct": false, "feedback": "Erreur : ce résultat correspond à `10 / (4 * 2)`. Sans\nparenthèses, la division est faite en premier.\n" }, { "text": "`4`", "correct": false, "feedback": "Erreur : `/` est la division réelle, le résultat est un\nflottant.\n" }, { "text": "Une erreur, car on ne peut pas enchaîner deux opérateurs", "correct": false, "feedback": "Erreur : enchaîner des opérateurs est permis, l'ordre\nd'évaluation suit les règles de priorité.\n" } ], "explanation": "À priorité égale, Python évalue de gauche à droite. Des\nparenthèses lèvent toute ambiguïté." }, { "statement": "Que vaut `12 / 3 * 5` ?", "options": [ { "text": "`20.0`", "correct": true, "feedback": "Bonne réponse : `/` et `*` ont la même priorité et s'évaluent de\ngauche à droite : d'abord `12 / 3`, puis le résultat\nmultiplié par 5.\n" }, { "text": "`0.8`", "correct": false, "feedback": "Erreur : ce résultat correspond à `12 / (3 * 5)`. Sans\nparenthèses, la division est faite en premier.\n" }, { "text": "`20`", "correct": false, "feedback": "Erreur : `/` est la division réelle, le résultat est un\nflottant.\n" }, { "text": "Une erreur, car on ne peut pas enchaîner deux opérateurs", "correct": false, "feedback": "Erreur : enchaîner des opérateurs est permis, l'ordre\nd'évaluation suit les règles de priorité.\n" } ], "explanation": "À priorité égale, Python évalue de gauche à droite. Des\nparenthèses lèvent toute ambiguïté." }, { "statement": "Que vaut `9 / 2 * 4` ?", "options": [ { "text": "`18.0`", "correct": true, "feedback": "Bonne réponse : `/` et `*` ont la même priorité et s'évaluent de\ngauche à droite : d'abord `9 / 2`, puis le résultat\nmultiplié par 4.\n" }, { "text": "`1.125`", "correct": false, "feedback": "Erreur : ce résultat correspond à `9 / (2 * 4)`. Sans\nparenthèses, la division est faite en premier.\n" }, { "text": "`16`", "correct": false, "feedback": "Erreur : `/` est la division réelle, le résultat est un\nflottant.\n" }, { "text": "Une erreur, car on ne peut pas enchaîner deux opérateurs", "correct": false, "feedback": "Erreur : enchaîner des opérateurs est permis, l'ordre\nd'évaluation suit les règles de priorité.\n" } ], "explanation": "À priorité égale, Python évalue de gauche à droite. Des\nparenthèses lèvent toute ambiguïté." } ] }, { "id": "q30", "difficulty": 3, "skills": [ "str", "concatenation", "priorite" ], "title": "Deux conversions et une concaténation", "statement": "Que vaut `str(2 + 3) + str(4)` ?", "options": [ { "text": "`'54'`", "correct": true, "feedback": "Bonne réponse : `2 + 3` est calculé entre nombres, donne\n5, puis `str` le transforme en texte, collé à `\"4\"`.\n" }, { "text": "`9`", "correct": false, "feedback": "Erreur : après `str`, le `+` central est une concaténation de\nchaînes, pas une addition.\n" }, { "text": "`'234'`", "correct": false, "feedback": "Erreur : l'addition `2 + 3` est faite avant la conversion,\nentre nombres.\n" }, { "text": "Une erreur, `str` ne s'appliquant pas à un calcul", "correct": false, "feedback": "Erreur : `str` reçoit le résultat du calcul, un entier, et le\nconvertit sans difficulté.\n" } ], "explanation": "Le même `+` additionne des nombres et concatène des chaînes. Tout\ndépend du type des valeurs au moment où il est appliqué.", "variants": [ { "statement": "Que vaut `str(2 + 3) + str(4)` ?", "options": [ { "text": "`'54'`", "correct": true, "feedback": "Bonne réponse : `2 + 3` est calculé entre nombres, donne\n5, puis `str` le transforme en texte, collé à `\"4\"`.\n" }, { "text": "`9`", "correct": false, "feedback": "Erreur : après `str`, le `+` central est une concaténation de\nchaînes, pas une addition.\n" }, { "text": "`'234'`", "correct": false, "feedback": "Erreur : l'addition `2 + 3` est faite avant la conversion,\nentre nombres.\n" }, { "text": "Une erreur, `str` ne s'appliquant pas à un calcul", "correct": false, "feedback": "Erreur : `str` reçoit le résultat du calcul, un entier, et le\nconvertit sans difficulté.\n" } ], "explanation": "Le même `+` additionne des nombres et concatène des chaînes. Tout\ndépend du type des valeurs au moment où il est appliqué." }, { "statement": "Que vaut `str(5 + 6) + str(7)` ?", "options": [ { "text": "`'117'`", "correct": true, "feedback": "Bonne réponse : `5 + 6` est calculé entre nombres, donne\n11, puis `str` le transforme en texte, collé à `\"7\"`.\n" }, { "text": "`18`", "correct": false, "feedback": "Erreur : après `str`, le `+` central est une concaténation de\nchaînes, pas une addition.\n" }, { "text": "`'567'`", "correct": false, "feedback": "Erreur : l'addition `5 + 6` est faite avant la conversion,\nentre nombres.\n" }, { "text": "Une erreur, `str` ne s'appliquant pas à un calcul", "correct": false, "feedback": "Erreur : `str` reçoit le résultat du calcul, un entier, et le\nconvertit sans difficulté.\n" } ], "explanation": "Le même `+` additionne des nombres et concatène des chaînes. Tout\ndépend du type des valeurs au moment où il est appliqué." }, { "statement": "Que vaut `str(1 + 9) + str(2)` ?", "options": [ { "text": "`'102'`", "correct": true, "feedback": "Bonne réponse : `1 + 9` est calculé entre nombres, donne\n10, puis `str` le transforme en texte, collé à `\"2\"`.\n" }, { "text": "`12`", "correct": false, "feedback": "Erreur : après `str`, le `+` central est une concaténation de\nchaînes, pas une addition.\n" }, { "text": "`'192'`", "correct": false, "feedback": "Erreur : l'addition `1 + 9` est faite avant la conversion,\nentre nombres.\n" }, { "text": "Une erreur, `str` ne s'appliquant pas à un calcul", "correct": false, "feedback": "Erreur : `str` reçoit le résultat du calcul, un entier, et le\nconvertit sans difficulté.\n" } ], "explanation": "Le même `+` additionne des nombres et concatène des chaînes. Tout\ndépend du type des valeurs au moment où il est appliqué." } ] } ] }