$course$/QCM de NSI/SNT/Notions transversales de programmation Variables et affectation, types de base, séquence d'instructions,
instruction conditionnelle, boucles bornées et non bornées,
définition et appel de fonctions, listes simples, opérateurs
arithmétiques, de comparaison et booléens, affichage et saisie,
lecture d'un message d'erreur.

]]> Notions transversales de programmation — Q01 : Une suite d'affectations Ce programme note les dimensions d'une photographie, en pixels.

largeur = 1024
hauteur = 768
hauteur = largeur
largeur = 640

Que vaut hauteur à la fin ?

]]> En Python, le signe = n'énonce pas une égalité mathématique, il range
une valeur dans une variable. Une affectation se lit de droite à gauche,
et seule la variable écrite à gauche change.

]]> 1.0 0.0 0 true true abc 768

]]> Erreur : c'est la valeur du départ, mais la troisième ligne l'a
remplacée par celle de largeur. Une affectation écrase sans
prévenir ce que la variable contenait.

]]> 1024

]]> Bonne réponse : la troisième ligne recopie dans hauteur la valeur
que largeur porte à cet instant, soit 1024. La ligne suivante ne
touche qu'à largeur.

]]> 640

]]> Erreur : suppose qu'une affectation crée un lien durable entre les
deux variables. Elle recopie une valeur une fois pour toutes, puis
chaque variable vit de son côté.

]]> 1792

]]> Erreur : additionne les deux valeurs. Le signe = ne calcule rien,
il range dans la variable de gauche la valeur trouvée à droite.

]]> Notions transversales de programmation — Q02 : Repérer une chaîne de caractères Un objet connecté range quatre informations dans quatre variables.

ville = "Lyon"
altitude = 173
humide = True
vitesse = 12.5

Laquelle contient une chaîne de caractères ?

]]> Les quatre types de base se reconnaissent à l'écriture : guillemets pour
une chaîne, chiffres seuls pour un entier, point décimal pour un
flottant, True ou False pour un booléen.

]]> 1.0 0.0 0 true true abc altitude, qui contient 173

]]> Erreur : 173 est un nombre entier. Il s'écrit sans guillemets et
sans point décimal, et se prête aux calculs.

]]> humide, qui contient True

]]> Erreur : True est un booléen, l'une des deux seules valeurs de
vérité. Il s'écrit sans guillemets et ne peut valoir que vrai ou
faux.

]]> vitesse, qui contient 12.5

]]> Erreur : 12.5 est un nombre flottant, reconnaissable à son point
décimal. Les guillemets sont absents.

]]> ville, qui contient "Lyon"

]]> Bonne réponse : les guillemets font de Lyon une suite de
caractères, et non un nom de variable.

]]> Notions transversales de programmation — Q03 : Un compteur de messages Une application compte les messages reçus.

messages = 0
messages = messages + 3
messages = messages + 2
print(messages)

Qu'affiche ce programme ?

]]> La ligne messages = messages + 3 se lit en deux temps : on calcule
d'abord messages + 3 avec la valeur actuelle, puis on range le
résultat dans messages. C'est le schéma de tout compteur.

]]> 1.0 0.0 0 true true abc 5

]]> Bonne réponse : la variable part de 0, reçoit 3, puis 2 de plus.
Chaque ligne lit la valeur courante, ajoute un nombre et range le
total au même endroit.

]]> 3

]]> Erreur : ne retient que la première addition. La ligne d'après
repart de 3 et ajoute encore 2.

]]> 2

]]> Erreur : suppose que la dernière addition remplace tout ce qui a
été calculé avant. Elle ajoute 2 à ce que la variable contient
déjà.

]]> 0

]]> Erreur : retient la valeur du départ. Les deux lignes qui suivent
modifient bel et bien la variable avant l'affichage.

]]> Notions transversales de programmation — Q04 : Un échange de coordonnées manqué Ce programme voudrait échanger la latitude et la longitude relevées par
un récepteur.

lat = 45
lon = 4
lat = lon
lon = lat
print(lat, lon)

