$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 à cause de la
représentation binaire IEEE 754.

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

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

]]> <class 'decimal'>

]]> Erreur : decimal est un module spécialisé,
mais le type natif des nombres à virgule est
float.

]]> <class 'float'>

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

]]> <class 'str'>

]]> Erreur : pas de guillemets.

]]> 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 str

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

]]> int

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

]]> bool

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

]]> 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.

]]> 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 True et False

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

]]> oui et non

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

]]> yes et no

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

]]> 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.

]]> 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

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

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> 4

]]> Erreur : pas d'arrondi.

]]> 3.5

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

]]> 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 0

]]> Erreur : 0 est le reste, pas le quotient.

]]> 4

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

]]> 3.5

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

]]> 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 1

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

]]> 3.5

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

]]> 0

]]> Erreur : 7 est impair, son reste modulo 2
est 1.

]]> 3

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

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

]]> print est utile pour le débogage rapide.
Pour des programmes plus structurés, on
privilégie le module logging.

]]> 1.0 0.0 0 true true abc Définit une variable nommée bonjour

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

]]> 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=", ").

]]> Imprime sur l'imprimante de l'ordinateur

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

]]> 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
flexibilité mais on perd en sécurité. Les
annotations de type (x: int = 5) et mypy
permettent une vérification statique
optionnelle.

]]> 1.0 0.0 0 true true abc Non, il faut redéclarer x

]]> Erreur : aucune « redéclaration » nécessaire
en Python.

]]> Oui, mais Python affiche un avertissement

]]> Erreur : aucun avertissement par défaut.

]]> Non, x est figé en entier

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

]]> Oui, parce que Python est typé dynamiquement : une variable peut changer de type au cours du programme

]]> Bonne réponse : Python autorise cette
réaffectation. Attention : c'est puissant
mais peut causer des bugs subtils.

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

]]> Bonne pratique : protéger les conversions de
saisies utilisateur avec un try/except.
`python
try:
n = int(input())
except ValueError:
print("Pas un entier")
`

]]> 1.0 0.0 0 true true abc Renvoie 0

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

]]> Renvoie None

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

]]> Renvoie "abc"

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

]]> Lève ValueError

]]> Bonne réponse : Python lève ValueError:
invalid literal for int() with base 10:
'abc'. À gérer avec un try/except.

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

]]> + est surchargé : 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 abc def

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

]]> 9 (somme alphabétique)

]]> Erreur : aucune somme alphabétique.

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> 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 ababab

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

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> 6 (longueur)

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

]]> ab3

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

]]> 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 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.

]]> 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 ?")).

]]> 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 (équivalent à 2 < 3 and 3 < 5)

]]> Bonne réponse : Python permet d'enchaîner
les comparaisons. 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) ?

]]> Valeurs fausses en Python : False, 0,
0.0, "", [], {}, None. Tout le reste
est vrai. Permet d'écrire if liste: au lieu
de if len(liste) > 0:.

]]> 1.0 0.0 0 true true abc True

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

]]> 0

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

]]> False

]]> Bonne réponse : par convention, 0 (entier
ou flottant) est faux ; tout autre nombre
est vrai. La chaîne vide "" et la liste
vide [] sont aussi fausses.

]]> Une erreur

]]> Erreur : conversion valide.

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

]]> len est polymorphe : marche sur les chaînes,
listes, tuples, dictionnaires, ensembles,
fichiers... Toujours en O(1) pour ces types.

]]> 1.0 0.0 0 true true abc hello

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

]]> 1

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

]]> 5.0

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

]]> 5

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

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

]]> Distinguer quatre fonctions : int(3.9) = 3
(troncature vers zéro) ; round(3.9) = 4
(arrondi au plus proche, avec départage au
pair seulement pour les valeurs à mi-chemin
du type 0{,}5) ; math.floor(3.9) = 3
(partie entière inférieure) ;
math.ceil(3.9) = 4 (partie entière
supérieure).

]]> 1.0 0.0 0 true true abc 4 (arrondi)

]]> Erreur : int() ne fait pas d'arrondi
mathématique.

]]> Une erreur

]]> Erreur : conversion valide.

]]> 3 (troncature vers 0)

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

]]> 3.9

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

]]> 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 h

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

]]> e

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

]]> Une erreur

]]> Erreur : la syntaxe est valide.

]]> hello

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

]]> 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 ==. Utiliser
abs(a - b) < epsilon pour une comparaison à
ε près, ou le module math.isclose.

]]> 1.0 0.0 0 true true abc 0.3

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

]]> True

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

]]> Une erreur

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

]]> False

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

]]> 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 100

]]> Erreur : ce serait 10², pas 2¹⁰.

]]> 1024 (= 2¹⁰)

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

]]> Une erreur

]]> Erreur : ** est valide.

]]> 20

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

]]> 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 = 2

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

]]> Une erreur

]]> Erreur : syntaxe valide.

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

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

]]> 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.

]]> 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 [a, b, c]

]]> Erreur : aucun crochet ajouté
automatiquement.

]]> Affiche abc

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

]]> Affiche a b c (espaces entre les arguments)

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

]]> Lève une exception

]]> Erreur : print accepte plusieurs
arguments.

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

]]> Mnémonique des valeurs fausses : « tout ce
qui est vide ou nul ». Cela permet des
idiomes concis comme if liste: (= « si la
liste n'est pas vide »).

]]> 1.0 0.0 0 true true abc Python est typé dynamiquement

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

]]> La chaîne vide "" est considérée comme vraie dans une condition

]]> Faux (donc bonne réponse) : la chaîne vide
est fausse en contexte booléen, comme
0, [], {}, None.

]]> / produit toujours un flottant en Python 3

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

]]> Les indices Python commencent à 0

]]> Vrai : convention standard en informatique.

]]> 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 swap(a, b)

]]> Erreur : il n'existe pas de fonction native
swap en Python. De plus, comme les paramètres
sont passés par référence d'objet, une telle
fonction ne pourrait pas réaffecter les
variables d'origine.

]]> 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é.

]]> 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 = 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.

]]> Variables et types de base — Q27 : Affichage formaté avec une f-string On exécute le code suivant :

