$course$/QCM de NSI/Première/Tuples et listes Types construits : tuples (immuables) et listes
(mutables), création, accès par indice, parcours,
ajout avec append, longueur avec len, tranches,
différences entre tuples et listes, cas d'usage,
découpage (slicing), affectation multiple.

]]> Tuples et listes — Q01 : Création d'une liste Comment crée-t-on une liste vide en
Python ?

]]> Trois conteneurs natifs principaux
sont à distinguer : les listes
(avec []), les tuples (avec
()) et les dictionnaires (avec
{}). Ils diffèrent par leur
mutabilité, leur ordre et leur
mode d'accès.

]]> 1.0 0.0 0 true true abc Avec la syntaxe liste = []

]]> On utilise les crochets pour
délimiter une liste. Une forme
équivalente consiste à écrire
liste = list().

]]> Avec la syntaxe liste = ()

]]> Cette syntaxe crée un tuple
vide, et non une liste.

]]> Avec la syntaxe liste = {}

]]> Les accolades sont utilisées
pour les dictionnaires ou
les ensembles, et non pour les
listes.

]]> Avec la syntaxe liste = null

]]> Le mot-clé null n'existe pas
en Python ; l'équivalent
s'appelle None, qui ne
représente d'ailleurs pas une
liste.

]]> Tuples et listes — Q02 : Création d'un tuple Comment crée-t-on un tuple en
Python ?

]]> Une distinction subtile : (1) est
simplement l'entier 1 entouré
de parenthèses de groupement,
tandis que (1,) est un tuple à
un seul élément. C'est la
virgule, et non les parenthèses,
qui crée le tuple.

]]> 1.0 0.0 0 true true abc Avec t = tuple[1, 2, 3], crochets après le mot tuple

]]> Erreur : tuple[...] avec des crochets
est une annotation de type, pas une
création de tuple. Pour convertir une
liste, on écrit tuple([1, 2, 3]).

]]> Avec t = (1, 2, 3), ou même t = 1, 2, 3

]]> Bonne réponse : les parenthèses sont
souvent facultatives ; ce sont les
virgules qui définissent un tuple. Le
tuple vide s'écrit () et, pour un
seul élément, la virgule est
obligatoire : t = (1,).

]]> Avec t = {1, 2, 3}, les accolades regroupant les éléments

]]> Erreur : les accolades autour de
plusieurs éléments séparés par des
virgules créent un ensemble, un
autre type de collection qui n'est
pas au programme de première, et
non un tuple.

]]> Avec t = [1, 2, 3], puis t.freeze() pour le figer

]]> Erreur : les crochets créent une liste,
et aucune méthode freeze n'existe. La
conversion se fait avec tuple(liste).

]]> Tuples et listes — Q03 : Mutabilité Quelle est la différence fondamentale entre un tuple et
une liste ?

]]> La mutabilité désigne la
possibilité d'être modifié.
L'instruction liste.append(x)
modifie la liste sur place. Sur
un tuple, l'appel
tuple.append(x) provoque une
exception AttributeError.

]]> 1.0 0.0 0 true true abc Un tuple contient forcément exactement deux éléments

]]> Aucune contrainte sur le
nombre d'éléments : un tuple
peut en contenir zéro, un, ou
beaucoup.

]]> Aucune différence, seule la notation change

]]> Erreur : la notation diffère, mais
surtout le comportement : une liste se
modifie sur place, un tuple jamais.

]]> La liste est modifiable, le tuple ne l'est pas

]]> Bonne réponse : une liste est
mutable, un tuple immuable
(figé). En conséquence, les tuples
peuvent être utilisés comme
clés de dictionnaire, ce que
les listes ne peuvent pas
faire. Les tuples sont
également un peu plus rapides
à manipuler.

]]> Un tuple ne contient que des nombres, une liste tout type

]]> Erreur : un tuple accepte n'importe quels
objets, comme une liste (("a", 1, [2])
est valide). La différence concerne la
mutabilité.

]]> Tuples et listes — Q04 : Accès par indice Que renvoie l'expression
["a", "b", "c"][1] ?

]]> Une indexation négative est aussi
possible : liste[-1] désigne le
dernier élément, liste[-2]
l'avant-dernier, et ainsi de
suite. C'est très utile pour
accéder à la fin d'une liste sans
avoir à connaître sa longueur.

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

]]> La chaîne "c" se trouve à
l'indice 2, et non à
l'indice 1.

]]> La chaîne "b"

]]> L'indice 1 correspond au
deuxième élément de la liste.
C'est la convention standard
des langages indexés à partir
de 0.

]]> La chaîne "a"

]]> En Python, l'indexation
commence à 0. L'élément
d'indice 0 est donc "a",
et l'élément d'indice 1 est
"b".

]]> Une exception est levée

]]> L'indice 1 est valide pour
une liste de trois éléments :
aucune exception n'est levée.

]]> Tuples et listes — Q05 : Longueur d'une séquence Comment obtient-on la longueur
d'une liste ou d'un tuple ?

]]> La fonction len s'exécute en
O(1), car la longueur est
stockée à part. L'expression
len([]) vaut 0, ce qui
permet de tester rapidement si
une liste est vide.

]]> 1.0 0.0 0 true true abc Avec liste.size()

]]> La méthode size n'existe
pas en Python. Elle vient du
monde C++.

]]> Avec liste.length

]]> L'attribut length n'existe
pas en Python. Cette syntaxe
provient de JavaScript ou de
Java.

]]> Avec len(liste)

]]> La fonction native len
fonctionne sur tous les
conteneurs standard : listes,
tuples, chaînes,
dictionnaires, ensembles.

]]> Avec size(liste)

]]> Aucune fonction size
n'existe dans la
bibliothèque standard de
Python.

]]> Tuples et listes — Q06 : Ajouter à une liste Comment ajoute-t-on l'élément
42 à la fin d'une liste liste ?

]]> Différence importante : la
méthode append modifie la
liste sur place, alors que
l'opérateur + crée une
nouvelle liste. Pour ajouter
plusieurs éléments d'un coup, on
écrit liste = liste + [4, 5, 6].

]]> 1.0 0.0 0 true true abc Avec liste += 42

]]> L'opérateur += attend un
itérable, pas un entier.
L'écriture liste += [42]
fonctionnerait, mais reste
moins idiomatique
qu'append.

]]> Avec liste = liste + 42

]]> L'opérateur + ne sait pas
combiner une liste avec un
entier ; il déclenche une
exception TypeError.

]]> Avec liste.append(42)

]]> Cette méthode modifie la
liste sur place. Par
exemple, après
liste = [1, 2]; liste.append(3),
la liste vaut [1, 2, 3].

]]> Avec liste.add(42)

]]> La méthode add est définie
pour les ensembles, mais pas
pour les listes.

]]> Tuples et listes — Q07 : Parcours d'une liste Comment parcourt-on tous les
éléments d'une liste pour les
afficher ?

]]> Pour parcourir une liste avec un
indice, on écrit
for i in range(len(liste)):.
On dispose alors à la fois de
l'indice i et de la valeur
liste[i] à chaque tour de boucle.

]]> 1.0 0.0 0 true true abc `python
for i in liste.length:
print(liste[i])
`

]]> L'attribut length n'existe
pas en Python, et
for i in nombre: n'est pas
une syntaxe valide.

]]> `python
print liste
`

]]> Cette syntaxe correspond à
Python 2. En Python 3,
print est une fonction et
requiert des parenthèses.

]]> `python
for x in liste:
print(x)
`

]]> C'est la forme idiomatique
en Python. La variable x
reçoit successivement chacun
des éléments de la liste.

]]> `python
while liste:
print(liste)
`

]]> Cette boucle est infinie tant
qu'on ne retire pas des
éléments à la liste, et elle
n'affiche pas les éléments
un par un.

]]> Tuples et listes — Q08 : Test d'appartenance Comment teste-t-on si l'élément
42 est présent dans une liste
liste ?

]]> Deux méthodes utiles existent
par ailleurs : liste.index(42)
renvoie l'indice de la première
occurrence, ou lève une
exception ValueError si
l'élément n'est pas présent ;
liste.count(42) compte le
nombre d'occurrences.

]]> 1.0 0.0 0 true true abc Avec liste.has(42)

]]> Aucune méthode de ce nom
n'existe pour les listes en
Python.

]]> Avec 42 in liste

]]> L'opérateur in renvoie un
booléen indiquant la
présence ou l'absence de
l'élément. Sur une liste,
cette opération s'exécute en
O(n) par parcours.

]]> Avec liste.find(42)

]]> La méthode find est définie
pour les chaînes de
caractères, mais pas pour les
listes.

]]> Avec liste.contains(42)

]]> La méthode contains
n'existe pas en Python.

]]> Tuples et listes — Q09 : Quand utiliser un tuple ? Dans quel cas préfère-t-on un
tuple à une liste ?

]]> Cas d'usage typiques d'un tuple :
coordonnées comme (x, y),
retours multiples d'une fonction
avec return a, b, ou
enregistrement comme
("Alice", 17, "Lyon").

]]> 1.0 0.0 0 true true abc Uniquement pour stocker des valeurs numériques entières

]]> Aucune restriction sur le
type des éléments. Un tuple
peut contenir des chaînes,
des objets, ou tout autre
type.

]]> Pour des données qui ne doivent pas être modifiées (constantes, coordonnées)

]]> Le tuple offre la sécurité
(l'immuabilité empêche les
modifications
accidentelles), une légère
efficacité supplémentaire,
et permet l'usage comme clé
de dictionnaire.

]]> Pour économiser quelques touches au clavier

]]> Cette motivation est trop
superficielle. Le choix
entre tuple et liste est
d'abord d'ordre conceptuel.

]]> Pour stocker des données qui changent souvent au cours du programme

]]> Pour des données dynamiques,
la liste est plus adaptée
puisqu'elle est mutable.

]]> Tuples et listes — Q10 : Trace simple Que produit ce code ?
`python
l = [1, 2, 3]
l.append(4)
print(len(l))
`

]]> La méthode append modifie la
liste sur place. Il ne faut pas
écrire l = l.append(4) :
append ne renvoie rien (la
valeur renvoyée est None),
donc l se retrouverait à
None.

]]> 1.0 0.0 0 true true abc Il affiche 5

]]> On ajoute un seul élément
à une liste qui en contenait
trois : la longueur passe
de 3 à 4, et non à 5.

]]> Il affiche 3

]]> Cette réponse ignore l'ajout
de l'élément 4 par la
méthode append.

]]> Il affiche 4

]]> La liste initiale est
[1, 2, 3]. Après
l.append(4), elle vaut
[1, 2, 3, 4], donc sa
longueur est 4.

]]> Il déclenche une exception

]]> Le code est parfaitement
valide.

]]> Tuples et listes — Q11 : Découpage d'une liste Que renvoie l'expression
[1, 2, 3, 4, 5][1:4] ?

]]> Convention Python : la borne
basse est incluse, la borne
haute est exclue. C'est cohérent
avec range(a, b). Une borne
omise vaut le début ou la fin :
[1, 2, 3, 4, 5][:2] donne
[1, 2] et [1, 2, 3, 4, 5][2:]
donne [3, 4, 5].

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

]]> L'indice 1 commence au
deuxième élément. La borne
basse est inclusive, donc
on commence par l'élément à
l'indice 1.

]]> La liste [2, 3, 4]

]]> La syntaxe liste[a:b]
extrait les éléments de
l'indice a (inclus) à
l'indice b (exclu). Les
indices 1, 2 et 3
correspondent ici aux
éléments 2, 3 et 4.

]]> La liste [1, 4]

]]> Le découpage extrait une
tranche continue, et non
deux éléments isolés.

]]> La liste [2, 3, 4, 5]

]]> La borne haute est
exclue par convention.
On ne prend donc pas
l'élément d'indice 4
(qui est 5).

]]> Tuples et listes — Q12 : Affectation multiple Quelles sont les valeurs de a,
b et c après l'instruction
(a, b, c) = (1, 2, 3) ?

]]> Une variante plus avancée
utilise l'astérisque pour
capturer une partie variable :
a, *reste = [1, 2, 3, 4]
affecte a = 1 et
reste = [2, 3, 4].

]]> 1.0 0.0 0 true true abc Le tuple ((1, 2, 3),)

]]> Aucune imbrication ne se
produit ici. Chaque variable
reçoit une seule valeur.

]]> a = 1, b = 1, c = 1

]]> L'affectation multiple
attribue chaque valeur du
tuple de droite à la variable
correspondante de gauche, et
non la même valeur à toutes.

]]> a = 1, b = 2, c = 3

]]> C'est ce qu'on appelle le
dépaquetage d'un tuple.
Les parenthèses peuvent
être omises :
a, b, c = 1, 2, 3. Cette
écriture est très utile,
notamment pour échanger
deux variables :
a, b = b, a.

]]> Une exception est levée

]]> Le code est parfaitement
valide.

]]> Tuples et listes — Q13 : Retirer le dernier élément On dispose de l = [10, 20, 30]. Quelle expression
fournit une nouvelle liste contenant tous les
éléments de l sauf le dernier, quelle que soit la
longueur de l ?

]]> Dans une tranche l[debut:fin], la borne de fin est
exclue et peut être négative : l[:-1] s'arrête
juste avant le dernier élément. Le résultat est une
nouvelle liste, la liste d'origine reste intacte.

]]> 1.0 0.0 0 true true abc l[1:]

]]> Erreur : cette tranche part de l'indice 1 et
retire donc le premier élément. Sur
l'exemple, elle vaut [20, 30].

]]> l[:-1]

]]> Bonne réponse : la borne haute -1 désigne le
dernier élément, exclu de la tranche. On obtient
[10, 20] dans une nouvelle liste ; l n'est
pas modifiée.

]]> l[:-2]

]]> Erreur : la borne haute étant exclue, -2
retire les deux derniers éléments. Sur
l'exemple, la tranche vaut [10].

]]> l[-1]

]]> Erreur : sans deux-points, les crochets font un
accès par indice, pas une tranche. l[-1] est
le dernier élément lui-même, ici 30.

]]> Tuples et listes — Q14 : Piège de la valeur par défaut mutable ``python
def f(l=[]):
l.append(1)
return l