Qu'affiche-t-il ?

]]> Échanger deux variables réclame une troisième variable, chargée de
garder la valeur qui va être écrasée. Sans elle, la première
affectation détruit ce que la seconde devait recopier.

]]> 1.0 0.0 0 true true abc 45 4

]]> Erreur : ce sont les valeurs du départ, comme si les deux
affectations n'avaient rien fait. La troisième ligne modifie
pourtant lat.

]]> 4 45

]]> Erreur : c'est l'échange souhaité, mais le programme ne l'obtient
pas. La valeur 45 disparaît dès que lat reçoit celle de lon.

]]> 4 4

]]> Bonne réponse : lat prend la valeur 4, puis lon reçoit cette
même valeur 4. L'ancienne valeur de lat n'existe plus nulle part.

]]> 45 45

]]> Erreur : c'est le résultat du même enchaînement mené dans l'autre
sens, où lon recevrait d'abord la valeur de lat.

]]> Notions transversales de programmation — Q05 : La division entière Un programme range 7 photographies sur des pages de 2 photographies.

print(7 // 2)

Qu'affiche-t-il ?

]]> Trois opérateurs cohabitent : / donne un quotient décimal, // le
quotient entier, % le reste. Ici, 7 vaut 3 fois 2, plus 1.

]]> 1.0 0.0 0 true true abc 3.5

]]> Erreur : c'est le résultat de 7 / 2, la division ordinaire, qui
donne un flottant. La barre doublée demande le quotient entier.

]]> 3

]]> Bonne réponse : // donne le nombre de fois que 2 tient dans 7,
soit 3, en abandonnant la partie décimale.

]]> 1

]]> Erreur : c'est le résultat de 7 % 2, qui donne le reste de la
division et non le quotient.

]]> 4

]]> Erreur : arrondit 3,5 au plus proche. La division entière
n'arrondit pas, elle abandonne la partie décimale.

]]> Notions transversales de programmation — Q06 : Une condition avec and L'éclairage d'un escalier lit deux capteurs.

sombre = True
presence = False
print(sombre and presence)

Qu'affiche ce programme ?

]]> and exige les deux conditions, or se contente d'une seule, not
inverse. Ces trois mots suffisent à écrire la règle de commande d'un
objet connecté.

]]> 1.0 0.0 0 true true abc False

]]> Bonne réponse : and n'est vrai que si ses deux côtés le sont. Le
second vaut ici False, donc le résultat aussi.

]]> True

]]> Erreur : ce serait le résultat de or, vrai dès qu'un seul côté
l'est. Avec and, les deux sont exigés en même temps.

]]> True False

]]> Erreur : suppose que print affiche les deux variables. Il ne
reçoit qu'une seule valeur, celle que and vient de calculer.

]]> None

]]> Erreur : None marque l'absence de valeur. Une opération entre
booléens donne toujours True ou False.

]]> Notions transversales de programmation — Q07 : La bonne condition d'alerte Un capteur sur pile doit lancer une alerte lorsque son niveau de
batterie est strictement inférieur à 20 et que l'appareil n'est pas en
charge. La variable en_charge vaut True pendant une recharge.
Quelle ligne convient ?

]]> Traduire une phrase en condition demande de repérer le mot de liaison,
ici « et », et la négation, ici « n'est pas ». and traduit le premier,
not la seconde.

]]> 1.0 0.0 0 true true abc if niveau < 20 or not en_charge:]]> Erreur : avec or, une seule des deux conditions suffit. L'alerte
partirait pour un capteur chargé à 80 %, au seul motif qu'il n'est
pas branché.

]]> if niveau < 20 and en_charge:]]> Erreur : cette ligne réclame l'inverse, une batterie basse pendant
la recharge. L'alerte ne partirait jamais pour un appareil
débranché.

]]> if not niveau < 20 and not en_charge:]]> Erreur : not niveau < 20 exige un niveau d'au moins 20. La
condition serait vraie pour un capteur plein et débranché, jamais
pour un capteur vide.

]]> if niveau < 20 and not en_charge:]]> Bonne réponse : and réunit les deux exigences et not inverse la
valeur de en_charge, ce qui traduit « pas en charge ».

]]> Notions transversales de programmation — Q08 : Ce que renvoie input Un questionnaire en ligne réclame un nombre.

reponse = input("Combien de messages as-tu reçus ? ")

L'utilisateur tape 12. Que contient reponse ?

]]> input rend toujours une chaîne de caractères. Pour calculer avec la
saisie, il faut la convertir, par exemple avec int(reponse) pour
obtenir un entier.

]]> 1.0 0.0 0 true true abc L'entier 12, converti par Python

]]> Erreur : aucune conversion n'a lieu d'elle-même. Obtenir un entier
demande de l'écrire, avec int(reponse).

]]> Le flottant 12.0, issu du clavier

]]> Erreur : aucun point décimal n'a été saisi, et le clavier ne
convertit rien. La saisie arrive telle qu'elle a été tapée.

]]> La chaîne de caractères « 12 »

]]> Bonne réponse : input rend toujours une chaîne, faite ici des deux
caractères 1 et 2, même quand la saisie ressemble à un nombre.

]]> Le booléen True, la saisie n'étant pas vide

]]> Erreur : un booléen ne sert qu'à répondre par vrai ou faux. input
rend le texte saisi, sans le juger.

]]> Notions transversales de programmation — Q09 : Une addition qui échoue Ce programme s'arrête sur une erreur.

