$course$/QCM de NSI/SNT/8. Listes Créer une liste, lire et modifier un élément par son indice, qui
commence à 0 ; la longueur avec len ; ajouter avec append ; tester
la présence avec in ; parcourir une liste avec for, par éléments ou
par indices ; calculer une somme, un maximum, un effectif. En
coordination avec le programme de mathématiques de seconde.

]]> 8. Listes — Q01 : Lire un élément

notes = [12, 15, 9, 18]
print(notes[1])

Qu'affiche ce programme ?

]]> Une liste range ses éléments à des positions numérotées à partir de
0. notes[1] est le deuxième élément, notes[0] le premier.

]]> 1.0 0.0 0 true true abc 15

]]> Bonne réponse : les indices commencent à 0. L'indice 1 désigne
le deuxième élément, 15.

]]> 12

]]> Erreur : 12 est à l'indice 0, le premier.

]]> 1

]]> Erreur : notes[1] renvoie l'élément rangé à l'indice 1, pas
l'indice lui-même.

]]> 9

]]> Erreur : 9 est à l'indice 2.

]]> 8. Listes — Q02 : Le nombre d'éléments

villes = ["Lyon", "Paris", "Nice"]
print(len(villes))

Qu'affiche ce programme ?

]]> len renvoie le nombre d'éléments d'une liste. Les indices valides
vont de 0 à len(liste) - 1.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : len compte les éléments de la liste, trois
chaînes.

]]> 2

]]> Erreur : 2 est le plus grand indice, mais il y a trois
éléments.

]]> 4

]]> Erreur : la liste contient trois chaînes.

]]> 14

]]> Erreur : len ne compte pas les caractères des chaînes, mais
les éléments de la liste.

]]> 8. Listes — Q03 : Ajouter à la fin

panier = ["pain"]
panier.append("lait")
print(panier)

Qu'affiche ce programme ?

]]> liste.append(x) ajoute x à la fin de la liste. La liste est
modifiée sur place : il n'y a rien à réaffecter.

]]> 1.0 0.0 0 true true abc ['pain', 'lait']

]]> Bonne réponse : append ajoute l'élément à la fin de la liste,
qui est modifiée.

]]> ['lait', 'pain']

]]> Erreur : append ajoute toujours à la fin, jamais au début.

]]> ['pain']

]]> Erreur : append modifie bien la liste, sans qu'il soit
nécessaire de réaffecter.

]]> pain lait

]]> Erreur : print affiche une liste entre crochets, avec ses
chaînes entre apostrophes.

]]> 8. Listes — Q04 : Un indice trop grand

t = [4, 8, 15]
print(t[3])

Que se passe-t-il ?

]]> Le plus grand indice d'une liste est len(liste) - 1. Le dépasser
déclenche IndexError: list index out of range, une erreur très
courante.

]]> 1.0 0.0 0 true true abc Une erreur, les indices de cette liste vont de 0 à 2

]]> Bonne réponse : trois éléments occupent les indices 0, 1 et 2.
L'indice 3 n'existe pas, d'où une erreur IndexError.

]]> Python affiche 15, le dernier élément

]]> Erreur : le dernier élément est à l'indice 2, pas 3.

]]> Python affiche None, il n'y a rien à cet indice

]]> Erreur : un indice hors de la liste provoque une erreur, pas
une valeur vide.

]]> Python affiche 0, valeur par défaut d'une case vide

]]> Erreur : il n'y a pas de case vide, la liste s'arrête à
l'indice 2.

]]> 8. Listes — Q05 : Modifier un élément Un programme retouche la première composante d'un pixel.

pixel = [10, 20, 30]
pixel[0] = 255
print(pixel)

