$course$/QCM de NSI/SNT/1. Variables et affectation Premier chapitre de programmation : ce qu'est une variable, le sens du
signe égal, la réaffectation, l'ordre des instructions dans une
séquence, la copie d'une valeur, l'échange de deux variables et
l'écriture raccourcie des mises à jour.

]]> 1. Variables et affectation — Q01 : Une variable mise à jour Un compte de réseau social gagne des abonnés.

abonnes = 250
abonnes = abonnes + 30

Que vaut abonnes après ces deux lignes ?

]]> Le signe = n'est pas une égalité mais une affectation : on calcule
la valeur à droite, puis on la range dans la variable nommée à gauche.
abonnes = abonnes + 30 se lit « abonnes prend sa valeur plus 30 ».

]]> 1.0 0.0 0 true true abc 280

]]> Bonne réponse : la deuxième ligne calcule d'abord abonnes + 30
avec la valeur du moment, 250, puis range le résultat 280 dans
la variable.

]]> 250

]]> Erreur : la deuxième ligne remplace bien l'ancienne valeur. Une
variable garde la dernière valeur qu'on lui a affectée.

]]> 30

]]> Erreur : 30 est ce qu'on ajoute, pas la nouvelle valeur. Le
calcul du membre de droite utilise l'ancienne valeur 250.

]]> Une erreur, car abonnes apparaît des deux côtés

]]> Erreur : c'est une écriture très courante. Python calcule
d'abord la droite, avec la valeur actuelle, puis affecte le
résultat à gauche.

]]> 1. Variables et affectation — Q02 : Un nom de variable correct Un programme compte des photographies. Lequel de ces noms de
variable est accepté par Python ?

]]> Un nom de variable commence par une lettre ou un tiret bas, puis
enchaîne lettres, chiffres et tirets bas, sans espace ni tiret. Un nom
parlant comme nombre_de_photos rend le programme lisible.

]]> 1.0 0.0 0 true true abc 2eme_photo

]]> Erreur : un nom de variable ne peut pas commencer par un
chiffre. photo_2 serait accepté.

]]> nombre-de-photos

]]> Erreur : le tiret est le signe de la soustraction. Python lirait
nombre - de - photos, trois variables à soustraire.

]]> nombre_de_photos

]]> Bonne réponse : lettres, chiffres et tiret bas, sans commencer
par un chiffre. C'est la forme habituelle des noms en Python.

]]> nombre de photos

]]> Erreur : un nom ne contient pas d'espace. Python verrait trois
mots séparés et signalerait une erreur de syntaxe.

]]> 1. Variables et affectation — Q03 : Une variable sans valeur

largeur = 800
print(largeur * hauteur)

Que se passe-t-il à l'exécution ?

]]> Une variable n'existe qu'à partir de sa première affectation. Lire une
variable jamais définie déclenche une erreur NameError, qui indique
le nom fautif.

]]> 1.0 0.0 0 true true abc Python affiche 0, une variable inconnue vaut 0 par défaut

]]> Erreur : une variable n'a aucune valeur par défaut. Tant qu'on
ne lui en a pas affecté une, elle n'existe pas.

]]> Python signale une erreur, hauteur n'a jamais reçu de valeur

]]> Bonne réponse : le message est

NameError: name 'hauteur' is not

defined

. Il faut affecter une valeur à hauteur avant de s'en
servir.

]]> Python affiche 800, la multiplication est ignorée

]]> Erreur : Python n'ignore jamais une partie d'un calcul. Il ne
peut pas multiplier par une variable qui n'existe pas et s'arrête.

]]> Python affiche le texte largeur * hauteur tel quel

]]> Erreur : sans guillemets, largeur * hauteur est un calcul à
effectuer, pas un texte à afficher.

]]> 1. Variables et affectation — Q04 : L'ordre des instructions

prix = 20
prix = prix * 2
prix = prix - 5
print(prix)