reponse = input("Nombre de messages : ")
total = reponse + 1
print(total)

Pourquoi ?

]]> Le signe + additionne deux nombres et met deux chaînes bout à bout,
mais ne mélange pas les deux genres. Toute saisie destinée à un calcul
doit d'abord être convertie.

]]> 1.0 0.0 0 true true abc Parce que la variable total n'a pas été créée avant d'être
utilisée

]]> Erreur : la deuxième ligne crée justement total. Une variable naît
de sa première affectation, elle n'a pas à être annoncée.

]]> Parce que input renvoie une chaîne, et non un entier

]]> Bonne réponse : Python refuse d'ajouter un entier à une chaîne et
signale TypeError: can only concatenate str (not "int") to str.
Il faut écrire int(reponse) + 1.

]]> Parce que le texte affiché par input contient un deux-points

]]> Erreur : le texte passé à input est un simple message d'invite.
Son contenu n'a aucun effet sur le calcul qui suit.

]]> Parce que print ne sait afficher que des chaînes de caractères

]]> Erreur : print affiche aussi bien un entier qu'une chaîne.
L'erreur survient avant l'affichage, sur la ligne de l'addition.

]]> Notions transversales de programmation — Q10 : Tester une égalité Un thermostat doit réagir quand la température relevée vaut exactement
30. Quelle ligne écrit ce test ?

]]> Un signe simple affecte, un signe doublé compare. La confusion est si
répandue que Python propose lui-même la correction dans son message
d'erreur.

]]> 1.0 0.0 0 true true abc if temperature == 30:

]]> Bonne réponse : le signe doublé compare deux valeurs et donne True
ou False. C'est exactement ce qu'une condition attend.

]]> if temperature = 30:

]]> Erreur : le signe simple range une valeur dans une variable, il ne
compare rien. Python refuse la ligne et signale une SyntaxError.

]]> if temperature === 30:

]]> Erreur : le signe triplé vient d'un autre langage. Python ne le
connaît pas et signale SyntaxError: invalid syntax.

]]> if egale(temperature, 30):

]]> Erreur : aucune fonction de ce nom n'existe. Python signale
NameError: name 'egale' is not defined au moment de l'appel.

]]> Notions transversales de programmation — Q11 : La branche retenue Un capteur de qualité de l'air range son relevé en trois catégories.

indice = 55
if indice < 50:
    print("bon")
elif indice < 100:
    print("moyen")
else:
    print("mauvais")

Qu'affiche ce programme ?

]]> Les conditions sont examinées de haut en bas et la première vraie
l'emporte. Celles qui la suivent ne sont même pas évaluées.

]]> 1.0 0.0 0 true true abc bon

]]> Erreur : 55 n'est pas inférieur à 50. La première condition est
donc fausse et sa branche est sautée.

]]> mauvais

]]> Erreur : la branche else ne sert que si aucune condition n'a été
trouvée vraie. Celle du elif l'est ici.

]]> moyen

]]> Bonne réponse : la première condition est fausse, la deuxième est
vraie puisque 55 est inférieur à 100. Seule sa branche s'exécute.

]]> bon puis moyen

]]> Erreur : suppose que plusieurs branches peuvent s'exécuter. Un
enchaînement if, elif, else n'en retient jamais qu'une.

]]> Notions transversales de programmation — Q12 : Une branche jamais atteinte Ce programme classe une vitesse relevée par un radar, mais il n'affiche
jamais « autoroute », quelle que soit la vitesse.

vitesse = 120
if vitesse > 50:
    print("hors agglomération")
elif vitesse > 110:
    print("autoroute")
else:
    print("agglomération")