Qu'affiche ce programme ?

]]> liste[i] = valeur remplace l'élément d'indice i. La longueur de
la liste ne change pas.

]]> 1.0 0.0 0 true true abc [255, 20, 30]

]]> Bonne réponse : l'affectation pixel[0] = 255 remplace
l'élément d'indice 0.

]]> [10, 255, 30]

]]> Erreur : l'indice 0 désigne le premier élément.

]]> [255, 10, 20, 30]

]]> Erreur : l'affectation par indice remplace, elle n'insère pas.

]]> Une erreur, une liste ne se modifie pas

]]> Erreur : une liste est modifiable, élément par élément.

]]> 8. Listes — Q06 : Parcourir une liste

for v in [3, 5, 7]:
    print(v * 2)

Qu'affiche ce programme ?

]]> for v in liste donne à v chaque élément à son tour, du premier au
dernier. C'est la façon la plus simple de traiter tous les éléments.

]]> 1.0 0.0 0 true true abc 6, 10 et 14

]]> Bonne réponse : v prend successivement chaque élément, et son
double est affiché.

]]> 3, 5 et 7

]]> Erreur : chaque élément est multiplié par 2 avant l'affichage.

]]> 0, 2 et 4

]]> Erreur : v reçoit les éléments de la liste, pas leurs
indices.

]]> 6, 10, 14, 6, 10 et 14

]]> Erreur : la liste est parcourue une seule fois, trois tours.

]]> 8. Listes — Q07 : Une moyenne

releves = [12, 15, 9, 18]
total = 0
for r in releves:
    total = total + r
print(total / len(releves))

Qu'affiche ce programme ?

]]> La moyenne combine un accumulateur pour la somme et len pour
l'effectif. Le même schéma sert pour n'importe quelle liste de
nombres.

]]> 1.0 0.0 0 true true abc 13.5

]]> Bonne réponse : la somme vaut 54, divisée par 4 éléments.

]]> 54.0

]]> Erreur : 54 est la somme, mais le programme la divise par la
longueur.

]]> 13.0

]]> Erreur : la division / ne tronque pas, 54 divisé par 4 vaut
13.5.

]]> 18.0

]]> Erreur : 18 est le dernier élément, pas la moyenne.

]]> 8. Listes — Q08 : Tester la présence

inscrits = ["Ana", "Bob", "Chloé"]
print("bob" in inscrits)

Qu'affiche ce programme ?

]]> x in liste vaut True si un élément de la liste est égal à x.
L'égalité est exacte, majuscules comprises.

]]> 1.0 0.0 0 true true abc False

]]> Bonne réponse : in cherche un élément exactement égal, et
"bob" diffère de "Bob" par sa majuscule.

]]> True

]]> Erreur : la comparaison des chaînes distingue majuscules et
minuscules.

]]> 1

]]> Erreur : in renvoie un booléen, pas une position.

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

]]> Erreur : in teste si une valeur figure dans la liste, quel que
soit son type.

]]> 8. Listes — Q09 : Chercher le maximum

temp = [18, 24, 21, 27, 19]
maxi = temp[0]
for t in temp:
    if t > maxi:
        maxi = t
print(maxi)

Qu'affiche ce programme ?

]]> Pour trouver le plus grand élément, on part du premier et on parcourt
la liste en remplaçant le maximum courant dès qu'on trouve mieux.
Partir du premier élément évite de choisir une valeur arbitraire.

]]> 1.0 0.0 0 true true abc 27

]]> Bonne réponse : maxi part du premier élément et est remplacé à
chaque valeur plus grande, 24 puis 27.

]]> 18

]]> Erreur : 18 est la valeur de départ, dépassée par une valeur
plus grande.

]]> 19

]]> Erreur : 19 est le dernier élément, mais il ne dépasse pas 27.

]]> 5

]]> Erreur : 5 est le nombre d'éléments, pas le maximum.

]]> 8. Listes — Q10 : Parcourir par indices

mots = ["a", "b", "c"]
for i in range(len(mots)):
    print(i, mots[i])