Qu'affiche ce programme ?

]]> Un programme est une séquence : chaque instruction s'exécute après la
précédente, avec les valeurs du moment. Changer l'ordre de deux lignes
change en général le résultat.

]]> 1.0 0.0 0 true true abc 35

]]> Bonne réponse : 20 devient 40 après le doublement, puis 35
après la soustraction. Les instructions s'exécutent dans l'ordre.

]]> 30

]]> Erreur : 30 correspondrait à soustraire d'abord, puis doubler.
Le programme fait l'inverse, ligne après ligne.

]]> 40

]]> Erreur : 40 est la valeur après la deuxième ligne. La troisième
ligne enlève encore 5 avant l'affichage.

]]> 15

]]> Erreur : 15 serait 20 moins 5, sans le doublement. Les
trois lignes s'exécutent, dans l'ordre écrit.

]]> 1. Variables et affectation — Q05 : Une valeur copiée

a = 5
b = a
a = 7
print(b)

Qu'affiche ce programme ?

]]> Une affectation copie une valeur, pas un lien. Après b = a, les deux
variables ont la même valeur, mais chacune vit sa vie : changer l'une
ne change pas l'autre.

]]> 1.0 0.0 0 true true abc 5

]]> Bonne réponse : b = a copie la valeur de a à cet instant, 5.
Modifier a ensuite ne touche pas b.

]]> 7

]]> Erreur : b n'est pas lié à a pour toujours. Il a reçu une
copie de sa valeur au moment de l'affectation, avant le changement.

]]> 12

]]> Erreur : aucune addition n'est écrite. b = a copie une valeur,
elle n'additionne rien.

]]> a

]]> Erreur : sans guillemets, a désigne la variable, et b = a
range sa valeur dans b, pas son nom.

]]> 1. Variables et affectation — Q06 : Un échange raté On voudrait échanger les deux coordonnées d'un point.

x = 3
y = 8
x = y
y = x
print(x, y)

Qu'affiche ce programme ?

]]> Une affectation écrase l'ancienne valeur sans la garder. Pour échanger
deux variables, il faut d'abord mettre l'une d'elles à l'abri dans une
troisième variable.

]]> 1.0 0.0 0 true true abc 8 3

]]> Erreur : c'est l'échange espéré, mais la troisième ligne a
effacé la valeur 3 de x avant qu'on puisse la donner à y.

]]> 8 8

]]> Bonne réponse : x = y donne 8 à x, et l'ancienne valeur 3
est perdue. Puis y = x copie ce 8 dans y.

]]> 3 8

]]> Erreur : les deux affectations modifient bien les variables.
Après x = y, x vaut 8.

]]> 3 3

]]> Erreur : la première affectation copie y dans x, pas
l'inverse. C'est la valeur 8 qui se propage.

]]> 1. Variables et affectation — Q07 : L'échange avec une variable de secours x vaut 3 et y vaut 8. Quelle suite d'instructions échange leurs
valeurs, pour obtenir x égal à 8 et y égal à 3 ?

]]> L'échange classique tient en trois affectations : sauvegarder une
valeur dans une variable temporaire, écraser, puis restituer. L'ordre
des trois lignes est ce qui compte.

]]> 1.0 0.0 0 true true abc tmp = x, puis x = y, puis y = tmp

]]> Bonne réponse : tmp conserve 3, x reçoit 8, puis y reçoit
le 3 mis à l'abri. Rien n'est perdu.

]]> x = y, puis y = x

]]> Erreur : après x = y, la valeur 3 n'existe plus nulle part. Les
deux variables finissent à 8.

]]> tmp = x, puis y = tmp, puis x = y

]]> Erreur : y = tmp écrase le 8 avec 3 avant que x l'ait reçu.
Les deux variables finissent à 3.

]]> x = tmp, puis tmp = y, puis y = x

]]> Erreur : tmp n'a encore aucune valeur à la première ligne, le
programme s'arrête sur une erreur.

]]> 1. Variables et affectation — Q08 : Trois modifications successives Un thermostat corrige une consigne de température.

consigne = 12
consigne = consigne + 3
consigne = consigne - 5
consigne = consigne * 2
print(consigne)