Comment l'expliquer ?

]]> Dans un enchaînement de conditions, l'ordre compte autant que les
seuils. Quand les intervalles se recouvrent, la condition la plus
exigeante doit venir en tête.

]]> 1.0 0.0 0 true true abc Parce qu'une instruction elif ne peut pas tester deux fois la
même variable

]]> Erreur : rien n'interdit de tester plusieurs fois la même variable.
C'est même le procédé habituel pour découper un intervalle.

]]> Parce que la branche else est choisie dès que deux conditions
sont vraies

]]> Erreur : else n'entre en jeu que si toutes les conditions sont
fausses. La première étant vraie, else est écarté.

]]> Parce qu'il manque un if devant la seconde condition, qui n'est
jamais lue

]]> Erreur : elif joue déjà le rôle d'un if rattaché au premier
test. La ligne est correctement écrite, c'est son rang qui pose
problème.

]]> Parce que toute vitesse dépassant 110 dépasse déjà 50, si bien que
la première branche l'emporte

]]> Bonne réponse : 120 est supérieur à 50, donc la première branche est
retenue et le reste de l'enchaînement est ignoré. Il faudrait
tester d'abord le seuil le plus élevé.

]]> Notions transversales de programmation — Q13 : Le nombre de tours d'une boucle Un programme de test envoie plusieurs requêtes à un serveur.

for i in range(5):
    print("requête envoyée")

Combien de fois le message est-il affiché ?

]]> range(n) parcourt les entiers de 0 à n - 1, soit exactement n
valeurs. Le nombre de tours se lit donc directement sur l'argument.

]]> 1.0 0.0 0 true true abc 4 fois, la valeur 0 ne comptant pas pour un tour

]]> Erreur : range(5) commence bel et bien à 0, et ce premier passage
exécute la ligne comme tous les autres.

]]> 5 fois, une par valeur parcourue

]]> Bonne réponse : range(5) fournit 0, 1, 2, 3 et 4, soit cinq
valeurs, donc cinq tours de boucle.

]]> 6 fois, les valeurs allant de 0 à 5 comprises

]]> Erreur : la borne écrite est exclue. range(5) s'arrête à 4 et ne
fournit jamais la valeur 5.

]]> 1 fois, seul le dernier tour affichant le message

]]> Erreur : la ligne indentée est exécutée à chaque tour, et non au
seul dernier. C'est tout l'intérêt d'une boucle.

]]> Notions transversales de programmation — Q14 : Une plage de valeurs Un objet connecté effectue un relevé à chaque heure d'une plage
horaire.

compte = 0
for heure in range(2, 8):
    compte = compte + 1
print(compte)

Qu'affiche ce programme ?

]]> range(a, b) parcourt les entiers de a à b - 1, soit b - a
valeurs. Ici, 8 moins 2 donne bien six tours.

]]> 1.0 0.0 0 true true abc 6

]]> Bonne réponse : la boucle parcourt 2, 3, 4, 5, 6 et 7, soit six
valeurs. La borne 8 est exclue.

]]> 5

]]> Erreur : retire une valeur de trop. La borne de départ, elle, est
bien parcourue.

]]> 7

]]> Erreur : compte la borne 8, qui est pourtant exclue. La boucle
s'arrête à 7.

]]> 8

]]> Erreur : prend la borne de fin pour le nombre de tours. Le départ
à 2 retire deux valeurs au compte.

]]> Notions transversales de programmation — Q15 : Une file de signalements traitée par lots Une équipe de modération traite 100 signalements par lots de 30.

restants = 100
tours = 0
while restants > 0:
    restants = restants - 30
    tours = tours + 1
print(tours, restants)

Qu'affiche ce programme ?

]]> Une boucle while examine sa condition avant chaque tour, jamais au
milieu. Le dernier lot est donc entamé en entier, même s'il dépasse ce
qui restait à traiter.

]]> 1.0 0.0 0 true true abc 3 10

]]> Erreur : après trois tours il reste 10 signalements, ce qui est
strictement supérieur à 0. La condition est encore vraie et un
quatrième tour a lieu.

]]> 4 0

]]> Erreur : la soustraction retire 30 à chaque tour, sans s'ajuster au
reste. Le quatrième tour fait passer le total sous zéro.

]]> 4 -20

]]> Bonne réponse : les valeurs passent par 70, 40, 10 puis -20, soit
quatre tours. La condition n'est examinée qu'en début de tour.

]]> 5 -50

]]> Erreur : ajoute un tour de trop. Dès que restants vaut -20, la
condition est fausse et la boucle s'arrête.

]]> Notions transversales de programmation — Q16 : Une boucle qui ne s'arrête pas Ce programme doit décompter les blocs d'un fichier restant à recevoir.

restants = 10
while restants > 0:
    print(restants)