Qu'affiche ce programme ?

]]> Parcourir par indices avec range(len(liste)) donne accès à la
position de chaque élément, ce qui est utile pour modifier la liste
ou comparer des voisins.

]]> 1.0 0.0 0 true true abc 0 a, 1 b et 2 c

]]> Bonne réponse : range(len(mots)) fournit les indices 0, 1 et
2, et mots[i] l'élément correspondant.

]]> 1 a, 2 b et 3 c

]]> Erreur : les indices commencent à 0.

]]> a, b et c

]]> Erreur : le programme affiche aussi l'indice, avant l'élément.

]]> 0, 1 et 2

]]> Erreur : chaque ligne contient l'indice et l'élément.

]]> 8. Listes — Q11 : Construire une liste dans une boucle

carres = []
for n in range(1, 5):
    carres.append(n * n)
print(carres)

Qu'affiche ce programme ?

]]> Une liste vide suivie d'un append à chaque tour est le schéma pour
construire une liste. Elle s'allonge d'un élément par tour.

]]> 1.0 0.0 0 true true abc [1, 4, 9, 16]

]]> Bonne réponse : on part d'une liste vide et on ajoute les carrés
de 1, 2, 3 et 4.

]]> [0, 1, 4, 9]

]]> Erreur : range(1, 5) commence à 1, pas à 0.

]]> [1, 4, 9, 16, 25]

]]> Erreur : 5 est exclu par range(1, 5).

]]> [16]

]]> Erreur : append ajoute sans effacer les éléments précédents.

]]> 8. Listes — Q12 : Compter au-dessus d'un seuil

mesures = [31, 28, 35, 40, 22]
n = 0
for m in mesures:
    if m > 30:
        n = n + 1
print(n)

Qu'affiche ce programme ?

]]> Le compteur conditionnel s'applique aux listes comme aux range :
on parcourt les éléments et on ajoute 1 quand le test est vrai.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : 31, 35 et 40 dépassent 30.

]]> 2

]]> Erreur : 31 est strictement supérieur à 30, il compte.

]]> 4

]]> Erreur : 28 et 22 ne dépassent pas 30.

]]> 106

]]> Erreur : 106 est la somme des valeurs retenues, mais le
programme les compte, il ne les additionne pas.

]]> 8. Listes — Q13 : Le dernier élément

t = [7, 3, 9, 4]
print(t[len(t) - 1])

Qu'affiche ce programme ?

]]> Le dernier élément est à l'indice len(liste) - 1, puisque la
numérotation commence à 0. C'est un calcul à connaître.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : len(t) vaut 4, donc len(t) - 1 vaut 3,
l'indice du dernier élément.

]]> 9

]]> Erreur : 9 est à l'indice 2, l'avant-dernier.

]]> 3

]]> Erreur : 3 est la valeur de l'indice calculé, pas l'élément qui
s'y trouve.

]]> Une erreur, l'indice 4 n'existe pas

]]> Erreur : l'indice calculé est 3, pas 4, grâce au - 1.

]]> 8. Listes — Q14 : Une liste de chaînes

codes = ["12", "7"]
print(codes[0] + codes[1])

Qu'affiche ce programme ?

]]> Une liste peut contenir des chaînes, des nombres ou des booléens.
Chaque élément garde son type, et les opérateurs se comportent en
conséquence.

]]> 1.0 0.0 0 true true abc 127

]]> Bonne réponse : les éléments sont des chaînes, + les
concatène.

]]> 19

]]> Erreur : 19 supposerait des entiers. Entre guillemets, ce sont
des chaînes.

]]> 12 7

]]> Erreur : la concaténation n'insère pas d'espace.

]]> Une erreur, on n'additionne pas des éléments de liste

]]> Erreur : un élément de liste s'utilise comme n'importe quelle
valeur de son type.

]]> 8. Listes — Q15 : Modifier tous les éléments

val = [1, 2, 3]
for i in range(len(val)):
    val[i] = val[i] * 10
print(val)