Qu'affiche ce programme ?

]]> Pour suivre un programme, on tient à jour la valeur de chaque variable
ligne après ligne : c'est une trace. Ici, la consigne passe par 12,
15, 10 et 20.

]]> 1.0 0.0 0 true true abc 20

]]> Bonne réponse : 12 devient 15, puis 10, puis
20. Chaque ligne repart de la valeur laissée par la précédente.

]]> 10

]]> Erreur : 10 est la valeur après la soustraction. La
dernière ligne la double encore.

]]> 24

]]> Erreur : 24 serait le double de 12, comme si les lignes
du milieu n'existaient pas. Elles s'exécutent toutes.

]]> 14

]]> Erreur : 14 serait le double de 7, c'est-à-dire de
12 moins 5, comme si la ligne qui ajoute 3 n'existait pas.
Aucune ligne n'est sautée.

]]> 1. Variables et affectation — Q09 : L'écriture raccourcie

score = 40
score += 10
score -= 5
print(score)

Qu'affiche ce programme ?

]]> x += 3 est un raccourci pour x = x + 3 ; de même pour -=, *=
et /=. On lit toujours « la variable prend son ancienne valeur
modifiée ».

]]> 1.0 0.0 0 true true abc 45

]]> Bonne réponse : score += 10 signifie score = score + 10, et
score -= 5 signifie score = score - 5. 40 devient
50 puis 45.

]]> 55

]]> Erreur : -= retranche, il n'ajoute pas. Après 50, le
score descend à 45.

]]> 50

]]> Erreur : 50 est la valeur après la deuxième ligne. La
troisième enlève encore 5.

]]> Une erreur, l'opérateur += n'existe pas en Python

]]> Erreur : += et -= existent bien. Ce sont des raccourcis très
utilisés pour mettre une variable à jour.

]]> 1. Variables et affectation — Q10 : Le sens du signe égal Une seule de ces lignes provoque une erreur. Laquelle ?

]]> Une affectation se lit de droite à gauche : la valeur calculée à
droite est rangée dans la variable nommée à gauche. Le membre de
gauche doit donc être un nom de variable.

]]> 1.0 0.0 0 true true abc 5 = nombre

]]> Bonne réponse : à gauche du signe =, il faut le nom de la
variable qui reçoit. On ne peut pas donner une valeur au nombre 5.

]]> nombre = 5

]]> Erreur : c'est une affectation ordinaire, nombre reçoit 5.

]]> nombre = nombre + 5

]]> Erreur : cette ligne est correcte dès que nombre a une valeur.
Elle l'augmente de 5.

]]> nombre = 5 + 5

]]> Erreur : Python calcule 10 puis le range dans nombre. Le membre
de droite peut être n'importe quel calcul.

]]> 1. Variables et affectation — Q11 : Une valeur écrasée Un programme ajuste la luminosité d'un pixel.

pixel = 120
pixel = 255
pixel = pixel - 55
print(pixel)

Qu'affiche ce programme ?

]]> Une nouvelle affectation efface l'ancienne valeur, sans en garder de
trace. Seule la dernière valeur affectée compte pour la suite du
programme.

]]> 1.0 0.0 0 true true abc 200

]]> Bonne réponse : la deuxième ligne remplace 120 par 255, et la
troisième enlève 55, ce qui donne 200.

]]> 65

]]> Erreur : 65 serait 120 moins 55. Mais la valeur 120 a
été écrasée par 255 avant la soustraction.

]]> 175

]]> Erreur : 175 serait 120 plus 55. Aucune addition
n'apparaît, et la valeur de départ a été remplacée.

]]> 255

]]> Erreur : 255 est la valeur après la deuxième ligne. La troisième
la diminue de 55 avant l'affichage.

]]> 1. Variables et affectation — Q12 : Deux variables qui dépendent l'une de l'autre

a = 2
b = a + 3
a = b * 2
b = a - b
print(a, b)

Qu'affiche ce programme ?

]]> Dans une trace, on met à jour une variable à la fois, avec les valeurs
des autres au moment précis de la ligne. Écrire un tableau des
valeurs ligne par ligne évite les confusions.

]]> 1.0 0.0 0 true true abc 10 5

]]> Bonne réponse : b vaut 5, puis a vaut 10, puis b vaut
10 moins 5, soit 5.

]]> 10 8

]]> Erreur : 8 serait 10 moins 2, avec l'ancienne valeur de
a à la place de b. Or c'est b, qui vaut 5, que l'on
soustrait à la dernière ligne.

]]> 2 5

]]> Erreur : la troisième ligne modifie a, qui passe de 2 à 10.

]]> 4 -1

]]> Erreur : la troisième ligne multiplie b par 2, pas a. Elle
donne 10 à a, et non 4, et la dernière ligne calcule
alors 10 moins 5.

]]> 1. Variables et affectation — Q13 : Majuscule ou minuscule