print(f())
print(f())
``
Quel est le résultat de l'exécution
de ce code ?

]]> C'est l'un des plus célèbres
pièges de Python. Il découle
directement de la mutabilité
des listes et de la manière
dont Python évalue les valeurs
par défaut.

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

]]> Cette réponse ignore le fait
que la valeur par défaut est
partagée entre les appels
successifs.

]]> `
[]
[]
`

]]> Cette réponse ignore les
appels à append, qui
ajoutent bien un élément
à chaque appel de f.

]]> `
[1]
[1, 1]
`

]]> La liste par défaut est créée
une seule fois, à la
définition de la fonction.
Les appels successifs
partagent donc la même
liste. Pour éviter ce
piège, on écrit l=None,
puis dans la fonction
if l is None: l = [].

]]> Une exception est levée

]]> Le code est parfaitement
valide ; aucune exception
n'est levée.

]]> Tuples et listes — Q15 : Méthodes sort et sorted Quelle est la différence entre
liste.sort() et sorted(liste) ?

]]> Moyen mnémotechnique : sorted
(« trié ») désigne un résultat,
une nouvelle liste triée
renvoyée sans modifier
l'original ; sort (« trier »)
désigne une action, qui modifie
la liste sur place et renvoie
None.

]]> 1.0 0.0 0 true true abc La méthode sort est nettement plus lente à l'exécution

]]> Les deux ont une
performance équivalente.
La différence porte sur
la modification, ou non,
de la liste d'origine.

]]> Aucune différence, sorted(liste) appelle liste.sort()

]]> Erreur : sorted construit une
nouvelle liste triée sans toucher à
l'original ; sort modifie la liste sur
place et renvoie None.

]]> La fonction sorted ne fonctionne que sur des nombres

]]> La fonction sorted
fonctionne sur tout type
comparable (entiers,
chaînes, tuples, etc.).

]]> sort modifie la liste, sorted renvoie une copie triée

]]> Bonne réponse : sort trie sur place
et renvoie None, sorted renvoie une
nouvelle liste. Le choix dépend du besoin :
si l'on veut conserver
l'original, on utilise
sorted ; sinon, sort
est préférable. La
fonction sorted
fonctionne aussi sur les
tuples, contrairement à
sort.

]]> Tuples et listes — Q16 : Compréhension de liste Quelle expression construit la liste
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
des carrés des entiers de 1 à 10 ?

]]> Une compréhension de liste
[expression for i in range(a, b)] construit
la liste des valeurs de l'expression pour i
allant de a à b - 1. Elle équivaut à une
boucle qui part d'une liste vide et ajoute
chaque valeur avec append. Les deux erreurs
classiques sont de confondre et *, et
de se tromper sur les bornes de range.

]]> 1.0 0.0 0 true true abc [i ** 2 for i in range(1, 11)]

]]> Bonne réponse : range(1, 11) parcourt les
entiers de 1 à 10 inclus, et i ** 2
calcule le carré de chacun. La compréhension
rassemble ces dix carrés dans une liste.

]]> [i * 2 for i in range(1, 11)]

]]> Erreur : i 2 est le double de i, pas
son carré. Cette expression construit
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20].
Le carré s'écrit i 2 ou i i.

]]> [i ** 2 for i in range(10)]

]]> Erreur : range(10) commence à 0 et
s'arrête à 9. Cette expression construit
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] :
le carré de 0 est en trop, celui de 10
manque.

]]> [i ** 2 for i in range(1, 10)]

]]> Erreur : la borne de fin de range est
exclue, donc range(1, 10) s'arrête à
9. Cette expression construit
[1, 4, 9, 16, 25, 36, 49, 64, 81], sans
le carré de 10.

]]> Tuples et listes — Q17 : Référence et copie `python
a = [1, 2, 3]
b = a
b.append(4)
print(a)
`
Que produit ce code ?

]]> C'est la notion essentielle
d'alias : deux variables
peuvent désigner le même
objet. Ce comportement diffère
des types immuables comme les
entiers, où b = a n'a pas
cet effet.

]]> 1.0 0.0 0 true true abc La liste [4]

]]> La méthode append
ajoute à la liste
existante, sans la
remplacer.

]]> La liste [1, 2, 3]

]]> L'affectation b = a ne
crée pas une copie, mais
attribue une nouvelle
référence vers la même
liste.

]]> Une exception est levée

]]> Le code est parfaitement
valide.

]]> La liste [1, 2, 3, 4]

]]> Les variables a et b
désignent le même objet
en mémoire. Modifier l'un
revient à modifier
l'autre. Pour faire une
copie, on utilise
b = a.copy() ou
b = a[:].

]]> Tuples et listes — Q18 : Réaffecter la variable de boucle `python
l = [1, 2, 3]
for x in l:
x = x * 2
print(l)
`
Que produit ce code ?

]]> Pour transformer les éléments d'une liste, on
parcourt les indices et on écrit dans la liste :
for i in range(len(l)): l[i] = l[i] * 2. La
variable x d'un for x in l n'est qu'un nom
temporaire posé sur chaque élément.

]]> 1.0 0.0 0 true true abc Il affiche [2, 4, 6]

]]> Erreur : x = x 2 crée un nouvel entier et le
range dans x, sans rien écrire dans la liste.
Pour doubler les éléments, il faut écrire
l[i] = l[i] 2 en parcourant les indices.

]]> Il affiche [1, 2, 3]

]]> Bonne réponse : réaffecter la variable de boucle
ne modifie jamais la liste. À chaque tour, x
désigne un élément, puis reçoit un nouvel
entier ; la liste n'est pas touchée.

]]> Il affiche [1, 2, 3, 2, 4, 6]

]]> Erreur : aucune instruction n'ajoute d'élément
à l. Seule la méthode append allongerait la
liste ; ici on ne fait que réaffecter x.

]]> Il déclenche une erreur, car la liste est modifiée pendant le parcours

]]> Erreur : la liste n'est justement pas modifiée,
et réaffecter la variable de boucle est de toute
façon autorisé. Le code s'exécute sans erreur.

]]> Tuples et listes — Q19 : Tuple comme clé de dictionnaire Pourquoi un tuple peut-il être
utilisé comme clé de
dictionnaire, alors qu'une liste
ne le peut pas ?

]]> Un objet est dit hashable
lorsqu'il possède une
empreinte stable et peut
donc être placé dans un
ensemble ou utilisé comme
clé. Les types immuables
classiques sont hashables :
entiers, flottants, chaînes,
tuples (s'ils ne contiennent
que des éléments hashables)
et ensembles figés.

]]> 1.0 0.0 0 true true abc Aucune des deux structures ne peut servir de clé

]]> Un tuple peut bien servir
de clé, à condition que
tous ses éléments soient
eux-mêmes immuables.

]]> Aucune raison particulière

]]> La distinction repose sur
des considérations
techniques précises, comme
expliqué dans la bonne
réponse.

]]> Parce qu'un tuple est immuable : il a une empreinte de hachage stable

]]> Les clés de dictionnaire
doivent être stables dans
le temps. Une liste,
mutable, ne pourrait pas
servir de clé : on
pourrait modifier la clé
après l'insertion, ce qui
casserait la table de
hachage.

]]> Uniquement pour des raisons purement historiques et anciennes

]]> La raison est strictement
technique, et non
historique.

]]> Tuples et listes — Q20 : Tuple à un élément Que vaut l'expression len((42)) ?

]]> C'est un piège classique : il
faut toujours penser à la
virgule pour les tuples à un
seul élément. Pour vérifier,
type((42)) renvoie int,
tandis que type((42,))
renvoie tuple.

]]> 1.0 0.0 0 true true abc La valeur 0, car le tuple (42) est considéré comme vide

]]> Erreur : (42) n'est pas un tuple du
tout, et len lève une exception sur un
entier.

]]> Une exception TypeError

]]> Bonne réponse : (42) n'est pas un tuple
mais l'entier 42 entre parenthèses, et
len n'agit pas sur un entier. Pour créer
un tuple à un seul élément, il faut une
virgule : (42,).

]]> La valeur 42, l'unique élément du tuple

]]> Erreur : len ne renvoie pas la valeur
de son argument, et (42) n'est pas un
tuple.

]]> La valeur entière 1, comme on pourrait l'attendre

]]> L'expression (42) n'est
pas un tuple, mais
simplement l'entier 42
entouré de parenthèses de
groupement.

]]> Tuples et listes — Q21 : Alias et concaténation `python
l = [1, 2, 3]
m = l
l = l + [4]
print(m)
`
Que produit ce code ?

]]> Deux façons d'allonger une liste n'ont pas le même
effet sur les alias : l.append(4) et l += [4]
modifient la liste partagée, visible depuis m ;
l = l + [4] réaffecte l à une nouvelle liste
et rompt le lien avec m.

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

]]> Erreur : l'alias m suivrait l si la liste
était modifiée sur place, par l.append(4) ou
l += [4]. Mais l + [4] construit une
nouvelle liste, que l reçoit ; m désigne
toujours l'ancienne.

]]> Il affiche [1, 2, 3, [4]]

]]> Erreur : l'opérateur + concatène les éléments
sans imbriquer la liste [4], et surtout il
produit une nouvelle liste : m n'en voit rien.

]]> Il affiche [1, 2, 3]

]]> Bonne réponse : après m = l, les deux noms
désignent la même liste. Puis l + [4] crée
une nouvelle liste [1, 2, 3, 4], affectée à
l seul. m garde l'ancienne liste, intacte.

]]> Il déclenche une erreur, car on ne peut pas additionner deux listes

]]> Erreur : + entre deux listes est défini et
produit leur concaténation. Seule l'addition
d'une liste et d'un entier, comme l + 4,
lève TypeError.

]]> Tuples et listes — Q22 : Liste de listes `python
grille = [[0] 3] 3
grille[0][0] = 1
print(grille)
`
Que produit ce code ?

]]> C'est un piège classique. La
bonne pratique consiste à
utiliser une compréhension de
liste pour créer chaque
sous-liste indépendamment.

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

]]> L'expression [[0]3]3
crée trois références
vers la même sous-liste.
Modifier une sous-liste
revient donc à modifier
les trois. La solution
consiste à utiliser une
compréhension de liste :
[[0] * 3 for _ in range(3)].

]]> Une exception est levée

]]> Le code est parfaitement
valide.

]]> [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

]]> Cette réponse ignore que
les trois sous-listes
référencent le même objet.

]]> [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

]]> On a affecté
grille[0][0] = 1, donc
la valeur 1 apparaît
quelque part dans le
résultat.

]]> Tuples et listes — Q23 : Corriger une note dans une liste de p-uplets Les notes d'une classe sont rangées dans
eleves = [("Ana", 12), ("Bilal", 9), ("Chloé", 15)],
un p-uplet par élève. La note de Bilal est
fausse, il a eu 11. Quelle instruction
corrige la liste sans erreur ?

]]> Dans une liste de p-uplets, chaque enregistrement
est immuable, mais la liste qui les contient est
mutable. Pour corriger un champ, on construit un
nouveau p-uplet et on l'affecte à l'indice voulu :
eleves[1] = ("Bilal", 11). Toute tentative de
modifier le p-uplet sur place lève une exception.

]]> 1.0 0.0 0 true true abc eleves[1][1] = 11

]]> Erreur : eleves[1] est le p-uplet
("Bilal", 9), et un p-uplet est immuable.
Python lève
TypeError: 'tuple' object does not support item assignment.

]]> eleves[1] = ("Bilal", 11)

]]> Bonne réponse : on ne modifie pas le p-uplet,
on le remplace. La liste, elle, est mutable :
l'affectation range un nouveau p-uplet à
l'indice 1, et la liste vaut
[("Ana", 12), ("Bilal", 11), ("Chloé", 15)].

]]> eleves["Bilal"] = 11

]]> Erreur : une liste s'indexe par un entier,
pas par une chaîne ; cette écriture est celle
d'un dictionnaire. Python lève
TypeError: list indices must be integers or slices, not str.

]]> eleves[1].append(11)

]]> Erreur : eleves[1] est un p-uplet, qui n'a
pas de méthode append. Python lève
AttributeError: 'tuple' object has no attribute 'append'.
Et même sur une liste, on aurait ajouté 11
au lieu de remplacer 9.

]]> Tuples et listes — Q24 : Tuples pour les constantes Pour stocker des constantes
que l'on ne modifiera jamais,
quelle structure est la plus
indiquée ?

]]> Convention Python : on
utilise les tuples pour les
données figées, et les
listes pour les données qui
évoluent au cours du
programme. Cette distinction
améliore la lisibilité du
code.

]]> 1.0 0.0 0 true true abc Un dictionnaire associant des clés à des valeurs

]]> Le dictionnaire associe
des clés à des valeurs.
Pour de simples
constantes, c'est plus
lourd qu'un tuple.

]]> Un tuple, immuable

]]> Bonne réponse : le tuple signale
l'immuabilité et reste un peu plus
léger qu'une liste. Par exemple,
JOURS = ("lun", "mar",
"mer", ...). Le lecteur
du code comprend
immédiatement que ces
données ne changeront
pas.

]]> Une liste, que l'on pourra compléter si les constantes évoluent

]]> Erreur : une liste fonctionnerait, mais
son caractère modifiable contredit
l'intention (des données figées) et
n'avertit pas le lecteur du code.

]]> Une chaîne de caractères, les valeurs séparées par des virgules

]]> Une chaîne n'est pas
adaptée pour stocker des
éléments séparés, sauf
dans des cas
particuliers.

]]> Tuples et listes — Q25 : Synthèse Parmi les affirmations suivantes
sur les tuples et les listes,
laquelle est fausse ?

]]> Mémo utile : les clés d'un
dictionnaire doivent être
stables dans le temps. Tout
ce qui est mutable n'offre
pas cette stabilité, et ne
peut donc pas servir de
clé.

]]> 1.0 0.0 0 true true abc Les deux structures supportent l'indexation et le découpage

]]> Cette affirmation est
correcte : on peut écrire
l[0], l[1:3] aussi
bien sur une liste que
sur un tuple.

]]> Les listes peuvent être utilisées comme clés de dictionnaire

]]> Cette affirmation est
fausse (donc c'est la
bonne réponse). Les
listes sont mutables,
donc non hashables, et
ne peuvent pas servir
de clé. Seuls les
tuples (à condition que
tous leurs éléments
soient hashables)
peuvent l'être.

]]> liste = [] crée une liste vide ; t = () crée un tuple vide

]]> Cette affirmation est
correcte.

]]> Une liste est mutable, un tuple est immuable

]]> Cette affirmation est
correcte. C'est même la
différence la plus
fondamentale entre les
deux structures.

]]> Tuples et listes — Q26 : Renverser une liste On dispose d'une liste t = [10, 20, 30, 40, 50] et
l'on veut construire une nouvelle liste r contenant
les mêmes éléments dans l'ordre inverse, soit
[50, 40, 30, 20, 10]. Quel code convient ?

]]> Construire la liste renversée revient à insérer
chaque élément en tête, ou à lire la liste de la fin
vers le début avec les indices len(t) - 1 - i.
Dans les deux cas, t n'est pas modifiée.

]]> 1.0 0.0 0 true true abc `python
r = []
for x in t:
r.append(x)
`

]]> Erreur : chaque élément est ajouté à la fin de
r dans l'ordre de parcours. On obtient une
simple copie [10, 20, 30, 40, 50].

]]> `python
r = []
for x in t:
r = [x] + r
`

]]> Bonne réponse : à chaque tour, [x] + r place
le nouvel élément devant ceux déjà rangés.
r vaut successivement [10], [20, 10],
[30, 20, 10], jusqu'à [50, 40, 30, 20, 10].

]]> `python
r = []
for i in range(len(t)):
r.append(t[-i])
`

]]> Erreur : au premier tour, i vaut 0 et t[-0]
est t[0], le premier élément. Le résultat est
[10, 50, 40, 30, 20], décalé d'un cran.

]]> `python
r = []
for i in range(len(t)):
r.append(t[len(t) - i])
`

]]> Erreur : au premier tour, t[len(t) - 0] vaut
t[5], hors de la liste, d'où une IndexError.
Il faudrait écrire t[len(t) - 1 - i].

]]> Tuples et listes — Q27 : Compter et trouver dans une liste Soit t = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]. Que
renvoient successivement les expressions
t.count(5) et t.index(5) ?

]]> Méthodes utiles sur les listes : count(x) (nombre
d'occurrences), index(x) (premier indice de x,
lève ValueError si absent), remove(x) (supprime
la première occurrence). Pour vérifier la présence
sans déclencher d'erreur, préférer if x in t:.

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

]]> Erreur : confusion entre les rôles. La méthode
count répond à « combien ? » (ici trois fois)
et index à « où ? » (ici à l'indice 4).

]]> 3 puis 4

]]> Bonne réponse : t.count(5) compte le nombre
d'occurrences de 5 dans la liste, il y en a
trois (indices 4, 8 et 10).
t.index(5) renvoie l'indice de la première
occurrence, ici 4 (l'indexation commence à
zéro).

]]> 5 puis 5

]]> Erreur : la valeur 5 est mentionnée trois
fois et son premier indice n'est pas 5. Bien
distinguer count (combien d'occurrences) de
index (à quelle position).

]]> 3 puis 5

]]> Erreur : count est correct (3 occurrences),
mais index renvoie l'indice du premier
5, pas la valeur 5. La première occurrence
se trouve en position 4.

]]> Tuples et listes — Q28 : append, extend et concaténation On exécute :