Qu'affiche ce programme ?

]]> Pour modifier les éléments d'une liste, on parcourt les indices et
on réaffecte liste[i]. C'est le rôle du parcours par indices.

]]> 1.0 0.0 0 true true abc [10, 20, 30]

]]> Bonne réponse : à chaque tour, l'élément d'indice i est
remplacé par son produit par 10.

]]> [1, 2, 3]

]]> Erreur : l'affectation val[i] = ... modifie bien la liste.

]]> [10, 10, 10]

]]> Erreur : chaque élément est multiplié par 10, ils restent
différents.

]]> [0, 10, 20]

]]> Erreur : on multiplie les valeurs, pas les indices.

]]> 8. Listes — Q16 : Un parcours qui ne modifie rien

val = [1, 2, 3]
for v in val:
    v = v * 10
print(val)

Qu'affiche ce programme ?

]]> Dans for v in val, la variable v est une copie de l'élément.
Modifier v ne touche pas la liste ; il faut passer par les indices
pour la changer.

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

]]> Bonne réponse : v reçoit une copie de chaque élément. La
modifier ne change pas la liste.

]]> [10, 20, 30]

]]> Erreur : pour modifier la liste, il faut réaffecter val[i],
pas la variable de boucle.

]]> [30]

]]> Erreur : la liste n'est ni réduite ni modifiée.

]]> Une erreur, v n'est pas modifiable

]]> Erreur : v est une variable ordinaire, on peut la modifier,
mais sans effet sur la liste.

]]> 8. Listes — Q17 : Longueur après ajouts

l = [5, 6]
l.append(7)
l.append(8)
print(len(l), l[2])

Qu'affiche ce programme ?

]]> Chaque append ajoute un élément à la fin et augmente la longueur de
1. Le nouvel élément prend l'indice len - 1.

]]> 1.0 0.0 0 true true abc 4 7

]]> Bonne réponse : deux ajouts portent la longueur à 4, et
l'élément d'indice 2 est 7.

]]> 4 8

]]> Erreur : 8 est à l'indice 3, le dernier.

]]> 2 7

]]> Erreur : len compte les éléments après les ajouts.

]]> 3 7

]]> Erreur : deux append ajoutent deux éléments.

]]> 8. Listes — Q18 : Dépouiller un sondage

reponses = ["oui", "non", "oui", "oui"]
c = 0
for r in reponses:
    if r == "oui":
        c = c + 1
print(c, len(reponses) - c)

Qu'affiche ce programme ?

]]> Compter les éléments égaux à une valeur est un compteur
conditionnel. Le complément s'obtient avec len, sans second
parcours.

]]> 1.0 0.0 0 true true abc 3 1

]]> Bonne réponse : 3 oui, et le reste, 4 moins 3, soit 1
non.

]]> 1 3

]]> Erreur : le compteur compte les oui, qui sont 3.

]]> 3 4

]]> Erreur : le second nombre est len(reponses) - c, soit 1.

]]> 4 3

]]> Erreur : c ne compte que les oui.

]]> 8. Listes — Q19 : Une liste vide

l = []
print(len(l), l)

Qu'affiche ce programme ?

]]> [] est la liste vide : longueur 0, aucun indice valide. On la
remplit ensuite avec append.

]]> 1.0 0.0 0 true true abc 0 []

]]> Bonne réponse : une liste vide a zéro élément et s'affiche
[].

]]> Une erreur, une liste ne peut pas être vide

]]> Erreur : la liste vide existe, c'est le point de départ habituel
avant des append.

]]> [] 0

]]> Erreur : len(l) est affiché en premier.

]]> None

]]> Erreur : [] est une liste, pas l'absence de valeur.

]]> 8. Listes — Q20 : Échanger deux éléments

t = [1, 2, 3]
tmp = t[0]
t[0] = t[2]
t[2] = tmp
print(t)

