$course$/QCM de NSI/Première/Variables et types de base Variables Python, affectation, types primitifs (entier,
flottant, chaîne, booléen), conversions de types,
opérateurs arithmétiques et logiques, opérations de base
sur les chaînes.

]]> Variables et types de base — Q01 : Affectation Quelle est la signification de l'instruction
x = 5 en Python ?

]]> L'opérateur = est l'affectation (asymétrique :
gauche reçoit droite). À ne pas confondre avec
== qui est le test d'égalité (symétrique,
booléen).

]]> 1.0 0.0 0 true true abc Affecter la valeur 5 à la variable x

]]> Bonne réponse : on fait pointer le nom x
vers la valeur 5. Si x n'existait pas,
la variable est créée ; sinon, elle est mise
à jour.

]]> Tester si x est égal à 5

]]> Erreur : le test d'égalité s'écrit == (deux
signes égal). Avec un seul =, c'est une
affectation.

]]> Définir une fonction x qui renvoie 5

]]> Erreur : une fonction se définit avec def.

]]> Multiplier x par 5

]]> Erreur : la multiplication s'écrit x * 5.

]]> Variables et types de base — Q02 : Type entier Quel est le type de la valeur 42 en Python ?

]]> Python distingue int (entiers, précision
arbitraire) et float (flottants, précision
finie). 42 et 42.0 sont distincts (mais
égaux par valeur).

]]> 1.0 0.0 0 true true abc int

]]> Bonne réponse : 42 est un entier (type
int). On peut le vérifier avec
type(42) qui renvoie <class 'int'>.

]]> str

]]> Erreur : 42 n'a pas de guillemets, ce n'est
pas une chaîne.

]]> bool

]]> Erreur : les booléens sont True et False.

]]> float

]]> Erreur : 42.0 serait un flottant. Sans
virgule, c'est un entier.

]]> Variables et types de base — Q03 : Type flottant Que renvoie type(3.14) en Python ?

]]> Attention : les flottants ont une précision limitée. 0.1 + 0.2 ne donne pas exactement
0.3 mais 0.30000000000000004, car ces nombres
n'ont pas d'écriture binaire exacte.

]]> 1.0 0.0 0 true true abc <class 'int'>

]]> Erreur : 3.14 a une partie décimale, c'est
un flottant.

]]> <class 'str'>

]]> Erreur : pas de guillemets.

]]> <class 'float'>

]]> Bonne réponse : tout nombre avec un point
décimal est un flottant en Python.

]]> <class 'decimal'>

]]> Erreur : decimal n'est pas un type natif de
Python ; le type des nombres à virgule est
float.

]]> Variables et types de base — Q04 : Type chaîne Quel est le type de "hello" en Python ?

]]> Python n'a pas de type spécifique pour un seul
caractère : 'a' est une chaîne de longueur 1.

]]> 1.0 0.0 0 true true abc int

]]> Erreur : "hello" est entre guillemets,
c'est une chaîne.

]]> char

]]> Erreur : pas de type char en Python (à la
différence de C ou Java). Un caractère est
juste une chaîne de longueur 1.

]]> bool

]]> Erreur : un booléen est True ou False.

]]> str

]]> Bonne réponse : les chaînes de caractères
sont du type str (string). On les écrit
entre guillemets simples (') ou doubles
(").

]]> Variables et types de base — Q05 : Type booléen Quelles sont les deux seules valeurs du type
bool en Python ?

]]> Mnémonique : majuscule à True et False,
pas comme en JavaScript ou C.

]]> 1.0 0.0 0 true true abc oui et non

]]> Erreur : Python est en anglais, pas en
français.

]]> 0 et 1

]]> Erreur : ce sont des entiers. Ils sont
interprétés comme booléens (0 = faux, 1 =
vrai) mais leur type reste int.

]]> True et False

]]> Bonne réponse : avec une majuscule obligatoire. true ou false (en
minuscules) provoqueraient une erreur.

]]> yes et no

]]> Erreur : ces mots-clés n'existent pas en
Python.

]]> Variables et types de base — Q06 : Conversion en entier Que renvoie int("42") ?

]]> int(x) accepte : entiers (renvoie x), flottants
(tronque vers 0), chaînes représentant un entier.
Avec int("3.14"), ça lève ValueError.

]]> 1.0 0.0 0 true true abc La chaîne "42"

]]> Erreur : int(...) renvoie un entier, pas
une chaîne.

]]> L'entier 42

]]> Bonne réponse : int(s) convertit la chaîne
s en son entier correspondant. Utile pour
lire une saisie utilisateur (input()
renvoie toujours une chaîne).

]]> Une erreur

]]> Erreur : "42" est convertible. Une chaîne
comme "abc" lèverait ValueError.

]]> Le flottant 42.0

]]> Erreur : int produit un entier, pas un
flottant. Utiliser float("42") pour cela.

]]> Variables et types de base — Q07 : Opérateur de division Que renvoie 7 / 2 en Python 3 ?

]]> Distinction Python 3 : / = division flottante
(toujours float) ; // = division entière
(entier si les deux opérandes sont entiers).

]]> 1.0 0.0 0 true true abc 3.5

]]> Bonne réponse : en Python 3, / est la
division flottante. Toujours, même entre
deux entiers.

]]> 4

]]> Erreur : pas d'arrondi.

]]> 3

]]> Erreur : c'est la division entière (//).

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> Variables et types de base — Q08 : Division entière Que renvoie 7 // 2 ?

]]> Avec des négatifs, attention : -7 // 2
vaut -4 (arrondi vers le bas, pas vers 0).
Cohérent avec a == (a // b) * b + a % b.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : 1 est le reste (%), pas le quotient.

]]> 3.5

]]> Erreur : c'est la division flottante
(/).

]]> 4

]]> Erreur : pas d'arrondi à l'entier supérieur,
mais troncature vers le bas.

]]> 3

]]> Bonne réponse : // est la division
entière (quotient sans le reste).

]]> Variables et types de base — Q09 : Modulo Que renvoie 7 % 2 ?

]]> Très utile : n % 2 permet de tester la parité
(n % 2 == 0 ⇔ pair). De manière plus
générale, n % k regarde la classe modulo k.

]]> 1.0 0.0 0 true true abc 3

]]> Erreur : 3 est le quotient (//), pas le
reste.

]]> 0

]]> Erreur : 7 n'est pas un multiple de 2, son reste
n'est pas nul.

]]> 3.5

]]> Erreur : c'est /, pas %.

]]> 1

]]> Bonne réponse : % calcule le reste
de la division entière. 7 = 3 × 2 + 1, donc
7 % 2 = 1.

]]> Variables et types de base — Q10 : Print Que fait l'instruction print("bonjour") ?

]]> print est aussi utile pour la mise au point d'un
programme : afficher la valeur d'une variable aide
à repérer une erreur.

]]> 1.0 0.0 0 true true abc Imprime sur l'imprimante de l'ordinateur

]]> Confusion : print affiche dans la
console (sortie standard), pas sur une
imprimante physique.

]]> Ne fait rien

]]> Erreur : print produit un effet visible.

]]> Affiche bonjour dans la console

]]> Bonne réponse : c'est l'affichage standard.
Pour ajouter à la fin, utiliser
print(x, end="") ; pour séparer plusieurs
arguments, print(a, b, sep=", ").

]]> Définit une variable nommée bonjour

]]> Erreur : print affiche, ne définit pas.

]]> Variables et types de base — Q11 : Typage dynamique `python
x = 5
x = "hello"
`
Cette suite d'instructions est-elle valide ?

]]> Avec le typage dynamique, on gagne en souplesse
mais on perd en sûreté : une erreur de type
n'apparaît qu'au moment de l'exécution.

]]> 1.0 0.0 0 true true abc Non, x est figé en entier dès sa première affectation

]]> Erreur : ce serait le cas dans un langage à
typage statique (Java, C++, Rust),
mais pas en Python.

]]> Oui, mais Python affiche un avertissement de changement de type

]]> Erreur : aucun avertissement n'est émis par
défaut.

]]> Oui : le typage de Python est dynamique

]]> Bonne réponse : une variable peut désigner
successivement des objets de types
différents, Python autorise cette
réaffectation. C'est puissant mais source
de bugs subtils.

]]> Non, il faut d'abord redéclarer la variable x avec son nouveau type

]]> Erreur : aucune « redéclaration » n'existe
en Python, une simple affectation suffit.

]]> Variables et types de base — Q12 : Conversion qui plante Que se passe-t-il avec int("abc") ?

]]> Bonne pratique : vérifier qu'une saisie ne
contient que des chiffres avant de la convertir.
`python
s = input()
ok = len(s) > 0
for c in s:
if c not in "0123456789":
ok = False
if ok:
n = int(s)
else:
print("Pas un entier")
`
La gestion des exceptions, qui permet de
rattraper l'erreur après coup, est au programme
de terminale.

]]> 1.0 0.0 0 true true abc Lève ValueError

]]> Bonne réponse : Python lève ValueError:
invalid literal for int() with base 10:
'abc'. Avant de convertir une saisie, on
vérifie donc qu'elle ne contient que des
chiffres.

]]> Renvoie None

]]> Erreur : pas de retour silencieux à None.

]]> Renvoie "abc"

]]> Erreur : int(...) est censé renvoyer un
entier, pas une chaîne.

]]> Renvoie 0

]]> Erreur : Python ne renvoie pas une valeur
par défaut, il lève une exception.

]]> Variables et types de base — Q13 : Concaténation Que renvoie "abc" + "def" ?

]]> + a un sens différent selon le type : addition
pour les nombres, concaténation pour les chaînes
et les listes. Mais pas de mélange : "a" + 5
lève TypeError.

]]> 1.0 0.0 0 true true abc Une erreur

]]> Erreur : la syntaxe est valide.

]]> abc def

]]> Erreur : aucun espace n'est ajouté
automatiquement par +.

]]> 9 (somme alphabétique)

]]> Erreur : aucune somme alphabétique.

]]> abcdef

]]> Bonne réponse : + concatène deux chaînes.
Le résultat est "abcdef" (sans espace,
sauf indication explicite).

]]> Variables et types de base — Q14 : Répétition de chaîne Que renvoie "ab" * 3 ?

]]> Comme pour +, est surchargé. Sur des
listes : [0] 5 == [0, 0, 0, 0, 0]. Très
utile pour initialiser un tableau.

]]> 1.0 0.0 0 true true abc 6 (longueur)

]]> Erreur : * ne calcule pas la longueur.

]]> ab3

]]> Erreur : * ne convertit pas l'entier en
chaîne pour concaténer.

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> ababab

]]> Bonne réponse : répète une chaîne. C'est
un raccourci très pratique :
"-" 80 produit une ligne de tirets.

]]> Variables et types de base — Q15 : Saisie utilisateur Que renvoie input("Âge ?") après que
l'utilisateur a tapé 17 ?

]]> Piège classique : n = input(); n + 1 lève
TypeError car n est une chaîne. Penser à
convertir explicitement.

]]> 1.0 0.0 0 true true abc L'entier 17

]]> Erreur : input renvoie toujours une
chaîne, même si l'utilisateur a tapé un
nombre.

]]> La chaîne "17"

]]> Bonne réponse : pour obtenir un entier, il
faut convertir : int(input("Âge ?")).

]]> Le flottant 17.0

]]> Erreur : pas de conversion automatique.

]]> Le booléen True

]]> La fonction input() renvoie
systématiquement une chaîne
de caractères, indépendamment
de ce que l'utilisateur saisit.
Aucune conversion en booléen
n'est effectuée.

]]> Variables et types de base — Q16 : Comparaison Que renvoie 2 < 3 < 5 en Python ?

]]> Particularité Python (rare dans les autres
langages) : a < b < c est correctement
interprété comme a < b and b < c.

]]> 1.0 0.0 0 true true abc False

]]> Erreur : 2 < 3 et 3 < 5 sont les deux
vraies.

]]> 5

]]> Erreur : la comparaison renvoie un booléen,
pas une valeur.

]]> Une erreur de syntaxe

]]> Erreur : Python autorise la comparaison
chaînée.

]]> True

]]> Bonne réponse : Python permet d'enchaîner
les comparaisons : 2 < 3 < 5 équivaut à
2 < 3 and 3 < 5. C'est lisible et naturel
(« 3 est entre 2 et 5 »).

]]> Variables et types de base — Q17 : Conversion en booléen Que renvoie bool(0) ?

]]> bool convertit un nombre en booléen : 0 et
0.0 donnent False, tout autre nombre donne
True. On retrouve la convention des valeurs
booléennes 0 et 1.

]]> 1.0 0.0 0 true true abc Une erreur

]]> Erreur : conversion valide.

]]> False

]]> Bonne réponse : par convention, 0 (entier
ou flottant) est faux ; tout autre nombre
est vrai.

]]> 0

]]> Erreur : bool(...) renvoie un booléen,
pas le même entier.

]]> True

]]> Erreur : 0 est considéré comme faux en
Python.

]]> Variables et types de base — Q18 : Longueur de chaîne Que renvoie len("hello") ?

]]> len s'applique aussi aux listes, aux p-uplets
et aux dictionnaires : elle renvoie toujours un
nombre d'éléments.

]]> 1.0 0.0 0 true true abc 5

]]> Bonne réponse : len renvoie le nombre
de caractères. Pour une liste, c'est le
nombre d'éléments.

]]> hello

]]> Erreur : len renvoie un entier, pas la
chaîne elle-même.

]]> 5.0

]]> Erreur : len renvoie un entier, pas un
flottant.

]]> 1

]]> Erreur : len ne renvoie pas le nombre de
mots ou de phrases.

]]> Variables et types de base — Q19 : Conversion float → int Que renvoie int(3.9) ?

]]> Distinguer quatre fonctions : int(3.9) vaut 3
(troncature vers zéro) ; round(3.9) vaut 4
(arrondi au plus proche) ; math.floor(3.9)
vaut 3 (partie entière inférieure) ;
math.ceil(3.9) vaut 4 (partie entière
supérieure).

]]> 1.0 0.0 0 true true abc 3.9

]]> Erreur : int() renvoie un entier, pas un
flottant.

]]> 4

]]> Erreur : int() ne fait pas d'arrondi
mathématique ; c'est round(3.9) qui
donnerait 4.

]]> Une erreur

]]> Erreur : conversion valide.

]]> 3

]]> Bonne réponse : int(x) applique une
troncature vers 0, pas un arrondi.
int(-3.9) donnerait
-3, pas -4. Pour arrondir
mathématiquement, utiliser round.

]]> Variables et types de base — Q20 : Indexation de chaîne Que renvoie "hello"[0] ?

]]> Indexation négative : "hello"[-1] = 'o'
(dernier). Tranche : "hello"[1:4] = 'ell'.

]]> 1.0 0.0 0 true true abc e

]]> Erreur : à l'indice 1, pas 0.

]]> hello

]]> Erreur : [0] extrait un seul caractère,
pas la chaîne entière.

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> h

]]> Bonne réponse : Python indexe à partir de
0. Le premier caractère est à l'indice
0, le dernier à l'indice n-1.

]]> Variables et types de base — Q21 : Précision flottante Que renvoie 0.1 + 0.2 == 0.3 ?

]]> Bonne pratique : ne jamais comparer des
flottants avec ==. On teste plutôt
abs(a - b) < epsilon, avec epsilon un petit
seuil comme 1e-9 : ainsi
abs(0.1 + 0.2 - 0.3) < 1e-9 vaut True.

]]> 1.0 0.0 0 true true abc Une erreur

]]> Erreur : pas d'erreur, juste un résultat
contre-intuitif.

]]> 0.3

]]> Erreur : une comparaison renvoie toujours
un booléen.

]]> False

]]> Bonne réponse : 0.1 + 0.2 vaut en réalité
0.30000000000000004. C'est un piège
classique des flottants.

]]> True

]]> Erreur : à cause de la représentation IEEE
754, 0.1 + 0.2 ne donne pas exactement
0.3.

]]> Variables et types de base — Q22 : Opérateur puissance Que vaut 2 ** 10 ?

]]> Syntaxe a b (parfois écrite pow(a, b)).
Astuce : 2 0.5 donne la racine carrée de
2.

]]> 1.0 0.0 0 true true abc 20

]]> Erreur : confusion entre (multiplication)
et * (puissance).

]]> 1024

]]> Bonne réponse : ** est l'opérateur
puissance. À retenir : 2¹⁰ = 1024,
2²⁰ ≈ 10⁶, 2³⁰ ≈ 10⁹.

]]> Une erreur

]]> Erreur : ** est valide.

]]> 100

]]> Erreur : ce serait 10², pas 2 élevé à la puissance 10.

]]> Variables et types de base — Q23 : Affectation simultanée `python
a, b = 1, 2
a, b = b, a

Que valent a et b` à la fin ?

]]> L'affectation simultanée est l'un des grands
atouts de Python pour la lisibilité. Beaucoup
d'algorithmes (tri, recherche) en bénéficient.

]]> 1.0 0.0 0 true true abc a = 2, b = 1 (échangés)

]]> Bonne réponse : Python crée d'abord le
tuple (b, a) = (2, 1), puis le déballe
dans a, b. Les deux changent
simultanément, sans variable
temporaire.

]]> a = 1, b = 2 (inchangé)

]]> Erreur : il y a bien échange.

]]> Une erreur

]]> Erreur : syntaxe valide.

]]> a = 2, b = 2

]]> Erreur : ce serait le résultat buggé
d'un échange séquentiel mal écrit. Python
gère correctement.

]]> Variables et types de base — Q24 : Print avec virgule Que renvoie print("a", "b", "c") ?

]]> Paramètres utiles : sep="..." (séparateur
entre arguments) et end="..." (à la fin, par
défaut \n). Pour ne pas aller à la ligne :
print("...", end="").

]]> 1.0 0.0 0 true true abc Affiche abc

]]> Erreur : par défaut, print insère un
espace entre les arguments.

]]> Affiche [a, b, c]

]]> Erreur : aucun crochet ajouté
automatiquement.

]]> Lève une exception

]]> Erreur : print accepte plusieurs
arguments.

]]> Affiche a b c

]]> Bonne réponse : print insère un espace
entre ses arguments, le séparateur par
défaut. On peut le changer avec
sep="...". Ex. : print("a", "b",
sep=" - ") affiche a - b.

]]> Variables et types de base — Q25 : Synthèse Parmi les affirmations suivantes, laquelle est
fausse ?

]]> À retenir : les flottants sont des valeurs
approchées, on évite donc de tester leur égalité
avec ==. On compare plutôt leur écart à une
petite tolérance, par exemple
abs(a - b) < 0.000001.

]]> 1.0 0.0 0 true true abc Les indices Python commencent à 0

]]> Vrai : convention standard en informatique.

]]> 0.1 + 0.2 == 0.3 vaut True en Python

]]> Faux (donc bonne réponse) : 0.1 + 0.2 vaut
0.30000000000000004, car ces nombres n'ont pas
d'écriture binaire exacte. La comparaison vaut
donc False.

]]> Le langage Python est typé dynamiquement

]]> Vrai : une variable peut changer de type.

]]> / produit toujours un flottant en Python 3

]]> Vrai : différence par rapport à Python 2.

]]> Variables et types de base — Q26 : Échanger deux variables en Python Quelle est la façon la plus idiomatique d'échanger
les valeurs de deux variables a et b en Python ?

]]> L'affectation multiple a, b = b, a repose sur les
p-uplets implicites : Python crée d'abord le
couple (b, a) côté droit, puis le déballe à
gauche. Cette construction est plus claire et plus
courte que la version classique avec variable
temporaire (tmp = a; a = b; b = tmp).

]]> 1.0 0.0 0 true true abc a, b = b, a

]]> Bonne réponse : Python évalue d'abord le
membre de droite (le couple (b, a)) puis
affecte simultanément les deux composantes aux
variables de gauche. Aucune variable temporaire
n'est nécessaire.

]]> a = b puis b = a

]]> Erreur : ce code ne réalise pas un échange. Après
la première instruction, a perd sa valeur
d'origine et prend celle de b. La seconde
instruction recopie alors b dans... b. Les
deux variables se retrouvent égales à la valeur
initiale de b.

]]> a = b = a

]]> Erreur : cette instruction affecte la valeur
actuelle de a à b, puis cette même valeur à
a (sans changement). Aucun échange n'est
effectué.

]]> swap(a, b)

]]> Erreur : il n'existe pas de fonction native
swap en Python.

]]> Variables et types de base — Q27 : Découper une date On exécute le code suivant :
`python
date = "12/09/2026"
morceaux = date.split("/")
print(morceaux)
`
Que va afficher le programme ?

]]> split(sep) découpe une chaîne selon un séparateur et renvoie une
liste de chaînes. C'est la méthode utilisée pour lire une ligne d'un
fichier CSV, avant de convertir les valeurs numériques avec int ou
float.

]]> 1.0 0.0 0 true true abc [12, 9, 2026]

]]> Erreur : split ne convertit rien, les morceaux restent des
chaînes de caractères. Pour obtenir le jour sous forme d'entier,
il faut écrire int(morceaux[0]).

]]> '12092026'

]]> Erreur : split ne se contente pas de supprimer les barres
obliques, il renvoie une liste de morceaux, pas une chaîne
recollée.

]]> ['12', '09', '2026']

]]> Bonne réponse : split("/") découpe la chaîne à chaque barre
oblique et renvoie la liste des morceaux. Ce sont des chaînes :
il faudrait int pour obtenir des nombres.

]]> ['12/', '09/', '2026']

]]> Erreur : le séparateur sert à couper la chaîne et disparaît du
résultat. Aucun morceau ne contient la barre oblique.

]]> Variables et types de base — Q28 : Méthodes de chaîne Que vaut l'expression "NSI".lower() en Python ?

]]> Méthodes de chaîne fréquentes : upper() (tout en
majuscules), lower() (tout en minuscules),
strip() (supprime les espaces de début et de fin),
split(sep) (découpe selon un séparateur). Ces
méthodes renvoient une nouvelle chaîne, sans
modifier la chaîne d'origine.

]]> 1.0 0.0 0 true true abc 'nsi'

]]> Bonne réponse : lower renvoie une nouvelle chaîne où toutes les lettres ont été passées
en minuscules. La chaîne d'origine n'est pas
modifiée.

]]> 'Nsi'

]]> Erreur : seule la première lettre serait alors
en majuscule. La méthode lower passe tous les
caractères en minuscules.

]]> 'NSI'

]]> Erreur : la méthode lower transforme la chaîne
en minuscules. Elle ne peut donc pas renvoyer la
chaîne d'origine inchangée.

]]> La méthode lower n'existe pas

]]> Erreur : lower est une méthode standard des
chaînes Python, présente depuis les premières
versions du langage. Elle est très utilisée pour
comparer des chaînes sans tenir compte de la
casse.

]]> Variables et types de base — Q29 : Une division par zéro évitée On exécute le code suivant :