`python
a = [1, 2, 3]
b = [4, 5]
a.append(b)

Que vaut la liste a` après cette exécution ?

]]> Deux opérations à distinguer : a.append(x)
ajoute x à la fin de a comme un seul élément,
en modifiant a sur place ; a + b produit une
nouvelle liste formée des éléments de a
puis de ceux de b, sans modifier ni a ni b.
Pour obtenir [1, 2, 3, 4, 5] dans a, on écrit
donc a = a + b. Confondre les deux est l'une des
erreurs les plus fréquentes en Python.

]]> 1.0 0.0 0 true true abc Le code lève une erreur

]]> Erreur : la méthode append accepte n'importe
quel objet, y compris une liste. Le code
s'exécute sans erreur, même si le résultat
peut surprendre.

]]> [1, 2, 3, [4, 5]]

]]> Bonne réponse : append ajoute son paramètre
tel quel à la fin de la liste, sans déballage.
Comme b est lui-même une liste, on obtient
une liste imbriquée.

]]> [1, 2, 3, 4, 5]

]]> Erreur : ce serait le résultat de
a = a + b, qui enchaîne les éléments de b
un par un après ceux de a. La méthode
append, elle, ajoute son paramètre comme un
unique élément.

]]> [[1, 2, 3], 4, 5]

]]> Erreur : append ajoute en fin de liste,
pas au début. Et c'est b qui est ajouté, pas
a.

]]>