Latitude = 45.7
print(latitude)

Que se passe-t-il ?

]]> Python distingue majuscules et minuscules dans les noms. Pour éviter
les erreurs, on écrit les noms de variables en minuscules, avec des
tirets bas entre les mots.

]]> 1.0 0.0 0 true true abc Python affiche 45.7, la casse des lettres n'a pas d'importance

]]> Erreur : pour Python, Latitude et latitude sont deux noms
différents. Le second n'a jamais reçu de valeur.

]]> Python signale une erreur, latitude n'existe pas

]]> Bonne réponse : les noms distinguent majuscules et minuscules.
Seule Latitude a été définie, latitude provoque une erreur
NameError.

]]> Python affiche le mot Latitude, sans sa valeur

]]> Erreur : print affiche la valeur d'une variable, jamais son
nom. Et ici, la variable demandée n'existe pas.

]]> Python affiche 0.0, valeur par défaut d'une variable

]]> Erreur : il n'y a pas de valeur par défaut. Une variable jamais
affectée n'existe pas.

]]> 1. Variables et affectation — Q14 : Une ligne qui ne change rien

x = 4
x = x
x = x * x
print(x)

Qu'affiche ce programme ?

]]> La ligne x = x est inutile mais correcte : elle affecte à x sa
propre valeur. Ce qui compte, c'est la dernière ligne, qui calcule
le carré.

]]> 1.0 0.0 0 true true abc 16

]]> Bonne réponse : x = x remet dans x sa propre valeur, sans
effet. Puis x * x vaut 4 fois 4.

]]> 4

]]> Erreur : la troisième ligne modifie bien x, qui devient 16.

]]> 8

]]> Erreur : x * x est une multiplication, 4 fois 4, et non une
addition.

]]> 44

]]> Erreur : x * x multiplie deux nombres, il ne colle pas deux
chiffres. Le résultat est 16.

]]> 1. Variables et affectation — Q15 : Afficher avant de modifier

niveau = 3
print(niveau)
niveau = niveau + 1
print(niveau)
niveau = niveau * 2

Qu'affiche ce programme ?

]]> print affiche la valeur d'une variable au moment où il s'exécute.
Une modification faite après un affichage ne le change pas, et une
modification finale sans affichage reste invisible.

]]> 1.0 0.0 0 true true abc 3 puis 4

]]> Bonne réponse : chaque print affiche la valeur du moment. Le
doublement final n'est jamais affiché.

]]> 4 puis 8

]]> Erreur : le premier print vient avant l'ajout de 1, il affiche
3. Et le doublement n'est suivi d'aucun affichage.

]]> 3 puis 8

]]> Erreur : le second print vient avant le doublement, il affiche
4.

]]> 4 puis 4

]]> Erreur : le premier affichage a lieu quand niveau vaut encore
3.

]]> 1. Variables et affectation — Q16 : Une rotation de trois valeurs

a = 1
b = 2
c = 3
tmp = a
a = b
b = c
c = tmp
print(a, b, c)

Qu'affiche ce programme ?

]]> Une variable temporaire sert à ne perdre aucune valeur quand on fait
tourner plusieurs variables. On suit les valeurs ligne par ligne :
tmp vaut 1, puis a vaut 2, b vaut 3 et c vaut 1.

]]> 1.0 0.0 0 true true abc 2 3 1

]]> Bonne réponse : a prend la valeur de b, b celle de c, et
c récupère l'ancienne valeur de a gardée dans tmp.

]]> 3 1 2

]]> Erreur : c'est la rotation dans l'autre sens. Ici a = b donne
2 à a.

]]> 1 2 3

]]> Erreur : les affectations modifient bien les trois variables, la
valeur de chacune se décale.

]]> 2 3 3

]]> Erreur : c = tmp donne à c la valeur sauvegardée au début,
1, et non celle de b.

]]> 1. Variables et affectation — Q17 : Ce qu'est une variable Dans l'instruction capteur = 21, que représente capteur ?

]]> Une variable est une case de la mémoire désignée par un nom. Le nom
est choisi pour être parlant, la valeur peut changer au cours du
programme.

]]> 1.0 0.0 0 true true abc Un nom qui désigne une valeur mémorisée, ici 21

]]> Bonne réponse : une variable est un nom associé à une valeur
rangée en mémoire. On retrouve la valeur en écrivant le nom.

]]> Une égalité mathématique vérifiée par le programme

]]> Erreur : le signe = de Python n'est pas celui des
mathématiques. Il ordonne de ranger 21 sous le nom capteur.

]]> Le texte capteur = 21 qui s'affichera à l'écran

]]> Erreur : une affectation n'affiche rien. Pour afficher, il faut
appeler print.

]]> Un capteur physique branché à l'ordinateur

]]> Erreur : le nom est choisi par le programmeur pour rappeler ce
que la valeur représente, mais ce n'est qu'un nom.

]]> 1. Variables et affectation — Q18 : Copier avant de modifier