Que fait-il réellement ?

]]> Toute boucle while réclame une instruction qui rapproche la condition
de sa fin. Sans elle, le programme tourne sans terme et il faut
l'interrompre à la main.

]]> 1.0 0.0 0 true true abc Il affiche 10 une seule fois, puis passe à la suite

]]> Erreur : while n'exécute pas son bloc une fois pour toutes. Il le
répète tant que la condition reste vraie.

]]> Il n'affiche rien, la condition étant fausse au départ

]]> Erreur : 10 est bien supérieur à 0. La condition est donc vraie dès
le premier examen et la boucle démarre.

]]> Il affiche les nombres de 10 jusqu'à 1, puis s'arrête

]]> Erreur : c'est le comportement attendu, mais aucune ligne ne
diminue restants. Il faudrait ajouter restants = restants - 1
dans le bloc.

]]> Il affiche 10 sans jamais s'arrêter

]]> Bonne réponse : rien ne modifie restants, qui vaut 10 à chaque
examen de la condition. Le même nombre défile indéfiniment.

]]> Notions transversales de programmation — Q17 : Une mémoire qui se remplit Le nombre de relevés stockés par un capteur est multiplié par trois
chaque jour.

releves = 5
jours = 0
while releves < 100:
    releves = releves * 3
    jours = jours + 1
print(jours, releves)

Qu'affiche ce programme ?

]]> Une multiplication répétée fait grimper une valeur très vite : trois
tours suffisent à passer de 5 à 135. La boucle s'arrête au premier
examen où la condition devient fausse.

]]> 1.0 0.0 0 true true abc 3 135

]]> Bonne réponse : les valeurs passent par 15, 45 puis 135, soit trois
tours. Le troisième a lieu parce que 45 est encore inférieur à 100.

]]> 2 45

]]> Erreur : s'arrête à 45, qui est pourtant inférieur à 100. La
condition reste vraie, donc un tour de plus a lieu.

]]> 3 45

]]> Erreur : compte trois tours mais garde la valeur du deuxième. Le
troisième tour multiplie encore par 3.

]]> 4 135

]]> Erreur : ajoute un tour de trop. Une fois releves à 135, la
condition est fausse et la boucle s'arrête.

]]> Notions transversales de programmation — Q18 : Une boucle de cinq en cinq Un programme de cartographie place un repère tous les cinq
kilomètres le long d'un parcours.

compteur = 0
for borne in range(5, 31, 5):
    compteur = compteur + 1
print(compteur)

Qu'affiche ce programme ?

]]> Dans range(debut, fin, pas), la boucle part de debut, avance
de pas à chaque tour et s'arrête avant fin. Ici elle prend les
six valeurs 5, 10, 15, 20, 25 et 30.

]]> 1.0 0.0 0 true true abc 6

]]> Bonne réponse : la boucle parcourt 5, 10, 15, 20, 25 et 30,
soit six valeurs, car le pas de 5 part de 5 et s'arrête avant
31. Le compteur est donc incrémenté six fois.

]]> 5

]]> Erreur : tu as sans doute compté 30 divisé par 5 en oubliant
que la borne 30 est atteinte. Les valeurs parcourues sont 5,
10, 15, 20, 25 et 30.

]]> 26

]]> Erreur : tu as compté les entiers de 5 à 30 en ignorant le
pas. Le troisième nombre de range fixe justement l'écart
entre deux valeurs successives.

]]> 31

]]> Erreur : tu as pris la borne de fin pour le nombre de tours.
Cette borne est exclue, et le pas de 5 ne retient que six
valeurs.

]]> Notions transversales de programmation — Q19 : La branche d'un relevé doux Une station météo qualifie la température relevée.

temp = 19
if temp < 5:
    resultat = "gel"
elif temp < 18:
    resultat = "frais"
elif temp < 25:
    resultat = "doux"
else:
    resultat = "chaud"
print(resultat)

Qu'affiche ce programme ?

]]> Les conditions d'une suite if, elif, else sont examinées
dans l'ordre, et la première qui est vraie emporte tout : son bloc
s'exécute, les suivants sont abandonnés.

]]> 1.0 0.0 0 true true abc frais

]]> Erreur : la condition temp < 18 est fausse pour 19, donc
cette branche est ignorée et l'examen se poursuit avec la
suivante.

]]> doux

]]> Bonne réponse : 19 n'est ni inférieur à 5 ni inférieur à 18,
mais il est inférieur à 25. C'est donc la troisième branche
qui s'exécute.

]]> chaud

]]> Erreur : la branche else ne s'exécute que si toutes les
conditions précédentes sont fausses. Or temp < 25 est vraie
pour 19.

]]> frais puis doux

]]> Erreur : dans une suite if, elif, else, une seule
branche s'exécute. Dès qu'une condition est vraie, les autres
ne sont plus examinées.

]]> Notions transversales de programmation — Q20 : Un partage répété par deux Un programme réduit de moitié la taille d'une image tant qu'elle
dépasse dix unités.