`python
prix = 12.5
quantite = 3
print(f"Total : {prix * quantite} €")
`

Que va afficher le programme ?

]]> Quelques options pratiques des f-strings :
f"{x:.2f}" arrondit à deux chiffres après la
virgule, f"{x:>10}" aligne à droite sur dix
caractères, f"{x=}" affiche à la fois le nom et
la valeur (x=37.5). C'est une syntaxe à privilégier
pour la plupart des affichages courants.

]]> 1.0 0.0 0 true true abc Total : 37.5 €

]]> Bonne réponse : la f-string remplace
{prix * quantite} par le résultat de
l'expression évaluée, soit
12{,}5 \times 3 = 37{,}5. Le reste de la
chaîne est laissé tel quel.

]]> Total : 12.5 * 3 €

]]> Erreur : Python évalue toujours l'expression
entre accolades, il n'affiche jamais l'opération
en clair. Le résultat affiché est
37{,}5, pas la formule.

]]> Total : {prix * quantite} €

]]> Erreur : la lettre f placée devant la chaîne
active le formatage : les expressions entre
accolades sont évaluées avant l'affichage.
Sans le préfixe f, on aurait au contraire ce
rendu littéral.

]]> Le code provoque une erreur de syntaxe

]]> Erreur : la syntaxe est correcte. Les f-strings
sont disponibles depuis Python 3{.}6 et sont
aujourd'hui le moyen le plus simple d'insérer
des valeurs dans une chaîne.

]]> 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),
replace(a, b) (remplace a par b),
split(sep) (découpe selon un séparateur). Comme
les chaînes sont immuables, ces méthodes renvoient
toujours une nouvelle chaîne.

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

]]> Erreur : ce serait l'effet de la méthode
capitalize, qui met seulement la première
lettre en majuscule et les autres en minuscules.
La méthode lower agit sur tous les caractères.

]]> 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.

]]> '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 (les chaînes Python sont immuables).

]]> '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.

]]> Variables et types de base — Q29 : Différence entre `==` et `is` En Python, quelle est la différence entre les
opérateurs == et is ?

]]> Recommandation pratique : utiliser == pour
comparer des valeurs ordinaires, et réserver is
aux comparaisons à des singletons (x is None,
x is True, x is False). La référence avec
None est en effet unique en mémoire, donc is
est exact et plus rapide.

]]> 1.0 0.0 0 true true abc == renvoie un nombre, is renvoie un booléen

]]> Erreur : les deux opérateurs renvoient un
booléen (True ou False). Aucun ne produit
de valeur numérique.

]]> Les deux sont strictement équivalents

]]> Erreur : ils ne testent pas la même chose. La
confusion entre les deux est une source classique
de bugs subtils, en particulier sur les listes
et les dictionnaires.

]]> == ne fonctionne que sur les nombres ; is ne fonctionne que sur les chaînes

]]> Erreur : les deux opérateurs s'appliquent à
toutes les valeurs Python. La distinction
entre eux est sémantique (égalité de valeur vs
identité d'objet), pas typologique.

]]> == compare les valeurs ; is teste si les deux références désignent le même objet en mémoire

]]> Bonne réponse : deux listes peuvent contenir les
mêmes valeurs ([1, 2] == [1, 2] vaut True)
tout en étant des objets distincts en mémoire
([1, 2] is [1, 2] vaut False). L'opérateur
is est plus strict que ==.

]]>