ancien = 100
nouveau = ancien * 2
ancien = ancien + 1
print(ancien, nouveau)

Qu'affiche ce programme ?

]]> Une affectation calcule une valeur une fois pour toutes. nouveau
ne contient pas la formule ancien * 2 mais le nombre 200 obtenu au
moment du calcul.

]]> 1.0 0.0 0 true true abc 101 200

]]> Bonne réponse : nouveau est calculé avec la valeur 100, puis
ancien passe à 101 sans que nouveau en soit affecté.

]]> 101 202

]]> Erreur : nouveau ne se recalcule pas tout seul quand ancien
change. Il garde 200.

]]> 100 200

]]> Erreur : la troisième ligne augmente ancien, qui vaut 101 à
l'affichage.

]]> 100 202

]]> Erreur : ni l'une ni l'autre : ancien devient 101, et
nouveau reste 200.

]]> 1. Variables et affectation — Q19 : Deux variables qui avancent ensemble Un robot avance par pas de plus en plus grands.

distance = 0
pas = 5
distance = distance + pas
pas = pas * 2
distance = distance + pas
pas = pas * 2
distance = distance + pas
print(distance, pas)

Qu'affiche ce programme ?

]]> Quand deux variables se modifient tour à tour, la trace ligne par
ligne est le seul moyen sûr : distance 5, pas 10, distance 15,
pas 20, distance 35.

]]> 1.0 0.0 0 true true abc 35 20

]]> Bonne réponse : la distance reçoit 5, puis 10, puis 20, soit
35. Le pas a été doublé deux fois, il vaut 20.

]]> 15 20

]]> Erreur : 15 est la distance après deux ajouts. Le troisième
ajoute encore 20.

]]> 35 40

]]> Erreur : le pas n'est doublé que deux fois, il vaut 20 à la fin,
pas 40.

]]> 30 20

]]> Erreur : 30 serait 10 plus 20, sans le premier
ajout. Or celui-ci a lieu avec un pas de 5, avant tout
doublement : 5 plus 10 plus 20 font 35.

]]> 1. Variables et affectation — Q20 : Lire l'affectation dans le bon sens

total = 10
total + 5 = total
print(total)

Que se passe-t-il ?

]]> Le membre de gauche d'une affectation est toujours un nom de variable.
Pour augmenter total de 5, on écrit total = total + 5 : le calcul
à droite, le nom à gauche.

]]> 1.0 0.0 0 true true abc Python affiche 15, l'égalité se lit dans les deux sens

]]> Erreur : l'affectation n'est pas une égalité. Python refuse de
ranger une valeur dans un calcul.

]]> Python affiche 10, la deuxième ligne est ignorée

]]> Erreur : Python n'ignore aucune ligne. Il s'arrête sur cette
erreur de syntaxe avant même d'exécuter le programme.

]]> Python signale une erreur, le membre de gauche n'est pas un nom de variable

]]> Bonne réponse : à gauche du =, seule une variable peut recevoir
une valeur. total + 5 est un calcul, pas un nom.

]]> Python affiche 5, la différence entre les deux membres

]]> Erreur : Python ne résout pas d'équation. Une affectation range
simplement une valeur dans une variable.

]]> 1. Variables et affectation — Q21 : Un calcul rangé dans une variable Qu'affiche ce programme ?