reste = 100
tours = 0
while reste > 10:
    reste = reste // 2
    tours = tours + 1
print(tours)

Qu'affiche ce programme ?

]]> Une boucle non bornée répète son bloc tant que sa condition est
vraie, sans qu'on sache d'avance combien de tours auront lieu.
Ici, la division entière par deux mène de 100 à 6 en quatre tours.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : reste prend successivement 50, 25, 12 puis
6. À ce moment la condition devient fausse, après quatre
tours.

]]> 3

]]> Erreur : tu t'es arrêté à 12, qui dépasse encore 10. Un tour
supplémentaire a lieu et ramène reste à 6.

]]> 5

]]> Erreur : tu as compté un tour de trop. Une fois reste à 6,
la condition est fausse et la boucle s'arrête sans exécuter
son bloc.

]]> 10

]]> Erreur : tu as pris le seuil de la condition pour le nombre
de tours. Comme la valeur est divisée par deux à chaque fois,
elle descend bien plus vite.

]]> Notions transversales de programmation — Q21 : Un argument manquant Un programme calcule le coût d'un trajet.

def cout(distance, prix_km):
    return distance * prix_km

print(cout(12))

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

]]> Un appel doit fournir autant d'arguments que la définition compte
de paramètres, dans le même ordre. Ici, cout(12, 3) renverrait
36, tandis que cout(12) est refusé.

]]> 1.0 0.0 0 true true abc Python signale une erreur, car il manque un argument
à l'appel

]]> Bonne réponse : la fonction attend deux arguments et n'en
reçoit qu'un. Python refuse l'appel en signalant l'argument
absent, ici prix_km.

]]> Le programme affiche 12, la valeur du seul
argument fourni

]]> Erreur : la fonction ne peut pas calculer son produit sans
connaître le prix. Aucun calcul n'a lieu, l'appel est refusé
avant.

]]> Le programme affiche 0, le paramètre absent
valant zéro

]]> Erreur : un paramètre sans argument ne prend aucune valeur par
défaut. Il faut soit fournir l'argument, soit prévoir une
valeur par défaut dans la définition.

]]> Le programme demande la valeur manquante à
l'utilisateur

]]> Erreur : une fonction ne dialogue jamais d'elle-même avec
l'utilisateur. Elle reçoit ses arguments au moment de l'appel,
et seulement là.

]]> Notions transversales de programmation — Q22 : La somme de quatre relevés Un capteur a enregistré quatre températures.

mesures = [18, 20, 22, 24]
total = 0
for m in mesures:
    total = total + m
print(total, len(mesures))

Qu'affiche ce programme ?

]]> Le schéma de l'accumulateur revient sans cesse : une variable mise à 0
avant la boucle, augmentée à chaque tour. Divisé par len, ce total
donne la moyenne.

]]> 1.0 0.0 0 true true abc 24 4

]]> Erreur : 24 est le dernier relevé, pas la somme. La variable total
accumule les quatre valeurs au fil de la boucle.

]]> 84 3

]]> Erreur : len donne le nombre d'éléments, soit 4, et non le plus
grand indice de la liste.

]]> 84 4

]]> Bonne réponse : la boucle ajoute 18, 20, 22 puis 24, ce qui fait 84,
et la liste compte quatre éléments.

]]> 18 4

]]> Erreur : 18 est le premier relevé. La boucle ne s'arrête pas au
premier tour, elle parcourt toute la liste.

]]> Notions transversales de programmation — Q23 : Un maximum jamais trouvé Ce programme cherche la température la plus haute d'une nuit d'hiver.

temperatures = [-3, -8, -1, -5]
maxi = 0
for t in temperatures:
    if t > maxi:
        maxi = t
print(maxi)