Qu'affiche ce programme ?

]]> L'échange de deux éléments suit le schéma de l'échange de deux
variables, avec une variable temporaire. C'est l'opération de base
des algorithmes de tri.

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

]]> Bonne réponse : tmp garde 1, le premier élément reçoit 3, et
le dernier récupère 1.

]]> [1, 2, 3]

]]> Erreur : les deux affectations modifient bien les éléments.

]]> [3, 2, 3]

]]> Erreur : t[2] = tmp remet la valeur sauvegardée, 1, à la fin.

]]> [1, 2, 1]

]]> Erreur : t[0] = t[2] donne 3 au premier élément.

]]> 8. Listes — Q21 : Deux listes mises bout à bout Qu'affiche print([1, 2] + [3]) ?

]]> Comme pour les chaînes, + concatène les listes : le résultat
contient les éléments de la première puis ceux de la seconde.

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

]]> Bonne réponse : + entre deux listes les met bout à bout, dans
l'ordre, en une seule liste.

]]> [[1, 2], [3]]

]]> Erreur : + ne crée pas une liste de listes, il enchaîne les
éléments.

]]> [1, 2, 3, 3]

]]> Erreur : aucun élément n'est dupliqué ni additionné, les listes
sont simplement enchaînées.

]]> 6

]]> Erreur : + entre listes ne calcule pas la somme des éléments.

]]> 8. Listes — Q22 : La somme d'une liste Qu'affiche print(sum([4, 8, 5])) ?

]]> sum, len, max et min sont des fonctions prêtes à l'emploi
sur les listes de nombres.

]]> 1.0 0.0 0 true true abc 17

]]> Bonne réponse : sum additionne tous les éléments de la liste.

]]> 3

]]> Erreur : 3 est le nombre d'éléments, donné par len.

]]> 8

]]> Erreur : 8 est le plus grand élément, donné par max.

]]> 5

]]> Erreur : 5 est le dernier élément, pas la somme.

]]> 8. Listes — Q23 : Une liste remplie de zéros Qu'affiche print([0] * 3) ?

]]> [valeur] * n est la façon la plus simple de créer une liste de
n cases toutes identiques.

]]> 1.0 0.0 0 true true abc [0, 0, 0]

]]> Bonne réponse : multiplier une liste par un entier la répète.
[0] * 3 contient 3 zéros.

]]> [3]

]]> Erreur : la multiplication ne change pas les éléments, elle les
répète.

]]> [0, 3]

]]> Erreur : 3 n'est pas ajouté à la liste, il indique combien de
fois elle est répétée.

]]> 0

]]> Erreur : le résultat est une liste, pas un nombre.

]]> 8. Listes — Q24 : Le plus petit élément Qu'affiche print(min([4, 2, 9])) ?

]]> min et max parcourent la liste pour trouver ses extrêmes, sans
se soucier de l'ordre des éléments.

]]> 1.0 0.0 0 true true abc 2

]]> Bonne réponse : min renvoie le plus petit élément de la liste.

]]> 9

]]> Erreur : 9 est le plus grand, donné par max.

]]> 4

]]> Erreur : 4 est le premier élément, pas forcément le plus
petit.

]]> 3

]]> Erreur : 3 est le nombre d'éléments.

]]> 8. Listes — Q25 : Deux éléments additionnés Qu'affiche ce programme ?

