$course$/QCM de NSI/Première/Tuples et listes Types construits : tuples (immuables) et listes
(mutables), création, accès par indice, parcours,
méthodes principales (append, pop, len, etc.),
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 la syntaxe t = tuple[1, 2, 3]

]]> Cette syntaxe est invalide en
Python.

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

]]> Les parenthèses sont souvent
facultatives ; ce sont les
virgules qui définissent un
tuple. Pour un tuple à un
seul élément, la virgule est
obligatoire : t = (1,).

]]> Avec la syntaxe t = {1, 2, 3}

]]> Les accolades autour de
plusieurs éléments séparés
par des virgules créent un
ensemble (set), pas un
tuple.

]]> Avec la syntaxe t = []

]]> Les crochets servent à créer
une liste, et non un tuple.

]]> 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 a forcément deux éléments

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

]]> Aucune différence

]]> La différence porte
précisément sur la mutabilité,
comme expliqué dans la bonne
réponse.

]]> Une liste est mutable (modifiable après sa création), tandis qu'un tuple est immuable (figé une fois créé)

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

]]> La couleur d'affichage dans l'éditeur

]]> Cette description littérale
n'a aucun rapport avec la
notion technique. 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
utilise liste.extend([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)):.
Pour parcourir avec à la fois
l'indice et la valeur :
for i, x in enumerate(liste):.

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

]]> 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, paires nom-valeur

]]> 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). La forme
complète du découpage est
liste[a:b:pas], où le pas est
facultatif (par défaut 1).

]]> 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 : Méthode pop Que fait l'appel liste.pop() ?

]]> Combinées, les méthodes append
et pop permettent d'ajouter
et de retirer des éléments à la
fin d'une liste. Ces deux
opérations sont très courantes
pour gérer dynamiquement le
contenu d'une liste.

]]> 1.0 0.0 0 true true abc Elle retire et renvoie le dernier élément de la liste, en O(1)

]]> Avec un argument, pop(i)
retire et renvoie l'élément
d'indice i. Cette opération
est en O(n) pour
i ≠ -1, à cause du
décalage des éléments
suivants.

]]> Elle se contente d'afficher le dernier élément

]]> La méthode pop modifie la
liste et renvoie la
valeur retirée.

]]> Elle compte le nombre d'éléments de la liste

]]> Le comptage des éléments se
fait avec la fonction len.

]]> Elle trie la liste sur place

]]> Le tri sur place se fait
avec la méthode sort.

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

]]> Convention Python : les verbes
à la voix passive (sorted,
reversed) renvoient une
version transformée sans
modifier l'original ; les
noms d'action (sort,
reverse) modifient sur
place.

]]> 1.0 0.0 0 true true abc La méthode sort est plus lente

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

]]> Aucune différence

]]> Une différence importante
existe, comme expliqué
dans la bonne réponse.

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

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

]]> La méthode sort modifie la liste sur place (et renvoie None), tandis que la fonction sorted renvoie une nouvelle liste triée sans modifier l'originale

]]> 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 Quel code crée la liste des
carrés des entiers de 1 à 10 ?

]]> Quatre formes de compréhension
existent : [] pour les
listes, {} pour les
ensembles, {k: v for ...}
pour les dictionnaires, et
(...) pour les générateurs.
Toutes sont très utilisées en
Python idiomatique.

]]> 1.0 0.0 0 true true abc for i in range(1, 11): liste.append(i 2)

]]> Cette construction sur
plusieurs lignes
fonctionne, mais la
compréhension de liste est
plus idiomatique.

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

]]> C'est une compréhension de
liste, une syntaxe concise
et idiomatique en Python.

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

]]> Cette syntaxe crée une
expression génératrice,
parcourable une seule fois,
et non une liste. Avec
list(...) autour, on
obtiendrait bien une liste.

]]> {i 2 for i in range(1, 11)}

]]> Cette syntaxe crée un
ensemble (set), pas
une liste.

]]> 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 : Retours multiples par tuple Que renvoie cette fonction ?
`python
def min_max(l):
return min(l), max(l)
`

]]> Cet idiome est très courant
en Python. Il évite de
définir une classe ad hoc
pour transporter deux valeurs
liées.

]]> 1.0 0.0 0 true true abc Une chaîne de caractères

]]> La fonction renvoie deux
valeurs numériques, pas
une chaîne.

]]> La valeur None

]]> La fonction renvoie bien
quelque chose, à savoir un
tuple.

]]> Une liste contenant deux éléments

]]> La virgule entre les deux
valeurs renvoyées crée un
tuple, et non une liste.

]]> Un tuple de la forme (min, max)

]]> La virgule entre deux
valeurs construit un tuple.
C'est l'idiome Python pour
renvoyer plusieurs valeurs.
On les récupère ensuite par
dépaquetage :
mn, mx = min_max(...).

]]> 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 : sa valeur ne peut pas changer après création, ce qui permet d'en calculer une empreinte 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.

]]> Pour des raisons purement historiques

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

]]> Aucune valeur de longueur
n'est calculée ; la
fonction len lève une
exception sur un entier.

]]> Une exception (TypeError), car la fonction len n'est pas définie sur les entiers

]]> Pour créer un tuple à un
seul élément, il faut une
virgule : (42,). Sans
cette virgule, on a juste
un entier.

]]> La valeur 42

]]> La fonction len ne
renvoie pas la valeur de
son argument.

]]> La valeur 1

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

]]> Tuples et listes — Q21 : Trace de pop `python
l = [10, 20, 30]
x = l.pop(0)
print(x, l)
`
Que produit ce code ?

]]> Performance : pop(-1) est
en O(1), alors que
pop(0) est en O(n) à
cause du décalage de tous
les éléments. Mieux vaut
donc retirer les éléments
par la fin de la liste
lorsque c'est possible.

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

]]> Sans argument, pop()
retire le dernier
élément. Mais ici, on a
précisé l'indice 0 :
c'est donc le premier
élément qui est retiré.

]]> Une exception est levée

]]> L'indice 0 est valide
pour une liste de trois
éléments.

]]> La sortie 10 [10, 20, 30]

]]> La méthode pop modifie
la liste sur place,
contrairement à ce que
suggère cette réponse.

]]> La sortie 10 [20, 30]

]]> L'appel pop(0) retire et
renvoie l'élément d'indice
0, c'est-à-dire 10. La
liste devient alors
[20, 30].

]]> 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 : Méthodes append et extend Quelle est la différence entre
les méthodes append et extend
d'une liste ?

]]> Une autre forme équivalente :
liste += iterable revient
à liste.extend(iterable).

]]> 1.0 0.0 0 true true abc La méthode append(x) ajoute x comme un seul élément ; la méthode extend(iterable) ajoute chaque élément de l'itérable un par un

]]> Par exemple,
[1].append([2, 3]) donne
[1, [2, 3]], alors que
[1].extend([2, 3])
donne [1, 2, 3]. La
distinction est subtile
mais importante.

]]> Aucune différence notable

]]> Une différence importante
existe, comme expliqué
dans la bonne réponse.

]]> La méthode append est plus rapide qu'extend

]]> Les performances sont
équivalentes pour ajouter
un élément. La distinction
porte sur le sens de
l'opération.

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

]]> Cette méthode existe bel
et bien et fait partie de
l'interface standard des
listes.

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

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

]]> Un tuple, qui signale clairement l'immuabilité, est légèrement plus rapide à créer et consomme un peu moins de mémoire

]]> Par exemple,
JOURS = ("lun", "mar",
"mer", ...). Le lecteur
du code comprend
immédiatement que ces
données ne changeront
pas.

]]> Une liste

]]> Une liste fonctionnerait,
mais on perdrait
l'information précieuse
de l'immuabilité, qui
aide à la lecture du
code.

]]> Une chaîne de caractères

]]> 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].
Que vaut t[::-1] ?

]]> Le découpage généralisé liste[debut:fin:pas]
permet de nombreux traitements rapides :
t[::-1] (inversion), t[::2] (un élément sur
deux), t[1::2] (à partir de l'indice 1, un sur
deux), t[-3:] (les trois derniers). Tous
produisent une nouvelle liste sans modifier
l'originale.

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

]]> Bonne réponse : la syntaxe [::-1] produit une
nouvelle liste contenant les éléments de t
dans l'ordre inverse. La liste d'origine n'est
pas modifiée.

]]> [10, 20, 30, 40, 50]

]]> Erreur : ce serait la liste d'origine. Le pas
négatif -1 indique au contraire de parcourir
la séquence dans le sens inverse.

]]> Une erreur d'indice

]]> Erreur : la syntaxe est valide. Le découpage
[debut:fin:pas] accepte parfaitement un pas
négatif lorsqu'on souhaite parcourir la
séquence à l'envers.

]]> []

]]> Erreur : la liste produite n'est pas vide. Le
pas -1 signifie « parcours en arrière », pas
« efface ».

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

]]> Trois opérations à distinguer : a.append(x)
ajoute x comme un seul élément ; a.extend(b)
ajoute les éléments de b un par un (équivalent
à a += b) ; a + b produit une nouvelle
liste sans modifier ni a ni b. Confondre les
trois 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.extend(b), qui ajoute les éléments de b
un par un. 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.

]]>