Qu'affiche-t-il ?

]]> Initialiser un maximum à 0 revient à supposer que toutes les valeurs
sont positives. Mieux vaut partir du premier élément de la liste, avec
maxi = temperatures[0].

]]> 1.0 0.0 0 true true abc -1

]]> Erreur : c'est la réponse attendue, mais le programme ne la trouve
pas. Aucun relevé ne dépasse la valeur du départ, qui reste donc en
place.

]]> 0

]]> Bonne réponse : les quatre relevés sont négatifs, donc aucun n'est
supérieur à 0. La variable maxi garde la valeur de son
initialisation.

]]> -8

]]> Erreur : c'est le relevé le plus bas, que la comparaison > ne
retient jamais. Le test cherche les valeurs supérieures.

]]> -3

]]> Erreur : c'est le premier relevé, qui aurait servi de point de
départ si l'initialisation avait été mieux choisie. Elle vaut 0.

]]> Notions transversales de programmation — Q24 : Compter les mesures fortes Ce programme doit afficher le nombre de mesures strictement supérieures
à 25.

mesures = [12, 31, 8, 45, 27]
compte = 0
for m in mesures:
    ...
print(compte)

Par quoi remplacer les points de suspension ?

]]> Un compteur avance toujours de 1, quelle que soit la valeur examinée.
C'est ce qui le distingue d'un accumulateur, qui ajoute la valeur
elle-même.

]]> 1.0 0.0 0 true true abc

if m > 25:
    compte = m

]]> Erreur : range la mesure elle-même dans le compteur au lieu de
l'augmenter. Le programme afficherait 27, la dernière mesure
retenue.

]]>

if compte > 25:
    compte = compte + 1

]]> Erreur : teste le compteur au lieu de la mesure. Comme il part de 0
et n'atteint jamais 25, le programme afficherait 0.

]]>

if m > 25:
    compte = compte + m

]]> Erreur : ajoute la valeur de la mesure au lieu d'ajouter 1. Le
programme afficherait 103, la somme des mesures retenues.

]]>

if m > 25:
    compte = compte + 1

]]> Bonne réponse : à chaque mesure supérieure à 25, le compteur avance
de 1. Le programme affiche 3, pour 31, 45 et 27.

]]> Notions transversales de programmation — Q25 : Le volume d'un groupe de discussion Dans un groupe de discussion, chaque membre envoie le même nombre de
messages, et chaque message pèse 2 kilo-octets.

def volume(membres, messages):
    return membres * messages * 2

print(volume(20, 15))

Qu'affiche ce programme ?

]]> Un appel de fonction remplace les paramètres par les arguments donnés,
exécute le corps, puis rend la valeur écrite après return. C'est
cette valeur que print affiche.

]]> 1.0 0.0 0 true true abc 600

]]> Bonne réponse : 20 membres envoient chacun 15 messages, soit 300
messages, et chacun pèse 2 kilo-octets.

]]> 300

]]> Erreur : oublie les 2 kilo-octets par message. C'est le nombre de
messages, et non le volume échangé.

]]> 70

]]> Erreur : additionne les deux paramètres au lieu de les multiplier,
avant de multiplier par 2.

]]> 40

]]> Erreur : ne tient compte que du nombre de membres. Les deux
paramètres interviennent dans le calcul.

]]> Notions transversales de programmation — Q26 : L'ordre des arguments Cette fonction calcule l'écart entre deux bornes kilométriques.

def ecart(depart, arrivee):
    return arrivee - depart

print(ecart(12, 5), ecart(5, 12))

Qu'affiche ce programme ?

]]> Les arguments d'un appel prennent la place des paramètres dans l'ordre
où ils sont écrits. Deux appels aux mêmes valeurs rangées autrement ne
donnent donc pas le même résultat.

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

]]> Erreur : intervertit les deux résultats. Au premier appel, depart
vaut 12 et arrivee vaut 5, donc la soustraction donne un nombre
négatif.

]]> 7 7

]]> Erreur : suppose que la fonction rend toujours un écart positif.
Elle applique la soustraction telle qu'elle est écrite, sans
corriger le signe.

]]> -7 7

]]> Bonne réponse : les arguments prennent la place des paramètres dans
l'ordre, d'où 5 moins 12 au premier appel et 12 moins 5 au second.

]]> -7 -7

]]> Erreur : donne le même signe aux deux appels. Échanger les
arguments change bien le signe du résultat.

]]> Notions transversales de programmation — Q27 : Afficher ou renvoyer Ce programme emploie une fonction qui double une valeur.

def doubler(valeur):
    print(valeur * 2)

resultat = doubler(5)
print(resultat)