liste = [5, 10, 20, 40]
print(liste[0] + liste[2])

]]> L'indice 0 désigne le premier élément, l'indice 2 le troisième.
Cette règle vaut pour toute liste.

]]> 1.0 0.0 0 true true abc 25

]]> Bonne réponse : liste[0] est le premier élément et liste[2]
le troisième, les indices commençant à 0.

]]> 15

]]> Erreur : c'est la somme des deux premiers éléments, aux indices
0 et 1.

]]> 50

]]> Erreur : c'est la somme des éléments d'indices 1 et 3, comme si
les indices commençaient à 1.

]]> 2

]]> Erreur : les indices servent à désigner des éléments, ce ne sont
pas eux qui sont additionnés.

]]> 8. Listes — Q26 : La longueur d'une liste de mots Qu'affiche print(len(['abc', 'de'])) ?

]]> len d'une liste compte ses éléments ; len d'une chaîne compte
ses caractères. Tout dépend de ce qu'on lui donne.

]]> 1.0 0.0 0 true true abc 2

]]> Bonne réponse : len compte les éléments de la liste, ici des
chaînes, quelle que soit leur longueur.

]]> 5

]]> Erreur : 5 est le nombre total de lettres, mais len
appliqué à la liste compte ses éléments.

]]> 3

]]> Erreur : 3 est la longueur du premier mot, pas celle de la
liste.

]]> Une erreur, len ne s'appliquant qu'aux chaînes

]]> Erreur : len s'applique aussi aux listes.

]]> 8. Listes — Q27 : Une somme calculée par indices Qu'affiche ce programme ?

liste = [3, 5, 9, 1]
s = 0
for i in range(len(liste)):
    s = s + liste[i]
print(s)

]]> Parcourir par indices avec range(len(liste)) permet d'accéder à
chaque élément par liste[i].

]]> 1.0 0.0 0 true true abc 18

]]> Bonne réponse : i parcourt les indices de 0 à 3, et
liste[i] désigne chaque élément, tous additionnés dans s.

]]> 6

]]> Erreur : ce serait la somme des indices, mais c'est liste[i]
qui est ajouté, pas i.

]]> 4

]]> Erreur : 4 est le nombre de tours, pas la somme des éléments.

]]> 1

]]> Erreur : s accumule tous les éléments, pas seulement le
dernier.

]]> 8. Listes — Q28 : Deux noms pour une même liste Qu'affiche ce programme ?

a = [1, 2]
b = a
b.append(3)
print(a)

]]> Affecter une liste à une autre variable crée un alias, pas une
copie. Pour obtenir une copie indépendante, il faut construire une
nouvelle liste.

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

]]> Bonne réponse : b = a ne copie pas la liste, les deux noms
désignent la même liste. L'ajout fait par b se voit par a.

]]> [1, 2]

]]> Erreur : il n'y a qu'une seule liste, modifiée par append,
quel que soit le nom utilisé.

]]> [3]

]]> Erreur : append ajoute à la fin, il ne remplace pas le
contenu.

]]> Une erreur, b ne pouvant modifier une liste créée par a

]]> Erreur : rien n'interdit la modification, et c'est bien la même
liste qui change.

]]> 8. Listes — Q29 : Un élément dans une liste de listes Qu'affiche ce programme ?

notes = [[12, 15], [9, 11]]
print(notes[1][0])

]]> Dans une liste de listes, le premier indice choisit la sous-liste,
le second l'élément dans cette sous-liste.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : notes[1] est la seconde liste, et [0] en
prend le premier élément.

]]> 15

]]> Erreur : ce serait notes[0][1], les deux indices ont été
échangés.

]]> 12

]]> Erreur : ce serait notes[0][0], le premier élément de la
première liste.

]]> [9, 11]

]]> Erreur : notes[1] seul donnerait cette liste, mais le second
indice en extrait un élément.

]]> 8. Listes — Q30 : La dernière position d'une valeur Qu'affiche ce programme ?

liste = [6, 7, 6, 9, 6]
pos = -1
for i in range(len(liste)):
    if liste[i] == 6:
        pos = i
print(pos)

]]> Sans arrêt anticipé, la boucle parcourt toute la liste : la
variable garde la trace de la dernière rencontre.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : pos est réécrit à chaque rencontre de 6. À
la fin, il garde l'indice de la dernière rencontre, 4.

]]> 0

]]> Erreur : 0 est l'indice de la première rencontre, mais la
boucle continue et écrase pos.

]]> 3

]]> Erreur : 3 est le nombre de fois où 6 apparaît, mais pos
reçoit un indice, pas un compte.

]]> 6

]]> Erreur : c'est l'indice qui est mémorisé, pas la valeur
cherchée.

]]>