x = 3 * 4
print(x)

]]> À droite du signe =, l'expression est calculée ; à gauche, la
variable reçoit le résultat.

]]> 1.0 0.0 0 true true abc 12

]]> Bonne réponse : le calcul 3 * 4 est effectué d'abord, et
son résultat 12 est rangé dans x.

]]> 3 * 4

]]> Erreur : sans guillemets, 3 * 4 est un calcul, pas un
texte. C'est le résultat qui est mémorisé.

]]> 7

]]> Erreur : * multiplie, il n'additionne pas.

]]> x

]]> Erreur : print(x) affiche la valeur de la variable, pas son
nom.

]]> 1. Variables et affectation — Q22 : Le nom ou la valeur Qu'affiche ce programme ?

x = 7
print("x")
print(x)

]]> Les guillemets changent tout : "x" est une chaîne, x est une
variable.

]]> 1.0 0.0 0 true true abc x puis 7

]]> Bonne réponse : entre guillemets, "x" est un texte d'une
lettre ; sans guillemets, x désigne la variable et sa valeur
7.

]]> 7 puis 7

]]> Erreur : les guillemets de la première ligne en font un texte,
affiché tel quel.

]]> x puis x

]]> Erreur : à la seconde ligne, x sans guillemets est la variable,
dont la valeur est affichée.

]]> Une erreur, car x ne peut pas être à la fois un texte et une variable

]]> Erreur : "x" et x sont deux choses différentes, un texte et
un nom de variable, qui coexistent sans conflit.

]]> 1. Variables et affectation — Q23 : Un message construit avec une variable Qu'affiche ce programme ?

prenom = "Lou"
message = "Bonjour " + prenom
print(message)

]]> Une variable peut contenir du texte, et + assemble des textes.
Les espaces voulus doivent figurer dans les chaînes.

]]> 1.0 0.0 0 true true abc Bonjour Lou

]]> Bonne réponse : + entre deux chaînes les met bout à bout, et
prenom est remplacé par sa valeur.

]]> Bonjour prenom

]]> Erreur : prenom sans guillemets est une variable, remplacée
par son contenu.

]]> Bonjour + Lou

]]> Erreur : le signe + est l'opérateur de concaténation, il
n'apparaît pas dans le résultat.

]]> BonjourLou

]]> Erreur : l'espace fait partie de la chaîne "Bonjour ", il est
donc conservé.

]]> 1. Variables et affectation — Q24 : Deux variables en une ligne Qu'affiche ce programme ?

a, b = 3, 7
print(a)

]]> a, b = 3, 7 équivaut à a = 3 suivi de b = 7. Les
valeurs sont distribuées dans l'ordre.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : l'affectation multiple donne la première valeur
à la première variable et la seconde à la seconde. a vaut 3.

]]> 7

]]> Erreur : 7 est rangé dans b, la seconde variable.

]]> 3, 7

]]> Erreur : print(a) n'affiche que a, pas les deux variables.

]]> Une erreur, une ligne ne pouvant affecter qu'une variable

]]> Erreur : Python autorise l'affectation de plusieurs variables en
une ligne, les valeurs étant prises dans l'ordre.

]]> 1. Variables et affectation — Q25 : L'échange en une ligne Qu'affiche ce programme ?

a = 1
b = 2
a, b = b, a
print(a, b)

]]> a, b = b, a évalue d'abord le couple de droite avec les anciennes
valeurs, puis l'affecte. Pas besoin de variable de secours.

]]> 1.0 0.0 0 true true abc 2 1

]]> Bonne réponse : les valeurs de droite, b puis a, sont
calculées avant toute affectation, puis rangées dans a et b.
Les deux variables sont échangées.

]]> 1 2

]]> Erreur : la troisième ligne échange bien les contenus des deux
variables.

]]> 2 2

]]> Erreur : ce serait le résultat de a = b suivi de b = a. Ici
les deux valeurs sont lues avant d'être écrites.

]]> Une erreur, a et b ne pouvant être modifiées en même temps

]]> Erreur : l'affectation multiple est faite pour cela, et c'est la
façon la plus simple d'échanger deux variables.

]]> 1. Variables et affectation — Q26 : Une variable qui change de nature Qu'affiche ce programme ?