Qu'affiche-t-il ?

]]> Afficher et renvoyer sont deux actions distinctes. print montre une
valeur à l'écran, return la rend au programme qui a fait l'appel. Une
fonction sans return rend None.

]]> 1.0 0.0 0 true true abc 10 puis 10

]]> Erreur : suppose que la fonction rend ce qu'elle affiche. Sans
return, l'appel ne rapporte aucune valeur utilisable.

]]> 10 puis None

]]> Bonne réponse : la fonction affiche 10, puis resultat reçoit
None, faute de return. La dernière ligne montre cette absence
de valeur.

]]> 10 seulement

]]> Erreur : oublie la dernière ligne, qui affiche resultat. Elle
s'exécute et montre ce que l'appel a rapporté.

]]> None puis 10

]]> Erreur : inverse l'ordre. L'affichage écrit dans le corps de la
fonction a lieu pendant l'appel, donc avant la dernière ligne.

]]> Notions transversales de programmation — Q28 : Un résultat qui se perd Ce programme veut doubler la largeur d'une image.

def agrandir(valeur):
    valeur = valeur * 2
    return valeur

largeur = 640
agrandir(largeur)
print(largeur)

Qu'affiche-t-il ?

]]> Une fonction travaille sur ses propres variables. Pour conserver ce
qu'elle calcule, il faut ranger la valeur rendue dans une variable au
moment de l'appel.

]]> 1.0 0.0 0 true true abc 1280

]]> Erreur : c'est la valeur calculée par la fonction, mais personne ne
la recueille. Il faudrait écrire largeur = agrandir(largeur).

]]> None

]]> Erreur : la fonction contient bien un return, et de toute façon la
dernière ligne affiche largeur, pas le résultat de l'appel.

]]> 0

]]> Erreur : la variable n'est jamais remise à zéro. Elle garde la
valeur reçue au moment de sa création.

]]> 640

]]> Bonne réponse : le paramètre valeur est une variable propre à la
fonction. La modifier ne change rien à largeur, et le résultat
rendu n'est rangé nulle part.

]]> Notions transversales de programmation — Q29 : Une fonction qui renvoie un booléen Une moyenne n'a de sens qu'à partir de trois relevés.

def assez(liste):
    return len(liste) >= 3

matin = [18, 21]
journee = [18, 21, 22, 25]
print(assez(matin), assez(journee), assez(matin) or assez(journee))

Qu'affiche ce programme ?

]]> Une fonction peut rendre un booléen, qui s'emploie alors comme une
condition ou se combine avec and, or et not. La comparaison
écrite après return est évaluée avant d'être rendue.

]]> 1.0 0.0 0 true true abc False True True

]]> Bonne réponse : matin compte 2 éléments et journee en compte 4.
Le or est vrai dès qu'un seul des deux appels l'est.

]]> False True False

]]> Erreur : or est vrai dès qu'une des deux valeurs l'est, et
l'appel sur journee rend justement True.

]]> True False True

]]> Erreur : intervertit les deux listes. C'est journee, avec ses
quatre éléments, qui atteint le seuil de trois.

]]> False False True

]]> Erreur : journee compte quatre éléments, ce qui est bien
supérieur ou égal à 3. Le deuxième appel rend True.

]]> Notions transversales de programmation — Q30 : Un appel incomplet Ce programme s'arrête sur une erreur au moment de l'appel.

def surface(largeur, hauteur):
    return largeur * hauteur

print(surface(12))

Que reproche Python à ce programme ?

]]> Un appel doit fournir une valeur pour chaque paramètre, dans l'ordre.
Le message d'erreur nomme même le paramètre qui manque, ici hauteur.

]]> 1.0 0.0 0 true true abc La fonction est appelée avant d'avoir été définie dans le fichier

]]> Erreur : la définition est bien écrite avant l'appel. Ce reproche
vaudrait pour un appel placé plus haut dans le fichier, et Python
signalerait alors une NameError.

]]> La valeur 12 n'est pas d'un type admis pour une multiplication

]]> Erreur : 12 est un entier, parfaitement multipliable. Le calcul n'a
même pas lieu, l'appel échouant avant.

]]> La fonction attend deux paramètres, or un seul argument est fourni

]]> Bonne réponse : Python signale

TypeError: surface() missing 1

required positional argument: 'hauteur'

. Il faut fournir autant
d'arguments que de paramètres.

]]> La fonction ne renvoie rien, donc print n'a rien à afficher

]]> Erreur : la fonction contient un return et rendrait bien une
valeur si l'appel aboutissait. L'erreur survient avant.

]]>