`python
x = 0
print(x != 0 and 10 / x > 1)
print(x == 0 or 10 / x > 1)
`

Qu'affiche ce programme ?

]]> Le caractère séquentiel de and et or permet de protéger une
opération risquée : dans x != 0 and 10 / x > 1, la division n'est
tentée que si x est non nul.

]]> 1.0 0.0 0 true true abc Une erreur ZeroDivisionError dès le premier print

]]> Erreur : and n'évalue pas son opérande droit quand l'opérande
gauche est faux. Comme x != 0 vaut False, la division par zéro
n'a jamais lieu.

]]> True puis False

]]> Erreur : les deux résultats sont inversés. x != 0 est faux pour
x nul, donc le and vaut False ; x == 0 est vrai, donc le
or vaut True.

]]> False puis une erreur ZeroDivisionError

]]> Erreur : or est lui aussi séquentiel. Son opérande gauche,
x == 0, est vrai : le résultat vaut True et la division
10 / x n'est jamais calculée.

]]> False puis True

]]> Bonne réponse : and et or évaluent leurs opérandes de gauche à
droite et s'arrêtent dès que le résultat est connu. x != 0 est
faux, donc le and vaut False sans calculer 10 / x ; x == 0
est vrai, donc le or vaut True sans calculer 10 / x.

]]> Variables et types de base — Q30 : Addition de deux chaînes Que vaut l'expression "3" + "4" en Python ?

]]> Le même symbole + additionne deux nombres et concatène deux
chaînes. C'est le type des opérandes qui décide : "3" + "4"
vaut '34', alors que 3 + 4 vaut 7.

]]> 1.0 0.0 0 true true abc '7'

]]> Erreur : Python n'additionne pas le contenu des chaînes. Il les
met bout à bout, ce qui donne '34'.

]]> '34'

]]> Bonne réponse : entre deux chaînes, + est la concaténation.
Les caractères de "4" sont ajoutés à la suite de ceux de
"3", sans aucun calcul.

]]> Une erreur, car + ne s'applique pas aux chaînes

]]> Erreur : + s'applique bien à deux chaînes et les concatène.
L'erreur n'apparaît que si l'on mélange une chaîne et un nombre.

]]> 7

]]> Erreur : les guillemets font de "3" et "4" des chaînes,
pas des nombres. Pour obtenir 7, il faudrait convertir les
deux avec int avant d'additionner.

]]> Variables et types de base — Q31 : Multiplication d'une chaîne par un entier Que vaut l'expression "ab" * 3 en Python ?

]]> Avec une chaîne et un entier, * répète la chaîne. Avec deux
chaînes, l'opération n'a pas de sens et lève une erreur.

]]> 1.0 0.0 0 true true abc 'ab ab ab'

]]> Erreur : la répétition n'insère aucun espace. Les copies sont
collées les unes aux autres : 'ababab'.

]]> 'ababab'

]]> Bonne réponse : multiplier une chaîne par un entier la répète.
"ab" est recopiée trois fois à la suite, sans séparateur.

]]> Une erreur, car on ne multiplie pas une chaîne par un entier

]]> Erreur : cette opération est permise et très utilisée, par
exemple "-" * 20 pour tracer une ligne. Seule la
multiplication de deux chaînes entre elles est interdite.

]]> 'ab3'

]]> Erreur : * ne colle pas le nombre à la chaîne. Il répète la
chaîne, ce qui donne 'ababab'.

]]> Variables et types de base — Q32 : Dernier caractère d'une chaîne Qu'affiche ce programme ?
`python
mot = "python"
print(mot[len(mot) - 1])
`

]]> Les indices d'une chaîne de longueur n vont de 0 à n - 1. Le
dernier caractère s'obtient donc avec mot[len(mot) - 1].

]]> 1.0 0.0 0 true true abc o

]]> Erreur : l'avant-dernier caractère est à l'indice
len(mot) - 2, soit 4. À l'indice 5 se trouve n.

]]> n

]]> Bonne réponse : len(mot) vaut 6 et les indices vont de 0
à 5. L'indice len(mot) - 1, soit 5, désigne donc le
dernier caractère, n.

]]> p

]]> Erreur : le premier caractère est à l'indice 0. L'indice
len(mot) - 1 vaut 5 et désigne le dernier caractère.

]]> Une erreur, car l'indice dépasse la longueur de la chaîne

]]> Erreur : c'est mot[len(mot)], d'indice 6, qui serait hors
limites. En retranchant 1, on tombe exactement sur le dernier
indice valide.

]]> Variables et types de base — Q33 : Un nom de variable interdit Que produit l'instruction class = 3 ?

]]> Un nom de variable commence par une lettre ou un tiret bas, ne
contient ni espace ni accent de préférence, et n'est jamais un
mot-clé. classe ou niveau conviennent.

]]> 1.0 0.0 0 true true abc La création d'une variable class valant 3

]]> Erreur : Python refuse ce nom avant même d'exécuter
l'affectation.

]]> Un avertissement, puis la création de la variable

]]> Erreur : il ne s'agit pas d'un avertissement mais d'une erreur
bloquante.

]]> La création d'une classe nommée 3, sans attribut

]]> Erreur : définir une classe demande une autre syntaxe, et 3
n'est pas un nom valide.

]]> Une erreur de syntaxe, class étant un mot réservé

]]> Bonne réponse : les mots-clés comme class, if, for ou
def sont réservés et ne peuvent pas servir de nom de variable.

]]> Variables et types de base — Q34 : Trois affectations raccourcies Qu'affiche ce programme ?
`python
n = 10
n -= 4
n *= 2
print(n)
`

]]> n -= a et n = b abrègent n = n - a et n = n b ; chaque
instruction part de la valeur courante.

]]> 1.0 0.0 0 true true abc 10

]]> Erreur : chaque écriture raccourcie modifie bien n.

]]> 2

]]> Erreur : les deux instructions s'enchaînent ; la multiplication
porte sur la valeur déjà diminuée.

]]> Une erreur, -= n'existant pas en Python

]]> Erreur : n -= 4 est l'abréviation de n = n - 4.

]]> 12

]]> Bonne réponse : n -= 4 retire 4, puis n *= 2 multiplie
le résultat par 2 : (10 - 4) × 2 = 12.

]]> Variables et types de base — Q35 : Un signe moins devant une puissance Que vaut -2 ** 2 en Python ?

]]> * passe avant le signe et avant ; en cas de doute, on écrit
(-2) 2 ou -(2 2) pour lever l'ambiguïté.

]]> 1.0 0.0 0 true true abc -4

]]> Bonne réponse : est prioritaire sur le signe moins.
L'expression se lit -(2 2), soit -4.

]]> -2

]]> Erreur : la puissance est bien calculée.

]]> 4

]]> Erreur : ce serait (-2) ** 2. Sans parenthèses, le signe
s'applique après la puissance.

]]> Une erreur de syntaxe

]]> Erreur : l'expression est valide, seule sa lecture demande de
connaître les priorités.

]]> Variables et types de base — Q36 : Le reste d'un nombre négatif Que vaut -7 % 3 en Python ?

]]> Python garantit a == b * (a // b) + a % b avec un reste compris
entre 0 et b - 1 pour b positif, même quand a est négatif.

]]> 1.0 0.0 0 true true abc -1

]]> Erreur : -1 est le reste au sens de certains autres langages,
qui gardent le signe du dividende. Python arrondit la division
entière vers le bas, ce qui donne un reste positif.

]]> 1

]]> Erreur : 1 serait le reste de la valeur absolue ; le signe
du dividende change le résultat.

]]> 2

]]> Bonne réponse : en Python, le reste a le signe du diviseur et
vérifie -7 == 3 * (-7 // 3) + 2, avec -7 // 3
valant -3.

]]> Une erreur, le modulo n'acceptant pas un nombre négatif

]]> Erreur : % accepte tous les entiers.

]]> Variables et types de base — Q37 : Modifier un caractère d'une chaîne Que produit ce programme ?
`python
s = "bonjour"
s[0] = "B"
`

]]> Une chaîne ne change jamais : toute « modification » crée une
nouvelle chaîne, ce que font upper, replace ou la
concaténation.

]]> 1.0 0.0 0 true true abc Rien, la modification étant ignorée en silence

]]> Erreur : Python signale l'opération interdite par une
exception.

]]> s devient Bonjour, le premier caractère remplacé

]]> Erreur : l'affectation par indice est refusée sur une chaîne.

]]> s devient B, l'affectation écrasant le reste

]]> Erreur : il n'y a ni remplacement ni raccourcissement, mais
une erreur.

]]> Une erreur, les chaînes étant immuables

]]> Bonne réponse : les chaînes sont immuables ; pour obtenir
Bonjour, on construit une nouvelle chaîne, par exemple
"B" + s[1:].

]]> Variables et types de base — Q38 : Tester la présence d'une sous-chaîne Que vaut l'expression "jour" in "bonjour" ?

]]> sous in chaine répond vrai si sous apparaît d'un seul tenant
dans chaine, sans dire où.

]]> 1.0 0.0 0 true true abc Une erreur, in ne s'appliquant qu'aux listes

]]> Erreur : in fonctionne aussi sur les chaînes.

]]> False, in ne cherchant qu'un caractère isolé

]]> Erreur : in cherche la sous-chaîne entière, consécutive, pas
ses lettres une à une.

]]> Un entier, la position de jour dans bonjour

]]> Erreur : in renvoie un booléen ; la position s'obtient par
find.

]]> True, jour figure d'un seul tenant dans bonjour

]]> Bonne réponse : in teste si la chaîne de gauche apparaît
telle quelle, caractères consécutifs, dans celle de droite.

]]>