x = 5
x = "cinq"
print(x)

]]> Chaque affectation remplace le contenu précédent, quel que soit son
type. Il ne reste que la dernière valeur.

]]> 1.0 0.0 0 true true abc cinq

]]> Bonne réponse : la seconde affectation remplace entièrement
l'ancienne valeur. Une variable peut recevoir un texte après un
nombre.

]]> 5

]]> Erreur : l'ancienne valeur est écrasée par la seconde
affectation.

]]> 5 cinq

]]> Erreur : une variable ne contient qu'une seule valeur à la fois,
la dernière reçue.

]]> Une erreur, une variable numérique ne pouvant recevoir un texte

]]> Erreur : en Python, une variable n'a pas de type fixé. Elle
prend le type de la valeur qu'on lui donne.

]]> 1. Variables et affectation — Q27 : Une variable ajoutée à elle-même Qu'affiche ce programme ?

a = 1
a = a + a
a = a + a
print(a)

]]> Dans a = a + a, le a de droite est l'ancienne valeur, le a de
gauche reçoit la nouvelle. Répétée, l'instruction double à chaque
fois.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : chaque ligne double la valeur courante : 1,
puis 2, puis 4.

]]> 2

]]> Erreur : 2 est la valeur après la première ligne

a = a +

a

. La seconde la double encore.

]]> 1

]]> Erreur : a = a + a modifie bien a, elle ne la laisse pas
intacte.

]]> 1 + 1 + 1 + 1

]]> Erreur : les additions sont calculées, pas affichées telles
quelles.

]]> 1. Variables et affectation — Q28 : Un compteur jamais créé Que produit ce programme ?

compteur = compteur + 1
print(compteur)

]]> Une variable doit être initialisée avant d'être utilisée dans un
calcul. Un compteur commence presque toujours par compteur = 0.

]]> 1.0 0.0 0 true true abc Une erreur, compteur n'ayant pas encore de valeur

]]> Bonne réponse : pour calculer compteur + 1, Python doit lire
compteur, qui n'existe pas encore. Il faut d'abord
compteur = 0.

]]> 1, Python donnant zéro par défaut à toute variable inconnue

]]> Erreur : aucune variable n'existe tant qu'elle n'a pas été
affectée. Il n'y a pas de valeur par défaut.

]]> 0, la variable étant créée vide puis affichée

]]> Erreur : une variable ne peut pas être créée vide. L'affectation
exige une valeur calculable.

]]> compteur + 1, affiché tel quel faute de valeur

]]> Erreur : Python tente le calcul avant d'afficher quoi que ce
soit, et c'est le calcul qui échoue.

]]> 1. Variables et affectation — Q29 : Un total qui ne se met pas à jour Qu'affiche ce programme ?

prix = 10
total = prix * 3
prix = 20
print(total)

]]> Une affectation calcule une valeur une fois pour toutes. Rien ne
relie durablement total à prix.

]]> 1.0 0.0 0 true true abc 30

]]> Bonne réponse : total a été calculé quand prix valait 10.
Modifier prix ensuite ne recalcule rien.

]]> 60

]]> Erreur : total ne suit pas les changements de prix. Pour
obtenir 60, il faudrait refaire total = prix * 3.

]]> 20

]]> Erreur : 20 est la nouvelle valeur de prix, pas celle de
total.

]]> 10

]]> Erreur : total contient le produit, pas l'ancien prix.

]]> 1. Variables et affectation — Q30 : Quatre affectations à suivre Qu'affiche ce programme ?

a = 5
b = a
a = b + 1
b = a * 2
print(a, b)

]]> Suivre un programme, c'est tenir à jour la valeur de chaque
variable ligne après ligne, en lisant chaque affectation de droite
à gauche.

]]> 1.0 0.0 0 true true abc 6 12

]]> Bonne réponse : b reçoit 5, puis a devient 5 + 1 = 6,
puis b devient 6 × 2 = 12.

]]> 6 10

]]> Erreur : à la dernière ligne, a vaut déjà 6, et non 5.
Le double est donc 12.

]]> 5 5

]]> Erreur : les deux dernières lignes modifient a puis b.

]]> 6 6

]]> Erreur : b = a * 2 double la valeur de a, il ne la recopie
pas.

]]>