$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,
appartenance avec in, compréhensions, conversions
d'un type à l'autre, affectation multiple et
déballage, le choix de la structure selon
l'usage, et les tranches (slicing) : bornes,
indices négatifs, pas et copie.

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

]]> Le mot-clé null n'existe pas
en Python ; l'équivalent
s'appelle None, qui ne
représente d'ailleurs pas 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 = []

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

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

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

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

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

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

]]> Les indices d'une liste de n
éléments vont de 0 à n - 1 :
le premier élément a l'indice 0
et le dernier l'indice
len(liste) - 1. Un indice
supérieur ou égal à n lève une
exception IndexError.

]]> 1.0 0.0 0 true true abc 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".

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

]]> Une exception est levée

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

]]> La chaîne "c"

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

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

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

]]> Avec liste.size()

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

]]> Avec size(liste)

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

]]> Avec len(liste)

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

]]> 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.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 += 42

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

]]> Avec liste.add(42)

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

]]> Avec liste = liste + 42

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

]]> 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
print liste
`

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

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

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

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

]]> On peut aussi écrire ce test soi-même : une boucle for parcourt
la liste et compare chaque élément à 42. Le coût est linéaire
dans les deux cas.

]]> 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, Python parcourt les éléments
un par un jusqu'à trouver 42.

]]> 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 Pour économiser quelques touches au clavier

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

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

]]> 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 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
3 : la longueur passe
de 3 à 4, et non à 5.

]]> Il déclenche une exception

]]> Le code est parfaitement
valide.

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

]]> Tuples et listes — Q11 : Extraire des éléments consécutifs On dispose de t = [10, 20, 30, 40, 50]. Que vaut
l'expression [t[i] for i in range(1, 4)] ?

]]> Dans range(a, b), la borne a
est incluse et la borne b
exclue. La compréhension
[t[i] for i in range(a, b)]
construit donc la liste des
éléments d'indices a à b - 1.

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

]]> Les indices commencent à 0 :
t[1] désigne le deuxième
élément, 20, et non celui qui
le précède.

]]> La liste [20, 30, 40]

]]> range(1, 4) produit les indices
1, 2 et 3, la borne 4 étant
exclue. La compréhension prend
les éléments situés à ces
indices : 20, 30 et 40.

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

]]> Ce sont les indices produits
par range(1, 4). La
compréhension ne garde pas i
mais t[i], l'élément situé à
cet indice.

]]> La liste [20, 30, 40, 50]

]]> La borne haute de range est
exclue : l'indice 4, qui
désigne 50, n'est pas
produit.

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

]]> L'affectation multiple sert aussi à récupérer d'un coup les valeurs
d'un p-uplet renvoyé par une fonction : si f() renvoie (4, 7),
l'instruction x, y = f() affecte x = 4 et y = 7.

]]> 1.0 0.0 0 true true abc Une exception est levée

]]> Le code est parfaitement
valide.

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

]]> Le tuple ((1, 2, 3),)

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

]]> 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 la compréhension [l[i] for i in range(n)],
les indices vont de 0 à n - 1. En prenant
len(l) - 1 comme borne, on 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[i] for i in range(len(l) - 1)]

]]> Bonne réponse : range(len(l) - 1) produit
les indices de 0 à len(l) - 2, soit tous
sauf celui du dernier élément. On obtient
[10, 20] dans une nouvelle liste ; l n'est
pas modifiée.

]]> [l[i] for i in range(1, len(l))]

]]> Erreur : les indices vont de 1 à
len(l) - 1, ce qui retire le premier
élément. Sur l'exemple, on obtient
[20, 30].

]]> [l[i] for i in range(len(l) - 2)]

]]> Erreur : la borne len(l) - 2 étant exclue,
les indices s'arrêtent à len(l) - 3 et les
deux derniers éléments disparaissent. Sur
l'exemple, on obtient [10].

]]> l[len(l) - 1]

]]> Erreur : sans compréhension, les crochets font
un accès par indice. l[len(l) - 1] est le
dernier élément lui-même, ici 30, et non une
liste.

]]> Tuples et listes — Q14 : Une fonction qui renvoie deux notes à la fois `python
def bornes(notes):
mini = notes[0]
maxi = notes[0]
for n in notes:
if n < mini:
mini = n
if n > maxi:
maxi = n
return (mini, maxi)
resultat = bornes([12, 8, 15, 10])

Que contient la variable resultat` après l'exécution de ce code ?

]]> Une fonction renvoie une seule valeur, mais cette valeur peut être
un p-uplet : c'est ainsi qu'on renvoie plusieurs résultats à la
fois. On les récupère ensuite par resultat[0] et resultat[1],
ou directement avec bas, haut = bornes([12, 8, 15, 10]).

]]> 1.0 0.0 0 true true abc La liste [8, 15]

]]> Erreur : les parenthèses de return (mini, maxi) construisent un
tuple, pas une liste. Les valeurs sont justes, mais le type ne
l'est pas.

]]> Le tuple (15, 8)

]]> Erreur : l'ordre des valeurs est celui écrit dans
return (mini, maxi) : d'abord le minimum, puis le maximum.

]]> Le tuple (8, 15)

]]> Bonne réponse : la boucle retient la plus petite note, 8, et la
plus grande, 15. L'instruction return (mini, maxi) renvoie un
p-uplet de deux valeurs, qui est affecté à resultat.

]]> L'entier 8

]]> Erreur : return ne s'arrête pas à la première valeur. Il renvoie
le p-uplet entier (mini, maxi), qui contient les deux notes.

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

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

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

]]> [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(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, 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.

]]> 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 Une exception est levée

]]> Le code est parfaitement
valide.

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

]]> La liste [4]

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

]]> 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 construit une
nouvelle liste, par exemple
b = [x for x in 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 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.

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

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

]]> Les types immuables classiques peuvent servir de clés : entiers,
flottants, chaînes et tuples, à condition que ces derniers ne
contiennent eux-mêmes que des valeurs immuables. Les listes et les
dictionnaires, modifiables, ne le peuvent pas.

]]> 1.0 0.0 0 true true abc Aucune raison particulière

]]> La distinction a une raison technique : une clé doit rester
identique pour que le dictionnaire retrouve la valeur associée.

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

]]> Parce qu'un tuple est immuable, contrairement à une liste

]]> Les clés de dictionnaire doivent rester identiques dans le temps.
Une liste, modifiable, ne peut pas servir de clé : on pourrait la
changer après l'avoir utilisée, et le dictionnaire ne retrouverait
plus la valeur associée.

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

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

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

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

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

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

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

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

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

]]> 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 listes peuvent être utilisées comme clés de dictionnaire

]]> Cette affirmation est fausse (donc c'est la bonne réponse). Les
listes sont modifiables, donc interdites comme clés de
dictionnaire. Les tuples peuvent l'être, à condition que tous leurs
éléments soient eux-mêmes immuables.

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

]]> Les deux structures supportent l'indexation et la fonction len

]]> Cette affirmation est correcte : on peut écrire s[0] ou len(s)
aussi bien sur une liste que sur un tuple.

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

]]> Cette affirmation est
correcte.

]]> 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 = [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) - 1):
r.append(t[len(t) - 1 - i])
`

]]> Erreur : l'indice len(t) - 1 - i lit bien la
liste depuis la fin, mais range(len(t) - 1) ne
fait que 4 tours. Le résultat
[50, 40, 30, 20] oublie le premier élément, 10.

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

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

]]> Tuples et listes — Q27 : Compter les 5 et repérer le premier `python
t = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
compteur = 0
premier = -1
for i in range(len(t)):
if t[i] == 5:
compteur = compteur + 1
if premier == -1:
premier = i
print(compteur, premier)
`
Qu'affiche ce programme ?

]]> Un seul parcours suffit pour compter les occurrences et retenir la
position de la première. La valeur de départ -1, qui n'est jamais
un indice produit par range, signale que la valeur n'a pas encore
été rencontrée.

]]> 1.0 0.0 0 true true abc 3 5

]]> Erreur : les indices commencent à 0. Le premier 5 est le
cinquième élément de la liste, mais son indice est 4.

]]> 3 10

]]> Erreur : ce serait l'indice de la dernière occurrence. Le test
premier == -1 n'est vrai qu'au premier 5 rencontré ; ensuite
premier vaut 4 et n'est plus modifié.

]]> 4 3

]]> Erreur : les rôles sont inversés. compteur vaut le nombre
d'occurrences, 3, et premier l'indice de la première, 4 ;
print les affiche dans cet ordre.

]]> 3 4

]]> Bonne réponse : la valeur 5 apparaît trois fois, aux indices 4, 8 et 10. La variable premier ne reçoit un indice que tant
qu'elle vaut -1, donc seulement à la première occurrence : 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]

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

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

]]> Tuples et listes — Q29 : Un tuple de types différents Le tuple eleve = ("Ana", 15, True)
est-il valide en Python ?

]]> Un tuple sert justement à réunir des
informations de natures différentes sur
un même objet : ("Ana", 15, True) se
lit comme une fiche à trois champs.

]]> 1.0 0.0 0 true true abc Oui : un tuple regroupe des valeurs de types différents

]]> Bonne réponse : un tuple, comme une
liste, accepte des éléments de types
différents. C'est même son emploi le
plus courant : regrouper les
caractéristiques d'une même chose,
ici un prénom, une note et un
booléen.

]]> Oui, mais seulement si on l'écrit sans parenthèses

]]> Erreur : les parenthèses ne changent
rien aux types acceptés. Ce sont les
virgules qui créent le tuple.

]]> Non : un tuple n'accepte que des nombres

]]> Erreur : un tuple accepte n'importe
quel type de valeur, y compris des
chaînes, des booléens, et même
d'autres tuples.

]]> Non : tous les éléments d'un tuple doivent avoir le même type

]]> Erreur : cette contrainte n'existe ni
pour les tuples ni pour les listes.
Elle existe dans d'autres langages,
comme les tableaux du langage C.

]]> Tuples et listes — Q30 : D'une liste au tuple Comment obtient-on un tuple à partir
de la liste l = [1, 2, 3] ?

]]> Les deux conversions se font par les
fonctions qui portent le nom du type :
tuple(l) dans un sens, list(t) dans
l'autre. Chacune crée une nouvelle
structure, l'originale reste intacte.

]]> 1.0 0.0 0 true true abc Avec t = tuple(l)

]]> Bonne réponse : tuple(l) construit un
nouveau tuple avec les mêmes éléments.
La conversion inverse s'écrit
list(t).

]]> Avec t = (l)

]]> Erreur : des parenthèses autour d'une
liste ne changent rien, t reste la
même liste.

]]> Avec t = l.freeze()

]]> Erreur : cette méthode n'existe pas en
Python.

]]> Avec t = l.tuple()

]]> Erreur : les listes n'ont pas de
méthode tuple. La conversion se fait
par la fonction tuple.

]]> Tuples et listes — Q31 : Échanger deux variables `python
a = 1
b = 2
a, b = b, a
print(a, b)
`
Que produit ce code ?

]]> Cette ligne cache un tuple : Python
évalue b, a, ce qui donne (2, 1),
puis déballe ce tuple dans a, b. D'où
l'échange en une seule instruction.

]]> 1.0 0.0 0 true true abc Il affiche 2 1

]]> Bonne réponse : la partie droite
construit d'abord le tuple (2, 1),
puis ses deux valeurs sont rangées
dans a et b. L'échange se fait
sans variable intermédiaire.

]]> Il affiche 1 2

]]> Erreur : les valeurs sont bien
échangées. Ce serait le résultat sans
la troisième ligne.

]]> Il affiche 2 2, car a est écrasé avant d'être lu

]]> Erreur : c'est ce qui arriverait avec
deux affectations successives
(a = b puis b = a). Ici la partie
droite est entièrement évaluée avant
toute affectation.

]]> Il déclenche une erreur de syntaxe

]]> Erreur : cette écriture est correcte
en Python, c'est même la façon
habituelle d'échanger deux variables.

]]> Tuples et listes — Q32 : Ce qu'un tuple sait faire On dispose de t = (3, 1, 4, 1, 5).
Quelle instruction est valide ?

]]> Un tuple ne garde que les méthodes qui
ne modifient rien : count et index.
Toutes celles qui transforment la
structure (append, sort, remove)
appartiennent aux seules listes.

]]> 1.0 0.0 0 true true abc t.append(9), qui ajoute 9 à la fin

]]> Erreur : append modifierait le
tuple, ce qui est impossible.
L'exécution lève une exception
AttributeError.

]]> t[0] = 7, qui remplace le premier élément

]]> Erreur : remplacer un élément revient à
modifier le tuple, ce qui lève une
exception TypeError.

]]> t.count(1), qui renvoie 2

]]> Bonne réponse : count compte les
occurrences d'une valeur et index
donne la position de la première.
Ces deux méthodes ne modifient rien,
elles sont donc permises sur un
tuple.

]]> t.sort(), qui range les valeurs dans l'ordre

]]> Erreur : sort trie sur place, donc
modifie. Sur un tuple, on passe par
sorted(t), qui renvoie une nouvelle
liste triée.

]]> Tuples et listes — Q33 : Parcourir un tuple par ses indices `python
t = (10, 20, 30)
for i in range(len(t)):
print(t[i])
`
Que produit ce code ?

]]> Un tuple se lit exactement comme une
liste : par indice, par parcours direct
for v in t, ou avec len. La seule
différence apparaît quand on veut
écrire.

]]> 1.0 0.0 0 true true abc Il affiche 0, 1 puis 2, c'est-à-dire les indices

]]> Erreur : t[i] désigne la valeur
rangée à l'indice i, pas l'indice
lui-même.

]]> Il affiche (10, 20, 30) en une seule ligne

]]> Erreur : le print est à l'intérieur
de la boucle, il s'exécute une fois
par tour.

]]> Il affiche 10, 20 puis 30, une valeur par ligne

]]> Bonne réponse : la lecture par indice
fonctionne sur un tuple comme sur une
liste. Seule l'écriture est interdite.

]]> Il déclenche une exception, un tuple n'ayant pas d'indices

]]> Erreur : les éléments d'un tuple sont
numérotés à partir de 0, exactement
comme ceux d'une liste.

]]> Tuples et listes — Q34 : Ajouter à un tuple `python
t = (1, 2)
u = t + (3,)
print(t, u)
`
Que produit ce code ?

]]> Retenir la nuance : on ne modifie jamais
un tuple, on en fabrique un autre. Même
t += (3,) ne fait pas exception, cette
écriture range un nouveau tuple dans t.

]]> 1.0 0.0 0 true true abc Il déclenche une exception, un tuple étant immuable

]]> Erreur : l'immuabilité interdit de
modifier un tuple existant, pas d'en
créer un nouveau à partir de lui.

]]> Il affiche (1, 2, 3) (1, 2, 3)

]]> Erreur : t n'est pas modifié, un
tuple ne peut pas l'être. Seul u
contient la valeur 3 en plus.

]]> Il affiche (1, 2) (1, 2, (3,))

]]> Erreur : le + entre deux tuples met
leurs éléments bout à bout, il
n'imbrique pas le second dans le
premier.

]]> Il affiche (1, 2) (1, 2, 3)

]]> Bonne réponse : la concaténation
construit un nouveau tuple u,
sans toucher à t. C'est la seule
façon d'« agrandir » un tuple.

]]> Tuples et listes — Q35 : Parcourir en déballant `python
eleves = [("Ana", 12), ("Bilal", 9)]
for prenom, note in eleves:
print(prenom, note)
`
Pourquoi ce parcours fonctionne-t-il ?

]]> Le déballage dans l'en-tête de boucle
rend le code lisible : prenom et note
disent ce que contiennent les deux
champs, là où eleve[0] et eleve[1]
obligent à se souvenir de l'ordre.

]]> 1.0 0.0 0 true true abc C'est une erreur : il faudrait écrire for eleve in eleves puis eleve[0]

]]> Cette écriture fonctionne aussi, mais
elle n'est pas obligatoire. Le
déballage donne des noms parlants aux
deux champs.

]]> Python parcourt d'abord tous les prénoms, puis toutes les notes

]]> Erreur : la boucle avance élève par
élève, et non colonne par colonne.

]]> Chaque élément est un tuple déballé dans les deux variables

]]> Bonne réponse : à chaque tour, le
tuple courant est déballé, son premier
élément va dans prenom et le second
dans note.

]]> Cela ne fonctionne que si les deux valeurs sont du même type

]]> Erreur : les types n'ont aucune
importance, seul le nombre de valeurs
compte.

]]> Tuples et listes — Q36 : Corriger une valeur d'un tuple On dispose de point = (3, 7) et l'on
veut obtenir le point d'abscisse 5 et
de même ordonnée. Que fait-on ?

]]> Quand une valeur doit changer souvent,
c'est le signe qu'une liste conviendrait
mieux. Le tuple s'emploie pour ce qui ne
bouge pas, comme les coordonnées d'un
point déjà placé.

]]> 1.0 0.0 0 true true abc On écrit point.append(5) puis on retire l'ancienne valeur

]]> Erreur : append n'existe pas sur un
tuple, et ajouter ne remplacerait pas
l'abscisse.

]]> On écrit point[0] = 5

]]> Erreur : cette affectation lève une
exception TypeError, un tuple
n'accepte aucune modification.

]]> On écrit point.modifier(0, 5)

]]> Erreur : cette méthode n'existe pas,
et modifier un tuple est de toute
façon impossible.

]]> On construit un nouveau tuple : point = (5, point[1])

]]> Bonne réponse : on ne modifie pas le
tuple, on en construit un autre et on
le range dans la même variable.

]]> Tuples et listes — Q37 : Un tuple qui contient une liste `python
t = ([1, 2], 3)
t[0].append(9)
print(t)
`
Que produit ce code ?

]]> L'immuabilité d'un tuple porte sur ses
cases, pas sur le contenu des objets
qu'elles désignent. Un tuple de listes
reste donc modifiable en profondeur, ce
qui lui interdit d'être clé de
dictionnaire.

]]> 1.0 0.0 0 true true abc Il affiche ([1, 2], 3), la modification étant perdue

]]> Erreur : append modifie bien la
liste, et le tuple désigne cette même
liste.

]]> Il déclenche une exception, le tuple étant immuable

]]> Erreur : on ne remplace aucun élément
du tuple, on modifie l'objet qu'il
désigne. Le tuple lui-même n'est pas
touché.

]]> Il affiche ([1, 2], 3, 9)

]]> Erreur : le 9 est ajouté à la liste
intérieure, pas au tuple.

]]> Il affiche ([1, 2, 9], 3)

]]> Bonne réponse : le tuple garde les
mêmes éléments, c'est la liste rangée
en première position qui change. Rien
n'interdit cela.

]]> Tuples et listes — Q38 : Trier des tuples Que vaut
sorted([(2, "b"), (1, "z"), (2, "a")]) ?

]]> Cette comparaison par ordre lexical,
comme dans un dictionnaire de langue,
explique l'astuce courante : ranger la
clé de tri en tête du tuple pour trier
des données sans effort.

]]> 1.0 0.0 0 true true abc [(1, 'z'), (2, 'a'), (2, 'b')]

]]> Bonne réponse : deux tuples se
comparent élément par élément. Les
premiers éléments décident, et en cas
d'égalité on départage sur le
deuxième.

]]> [(2, 'a'), (2, 'b'), (1, 'z')]

]]> Erreur : le tri est croissant, le
tuple commençant par 1 vient en
premier.

]]> Une exception, car les tuples mêlent nombres et chaînes

]]> Erreur : la comparaison ne mêle jamais
les types ici, elle compare des
nombres entre eux puis, si besoin,
des chaînes entre elles.

]]> [(1, 'z'), (2, 'b'), (2, 'a')]

]]> Erreur : à premier élément égal, la
comparaison se poursuit sur le
deuxième, donc 'a' passe avant
'b'.

]]> Tuples et listes — Q39 : Un carnet de notes qui s'allonge Un programme enregistre les notes d'un
élève au fil de l'année. Quelle structure
convient ?

]]> La bonne question à se poser est
toujours la même : est-ce que le contenu
va changer ? Si oui, liste ; si non,
tuple.

]]> 1.0 0.0 0 true true abc Un tuple, car les notes ne changent plus une fois attribuées

]]> Une note déjà attribuée ne change
plus, mais le carnet, lui, s'allonge :
il faudrait reconstruire le tuple à
chaque note.

]]> Un tuple, car il occupe moins de place en mémoire

]]> Le gain est réel mais négligeable ici,
et il ne compense pas l'impossibilité
d'ajouter une note.

]]> Une liste, car le nombre de notes augmente au fil du temps

]]> Bonne réponse : une structure qui
grandit demande une liste, seule à
accepter append.

]]> Une liste, mais seulement si les notes sont des entiers

]]> Erreur : une liste accepte tous les
types, entiers comme décimaux.

]]> Tuples et listes — Q40 : Un tableau de données On veut représenter un tableau de
relevés, une ligne par mesure, chaque
ligne contenant une date et une
température. Quelle structure ?

]]> C'est la forme habituelle d'un tableau de
données en Python : une liste de lignes,
chaque ligne étant un tuple de champs,
exactement ce que renvoie la lecture d'un
fichier CSV.

]]> 1.0 0.0 0 true true abc Une liste de tuples, la liste pour les lignes, un tuple par mesure

]]> Bonne réponse : le tableau s'allonge à
chaque relevé, d'où la liste ; une
mesure, elle, forme un couple figé,
d'où le tuple.

]]> Un tuple de listes, le tuple pour les lignes, une liste par mesure

]]> Erreur : c'est l'inverse. Le tuple
extérieur empêcherait d'ajouter des
relevés.

]]> Un tuple de tuples, pour empêcher toute modification du tableau de relevés

]]> Erreur : le tableau doit accueillir de
nouveaux relevés, il ne peut donc pas
être un tuple.

]]> Une liste de listes, pour pouvoir modifier n'importe quelle valeur plus tard

]]> Cela fonctionne, mais rien ne justifie
de rendre modifiable une mesure déjà
relevée. Le tuple dit au lecteur que
la ligne est figée.

]]> Tuples et listes — Q41 : Tranche d'un tuple On dispose de t = (10, 20, 30, 40, 50).
Que vaut t[1:3] ?

]]> Découper ne modifie pas : la tranche
construit une nouvelle structure du même
type que l'original. t[1:3] se lit « de
l'indice 1 jusqu'à l'indice 3 exclu ».

]]> 1.0 0.0 0 true true abc Le tuple (20, 30, 40), les deux indices étant inclus

]]> Erreur : l'indice de fin est exclu, le
40 n'est pas pris.

]]> Une exception, un tuple n'acceptant pas les tranches

]]> Erreur : lire une tranche ne modifie
rien, c'est donc permis sur un tuple.

]]> Le tuple (20, 30)

]]> Bonne réponse : la tranche part de
l'indice 1 inclus et s'arrête à
l'indice 3 exclu. Le résultat est un
nouveau tuple, celui d'origine reste
intact.

]]> La liste [20, 30], car une tranche renvoie toujours une liste

]]> Erreur : une tranche conserve le type
de départ. Sur un tuple, elle renvoie
un tuple.

]]> Tuples et listes — Q42 : Retirer une valeur d'une liste `python
l = [3, 1, 4, 1, 5]
l.remove(1)
print(l)
`
Que produit ce code ?

]]> Deux pièges en un : remove travaille sur
une valeur et non sur un indice, et il
n'en retire qu'une seule. Sur un tuple,
cette méthode n'existe pas, puisqu'elle
modifierait la structure.

]]> 1.0 0.0 0 true true abc Il affiche [3, 1, 4, 1, 5], remove renvoyant une nouvelle liste

]]> Erreur : remove modifie la liste sur
place et ne renvoie rien.

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

]]> Bonne réponse : remove retire la
première occurrence de la valeur
demandée, pas toutes. Le second 1
reste en place.

]]> Il affiche [1, 4, 1, 5], le premier élément étant retiré

]]> Erreur : remove prend une valeur,
pas une position. Retirer par indice se
fait autrement.

]]> Il affiche [3, 4, 5], les deux 1 ayant disparu

]]> Erreur : une seule occurrence est
retirée par appel. Il faudrait appeler
remove autant de fois qu'il y a de
valeurs à retirer.

]]> Tuples et listes — Q43 : Indice du dernier élément La liste notes contient 12 valeurs.
Quelle expression désigne sa dernière
valeur ?

]]> Une liste de n éléments a ses indices de
0 à n-1 : c'est la source d'erreur la
plus fréquente quand on parcourt une liste
par ses indices.

]]> 1.0 0.0 0 true true abc notes[len(notes) - 1]

]]> Bonne réponse : les indices vont de 0
à 11, le dernier vaut donc
12 - 1 = 11.

]]> notes[12], puisque la liste compte douze valeurs

]]> Erreur : même problème, les indices
s'arrêtent à 11.

]]> notes[len(notes)], la longueur servant d'indice

]]> Erreur : cet indice vaut 12, il
dépasse d'une unité et lève une
exception IndexError.

]]> notes.dernier()

]]> Erreur : cette méthode n'existe pas en
Python.

]]> Tuples et listes — Q44 : Construire une liste dans une boucle `python
carres = []
for i in range(1, 5):
carres.append(i * i)
print(carres)
`
Que produit ce code ?

]]> C'est le schéma le plus courant en
programmation : une liste vide, une boucle,
un append par tour. Le résultat se lit
dans l'ordre de construction.

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

]]> Erreur : range(1, 5) s'arrête à 4,
la borne de fin est exclue.

]]> Il affiche [0, 1, 4, 9, 16]

]]> Erreur : la boucle commence à 1, pas
à 0.

]]> Il affiche 16, seule la dernière valeur étant gardée

]]> Erreur : append ajoute sans écraser,
toutes les valeurs restent.

]]> Il affiche [1, 4, 9, 16]

]]> Bonne réponse : la liste part vide et
reçoit un carré à chaque tour, pour i
valant 1, 2, 3 puis 4.

]]> Tuples et listes — Q45 : D'un range à une liste Que vaut list(range(2, 9, 2)) ?

]]> range ne crée pas une liste mais une
suite d'entiers parcourable ; list la
déroule. Les trois arguments se lisent
« début, fin exclue, pas ».

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

]]> Erreur : le premier argument est le
début, ici 2 et non 0.

]]> [2, 4, 6, 8]

]]> Bonne réponse : on part de 2, on
avance de 2 en 2, et on s'arrête
avant 9.

]]> [2, 3, 4, 5, 6, 7, 8]

]]> Erreur : le troisième argument est le
pas, ici 2, et non une simple borne.

]]> [2, 4, 6, 8, 10]

]]> Erreur : 10 dépasse la borne de fin,
qui est exclue.

]]> Tuples et listes — Q46 : Deux façons de parcourir `python
l = [4, 7, 2]
for v in l:
print(v)
for i in range(len(l)):
print(l[i])
`
Que produit ce code ?

]]> Parcourir par élément se lit mieux ;
parcourir par indice devient nécessaire dès
qu'on a besoin de la position, par exemple
pour comparer un élément à son voisin.

]]> 1.0 0.0 0 true true abc Il affiche deux fois de suite les valeurs 4, 7 et 2

]]> Bonne réponse : les deux parcours
donnent les mêmes valeurs, dans le même
ordre. Le second connaît en plus la
position de chaque élément.

]]> Il affiche les valeurs, puis les indices 0, 1 et 2

]]> Erreur : la seconde boucle affiche
l[i], c'est-à-dire la valeur rangée à
l'indice i.

]]> Il affiche les valeurs, puis la liste entière trois fois

]]> Erreur : l[i] désigne un élément, pas
la liste.

]]> Il déclenche une exception à la seconde boucle

]]> Erreur : range(len(l)) produit
exactement les indices valides.

]]> Tuples et listes — Q47 : Somme des éléments `python
notes = [12, 15, 9]
total = 0
for n in notes:
total = total + n
print(total)
`
Que produit ce code ?

]]> L'accumulateur initialisé à 0 avant la
boucle est le schéma de base d'un calcul
sur une liste : somme, produit, moyenne,
comptage en dérivent tous.

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

]]> Erreur : 9 est la dernière note, pas
la somme.

]]> Il affiche [12, 15, 9]

]]> Erreur : total est un nombre, pas une
liste.

]]> Il affiche 36

]]> Bonne réponse : l'accumulateur part de
0 et reçoit chaque note, d'où
12 + 15 + 9 = 36.

]]> Il affiche 12

]]> Erreur : ce serait le résultat si
total était réaffecté à chaque tour
au lieu d'être augmenté.

]]> Tuples et listes — Q48 : Chercher le maximum `python
valeurs = [3, 9, 4]
m = valeurs[0]
for v in valeurs:
if v > m:
m = v
print(m)

Pourquoi initialise-t-on m avec
valeurs[0]` ?

]]> Initialiser avec un élément de la liste,
plutôt qu'avec 0, est la précaution qui
rend l'algorithme correct pour des valeurs
négatives.

]]> 1.0 0.0 0 true true abc Parce qu'une variable doit toujours valoir 0 au départ

]]> Erreur : initialiser à 0 donnerait un
résultat faux si toutes les valeurs
étaient négatives.

]]> Pour partir d'une valeur de la liste

]]> Bonne réponse : en partant du premier
élément, la comparaison a du sens dès le
premier tour, quelles que soient les
valeurs, y compris négatives.

]]> Pour que la boucle commence à l'indice 1

]]> Erreur : la boucle parcourt toute la
liste, le premier élément est
simplement comparé à lui-même.

]]> Parce que le maximum est toujours le premier élément

]]> Erreur : ici le maximum est 9, qui
n'est pas en première position.

]]> Tuples et listes — Q49 : Compréhension avec condition On dispose de notes = [8, 14, 11, 5].
Quelle expression construit la liste des
notes supérieures ou égales à 10 ?

]]> Une compréhension se lit dans l'ordre :
ce qu'on garde, d'où ça vient, à quelle
condition. Elle remplace une boucle avec
append en une ligne.

]]> 1.0 0.0 0 true true abc [n if n >= 10 for n in notes]

]]> Erreur : la condition de filtre se place
après la boucle, pas avant.

]]> [notes if n >= 10], sans boucle explicite

]]> Erreur : il manque la boucle for, qui
parcourt les éléments un à un.

]]> [n >= 10 for n in notes], qui teste chaque note

]]> Erreur : cette expression construit une
liste de booléens, [False, True, True,
False], et non les notes elles-mêmes.

]]> [n for n in notes if n >= 10]

]]> Bonne réponse : la condition filtre les
éléments gardés, ici [14, 11].

]]> Tuples et listes — Q50 : Tableau à deux dimensions `python
grille = [[1, 2, 3], [4, 5, 6]]
print(grille[1][2])
`
Que produit ce code ?

]]> Un tableau de données se range souvent
ainsi : une liste de lignes, chaque ligne
étant une liste de valeurs. Le premier
indice choisit la ligne, le second la
colonne.

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

]]> Erreur : le second indice descend dans
la ligne, il ne l'affiche pas en
entier.

]]> Il affiche 6

]]> Bonne réponse : grille[1] désigne la
deuxième ligne [4, 5, 6], et [2] en
prend le troisième élément.

]]> Il affiche 3

]]> Erreur : ce serait grille[0][2], sur
une autre ligne.

]]> Il affiche 2, l'élément d'indice 1 dans la liste aplatie

]]> Erreur : une liste de listes n'est pas
aplatie, les deux indices désignent la
ligne puis la colonne.

]]> Tuples et listes — Q51 : Travailler sur une copie `python
original = [1, 2, 3]
copie = original[:]
copie.append(4)
print(original, copie)
`
Que produit ce code ?

]]> Retenir la différence : copie = original
partage la même liste, copie = original[:]
en fabrique une nouvelle. C'est la
précaution à prendre avant toute
modification.

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

]]> Erreur : ce serait le cas avec
copie = original, qui donne deux noms
à la même liste.

]]> Il déclenche une exception, une liste ne se copiant pas ainsi

]]> Erreur : original[:] est une écriture
courante et valide pour copier une
liste.

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

]]> Bonne réponse : la tranche construit une
nouvelle liste. Modifier la copie laisse
l'originale intacte.

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

]]> Erreur : la copie contient déjà les
trois valeurs avant l'ajout.

]]> Tuples et listes — Q52 : Lignes et colonnes d'un tableau `python
t = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

Combien de lignes et de colonnes possède le tableau
t` ?

]]> Un tableau à deux dimensions est une liste de
listes : la liste extérieure contient les lignes,
chaque ligne contient les colonnes. len(t) donne
le nombre de lignes, len(t[0]) le nombre de
colonnes.

]]> 1.0 0.0 0 true true abc 3 lignes et 4 colonnes

]]> Chaque liste intérieure est une ligne ; il y en a
quatre, de trois éléments chacune.

]]> 4 lignes et 3 colonnes

]]> len(t) vaut 4 (quatre listes intérieures) et
len(t[0]) vaut 3.

]]> 4 lignes et 4 colonnes

]]> Une ligne compte trois éléments : t[0] est
[0, 1, 2].

]]> 12 lignes et 1 colonne

]]> Les douze valeurs sont réparties en quatre listes
de trois, pas en douze listes d'un élément.

]]> Tuples et listes — Q53 : Modifier une case d'une grille `python
grille = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
grille[2][0] = 0
print(grille)
`

Qu'affiche ce programme ?

]]> grille[i][j] se lit de gauche à droite :
grille[i] sélectionne la ligne d'indice i, puis
[j] la colonne. Les indices commencent à 0 :
la ligne 2 est la troisième, la colonne 0 la
première.

]]> 1.0 0.0 0 true true abc [[1, 2, 0], [4, 5, 6], [7, 8, 9]]

]]> Les indices sont lus dans l'ordre ligne puis
colonne : 2 puis 0, pas 0 puis 2.

]]> [[1, 2, 3], [4, 5, 6], [7, 8, 0]]

]]> [0] désigne le premier élément de la ligne, pas
le dernier.

]]> [[1, 2, 3], [4, 5, 6], [0, 8, 9]]

]]> grille[2] est la troisième ligne, [7, 8, 9],
et [0] en désigne le premier élément.

]]> [[0, 2, 3], [4, 5, 6], [7, 8, 9]]

]]> Ce serait grille[0][0] = 0 ; le premier indice
choisit la ligne, pas la colonne.

]]> Tuples et listes — Q54 : Somme d'une colonne `python
t = [[1, 2], [3, 4], [5, 6]]
total = 0
for i in range(len(t)):
total = total + t[i][1]
print(total)
`

Qu'affiche ce programme ?

]]> La boucle parcourt les indices de ligne ; à chaque
tour, elle ajoute l'élément de colonne 1 de la
ligne courante. Pour sommer une ligne entière, on
parcourrait au contraire les indices de colonne à
ligne fixée.

]]> 1.0 0.0 0 true true abc 9

]]> 1 + 3 + 5 serait la somme de la colonne
d'indice 0.

]]> 12

]]> t[i][1] est le deuxième élément de chaque
ligne : 2 + 4 + 6 = 12.

]]> 21

]]> C'est la somme de toutes les valeurs ; la boucle
n'ajoute qu'un élément par ligne.

]]> 6

]]> Ce serait la dernière valeur lue, pas la somme
accumulée dans total.

]]> Tuples et listes — Q55 : Construire une grille par compréhension `python
m = [[0 for j in range(3)] for i in range(2)]

Quelle valeur reçoit m` ?

]]> Une compréhension dans une compréhension : la partie
intérieure [0 for j in range(3)] construit une
ligne, la partie extérieure répète cette
construction pour chaque i. C'est la façon sûre de
créer une grille vide, chaque ligne étant une liste
distincte.

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

]]> L'expression produite est 0, pas j ; la
variable j ne sert qu'à répéter trois fois.

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

]]> range(2) est à l'extérieur : il fixe le nombre
de lignes à deux, et range(3) le nombre de
colonnes à trois.

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

]]> La compréhension extérieure fabrique deux lignes ;
chacune est une liste de trois zéros.

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

]]> Les crochets intérieurs créent une liste par
ligne ; le résultat n'est pas aplati.

]]> Tuples et listes — Q56 : Deux lignes qui n'en font qu'une `python
ligne = [0, 0, 0]
m = [ligne, ligne]
m[0][0] = 5
print(m)
`

Qu'affiche ce programme ?

]]> [ligne, ligne] ne copie pas ligne : il range
deux fois la même référence. Pour obtenir deux
lignes indépendantes, on construit chaque ligne
séparément, par exemple avec
[[0 for j in range(3)] for i in range(2)].

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

]]> L'affectation m[0][0] = 5 modifie bien la
liste ; elle n'est pas sans effet.

]]> Une erreur, car une liste ne peut pas contenir deux fois la même liste

]]> Python l'accepte sans broncher ; c'est
précisément ce qui rend le piège discret.

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

]]> m[0] et m[1] désignent la même liste
ligne ; la modifier par l'une se voit par
l'autre.

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

]]> Ce serait le cas si les deux lignes étaient des
listes distinctes ; ici elles sont la même liste.

]]> Tuples et listes — Q57 : Plusieurs valeurs renvoyées par une fonction Une fonction division(a, b) doit renvoyer à la fois le quotient
et le reste de la division euclidienne de a par b. Quelle
solution est la plus naturelle en Python ?

]]> Dès qu'une fonction produit plusieurs résultats de nature fixée, le
tuple est l'outil adapté : return q, r construit le tuple et
q, r = division(a, b) le décompose.

]]> 1.0 0.0 0 true true abc Renvoyer la chaîne "q,r" que l'appelant découpe et reconvertit

]]> Erreur : transformer des entiers en texte oblige l'appelant à
découper puis reconvertir. Un tuple transmet directement les deux
entiers.

]]> Renvoyer le tuple (q, r), décomposé par q, r = division(a, b)

]]> Bonne réponse : un tuple regroupe des valeurs de rôles fixés, en
nombre connu. L'affectation multiple le décompose en une ligne,
sans que personne n'ait à le modifier ensuite.

]]> Ranger le reste dans une variable extérieure et ne renvoyer que le quotient

]]> Erreur : une variable extérieure cache une partie du résultat et
rend la fonction dépendante de son contexte. Renvoyer les deux
valeurs ensemble est plus clair et plus sûr.

]]> Écrire deux instructions return successives, une par valeur

]]> Erreur : la première instruction return termine la fonction.
La seconde ne serait jamais exécutée et le reste serait perdu.

]]> Tuples et listes — Q58 : Données transmises sans risque de modification Les réglages d'un jeu (largeur de la grille, hauteur, nombre de
vies) sont transmis à de nombreuses fonctions, dont aucune ne doit
pouvoir les altérer par erreur. Quel choix de structure apporte
cette garantie ?

]]> Choisir un tuple pour des données qui ne doivent pas changer
transforme une erreur silencieuse en erreur signalée : c'est la
garantie que la liste ne peut pas offrir.

]]> 1.0 0.0 0 true true abc Un tuple, car toute tentative de modification en place lève une erreur

]]> Bonne réponse : un tuple est immuable. Une fonction qui
tenterait reglages[0] = 50 provoquerait une erreur, ce qui
révèle le bug au lieu de le laisser corrompre les réglages.

]]> Une liste, accompagnée d'un commentaire demandant de ne pas la modifier

]]> Erreur : un commentaire n'empêche rien. Une faute d'inattention
dans l'une des fonctions suffirait à modifier les réglages sans
qu'aucune erreur ne soit signalée.

]]> Trois variables séparées, recopiées au début de chaque fonction

]]> Erreur : recopier trois valeurs dans chaque fonction alourdit le
code et n'empêche pas une fonction d'oublier la copie. Le tuple
regroupe les réglages et les protège d'un coup.

]]> Une liste, car une fonction ne peut jamais modifier une liste reçue en paramètre

]]> Erreur : c'est l'inverse. Une liste passée en paramètre est
partagée avec l'appelant, et reglages[0] = 50 dans la fonction
modifie bien la liste d'origine.

]]> Tuples et listes — Q59 : Bornes d'une tranche On dispose de L = [10, 20, 30, 40, 50, 60].
Que vaut L[1:4] ?

]]> L[a:b] contient les éléments d'indice
a, a + 1, … jusqu'à b - 1 : on en
obtient b - a. La fin est exclue, comme
pour range(a, b).

]]> 1.0 0.0 0 true true abc La liste [30, 40, 50], les indices commençant à 1

]]> Erreur : le premier élément a l'indice
0. L'élément d'indice 1 est donc
20.

]]> La liste [20, 50], formée des deux éléments aux bornes

]]> Erreur : une tranche prend tous les
éléments entre les deux bornes, pas
seulement les éléments aux bornes.

]]> La liste [20, 30, 40]

]]> Bonne réponse : la tranche part de
l'indice 1 inclus et s'arrête juste
avant l'indice 4.

]]> La liste [20, 30, 40, 50], les deux bornes étant incluses

]]> Erreur : l'indice de fin est toujours
exclu, comme dans range(1, 4).

]]> Tuples et listes — Q60 : Début omis On dispose de L = [3, 1, 4, 1, 5, 9].
Que vaut L[:2] ?

]]> Un début omis vaut 0 : L[:k] donne les
k premiers éléments.

]]> 1.0 0.0 0 true true abc La liste [4, 1, 5, 9]

]]> Erreur : c'est L[2:]. Ici, le nombre
est placé après les deux-points : c'est
la fin, pas le début.

]]> La liste [3, 1]

]]> Bonne réponse : le début omis vaut 0.
On prend les éléments d'indice 0 à
2 exclu, soit les 2 premiers.

]]> La liste [3, 1, 4], l'indice 2 étant inclus

]]> Erreur : la fin est exclue, même quand
le début est omis.

]]> La liste [5, 9], les 2 derniers éléments

]]> Erreur : les 2 derniers s'écrivent
L[-2:]. Sans signe moins, on part
du début.

]]> Tuples et listes — Q61 : Fin omise On dispose de L = [10, 20, 30, 40, 50].
Que vaut L[2:] ?

]]> Une fin omise vaut len(L) : L[k:]
donne tout à partir de l'indice k
inclus. Avec L[:k], les deux tranches
se partagent la liste sans chevauchement.

]]> 1.0 0.0 0 true true abc La liste [30], réduite à l'élément d'indice 2

]]> Erreur : les deux-points demandent une
tranche, qui va ici jusqu'au bout de la
liste.

]]> La liste [40, 50], l'indice 2 étant exclu

]]> Erreur : seul l'indice de fin est
exclu. Le début est toujours inclus.

]]> La liste [10, 20]

]]> Erreur : c'est L[:2], les éléments
placés avant l'indice 2.

]]> La liste [30, 40, 50]

]]> Bonne réponse : la fin omise vaut
len(L). On prend tout à partir de
l'indice 2 inclus.

]]> Tuples et listes — Q62 : Les derniers éléments On dispose de L = [2, 4, 6, 8, 10].
Que vaut L[-2:] ?

]]> L[-k:] donne les k derniers éléments,
L[:-k] tout sauf ces k derniers.

]]> 1.0 0.0 0 true true abc La liste [2, 4, 6], tout sauf les 2 derniers

]]> Erreur : c'est L[:-2], où -2 est
la fin de la tranche et non son début.

]]> La liste [2, 4], les 2 premiers éléments

]]> Erreur : un indice négatif se compte à
partir de la fin de la liste.

]]> La liste [10, 8], les 2 derniers dans l'ordre inverse

]]> Erreur : sans pas négatif, une tranche
garde toujours l'ordre de la liste.

]]> La liste [8, 10], les 2 derniers éléments

]]> Bonne réponse : l'indice -2 désigne
le 2e élément en partant de la fin,
et la fin omise va jusqu'au bout.

]]> Tuples et listes — Q63 : Retirer le premier et le dernier caractère On dispose de s = "bonjour".
Que vaut s[1:-1] ?

]]> s[1:-1] retire le premier et le dernier
caractère. C'est le même découpage sur une
chaîne que sur une liste.

]]> 1.0 0.0 0 true true abc La chaîne 'onjou'

]]> Bonne réponse : on part de l'indice 1
(le 'o') et on s'arrête avant le
dernier caractère, d'indice -1.

]]> Une erreur, les indices négatifs étant interdits dans une tranche

]]> Erreur : les indices négatifs sont
permis dans une tranche, comme dans
un accès simple.

]]> La chaîne 'onjour'

]]> Erreur : la fin -1 est exclue, le
dernier caractère n'est donc pas pris.

]]> La chaîne 'bonjou'

]]> Erreur : l'indice 1 désigne le
deuxième caractère. Le 'b' a l'indice
0 et n'est pas pris.

]]> Tuples et listes — Q64 : Un élément sur deux On dispose de L = [10, 11, 12, 13, 14, 15, 16].
Que vaut L[1::2] ?

]]> L[début:fin:pas] : le pas est l'écart
entre deux indices pris. L[::2] prend
les indices pairs, L[1::2] les indices
impairs.

]]> 1.0 0.0 0 true true abc La liste [13, 14, 15, 16], le 2 s'ajoutant au début

]]> Erreur : le troisième nombre est
l'écart entre deux indices pris, pas un
décalage du début.

]]> La liste [11, 13, 15]

]]> Bonne réponse : on part de l'indice
1 et on avance de 2 en 2
jusqu'au bout de la liste.

]]> La liste [10, 12, 14, 16]

]]> Erreur : c'est un élément sur deux,
mais à partir de l'autre indice de
départ. Ici, le départ est 1.

]]> La liste [11], le 2 étant la fin

]]> Erreur : avec deux fois deux-points, le
nombre placé en dernier est le pas,
pas la fin.

]]> Tuples et listes — Q65 : Inverser une chaîne On dispose de mot = "python".
Que vaut mot[::-1] ?

]]> mot[::-1] renvoie la séquence à
l'envers. Cela marche aussi sur une liste
ou un tuple.

]]> 1.0 0.0 0 true true abc La chaîne 'nohtyp'

]]> Bonne réponse : avec un pas de -1,
on parcourt la chaîne de la fin vers le
début.

]]> La chaîne 'n', le dernier caractère

]]> Erreur : c'est mot[-1], un accès à un
seul caractère, sans deux-points.

]]> La chaîne 'pytho', sans le dernier caractère

]]> Erreur : c'est mot[:-1]. Ici, -1
est en troisième position : c'est le
pas.

]]> La chaîne 'ython', sans le premier caractère

]]> Erreur : c'est mot[1:]. Un pas
négatif ne retire rien, il renverse
l'ordre.

]]> Tuples et listes — Q66 : Tester un palindrome ``python
def est_palindrome(mot):
return mot == mot[::-1]

print(est_palindrome("kayak"))
print(est_palindrome("radis"))
``
Que produit ce code ?

]]> Un mot est un palindrome quand il est égal
à son inverse : mot == mot[::-1] le teste
en une seule ligne.

]]> 1.0 0.0 0 true true abc Il affiche False puis False, mot[::-1] ne changeant rien

]]> Erreur : avec un pas de -1, la chaîne
est bien renversée.

]]> Une erreur, une chaîne ne pouvant pas être comparée à une tranche

]]> Erreur : une tranche de chaîne est une
chaîne, la comparaison est donc
possible.

]]> Il affiche True puis False

]]> Bonne réponse : "kayak" se lit de la
même façon dans les deux sens, pas
"radis", qui donne "sidar".

]]> Il affiche True puis True

]]> Erreur : "radis"[::-1] vaut "sidar",
qui est différent de "radis".

]]> Tuples et listes — Q67 : Indexation ou tranche `python
L = ['a', 'b', 'c', 'd']
x = L[1]
y = L[1:2]

Que valent x et y` ?

]]> L'indexation renvoie un élément, la
tranche renvoie une nouvelle séquence. On
ne peut donc pas écrire L[1:2] + 1 si
L contient des nombres.

]]> 1.0 0.0 0 true true abc x et y valent tous deux ['b']

]]> Erreur : sans deux-points, on accède à
l'élément lui-même, ici une chaîne.

]]> x vaut 'b' et y vaut ['b', 'c']

]]> Erreur : l'indice de fin 2 est exclu,
seul l'élément d'indice 1 est pris.

]]> x vaut 'b' et y vaut ['b']

]]> Bonne réponse : L[1] est un élément,
L[1:2] est une liste qui contient cet
élément.

]]> x et y valent tous deux 'b'

]]> Erreur : avec deux-points, le résultat
est toujours une liste, même s'il n'a
qu'un élément.

]]> Tuples et listes — Q68 : Tranche qui dépasse la liste On dispose de L = [1, 2, 3, 4].
Que vaut L[2:10] ?

]]> Contrairement à L[i], une tranche ne
déclenche jamais d'erreur d'indice : les
bornes trop grandes sont ramenées à la
longueur.

]]> 1.0 0.0 0 true true abc Une erreur IndexError, l'indice 10 n'existant pas

]]> Erreur : seul l'accès à un élément,
comme L[10], provoque IndexError.
Une tranche s'arrête au bout de la liste.

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

]]> Erreur : une tranche ne crée pas
d'éléments, elle prend seulement ceux
qui existent.

]]> La liste [3, 4]

]]> Bonne réponse : une borne trop grande
est ramenée à la longueur de la liste,
sans erreur.

]]> La liste vide []

]]> Erreur : les éléments d'indice 2 et
3 existent et sont pris.

]]> Tuples et listes — Q69 : Tranche vide On dispose de L = [5, 6, 7, 8, 9].
Que vaut L[3:1] ?

]]> Avec un pas positif, si le début n'est pas
avant la fin, la tranche est vide.

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

]]> Bonne réponse : avec le pas 1 par
défaut, on avance vers la droite. Partir
de l'indice 3 pour s'arrêter avant
l'indice 1 ne prend aucun élément.

]]> La liste [8, 7], parcourue à l'envers

]]> Erreur : il faudrait un pas négatif,
L[3:1:-1], pour aller vers la gauche.

]]> Une erreur, le début étant plus grand que la fin

]]> Erreur : une tranche ne déclenche pas
d'erreur ; elle est simplement vide.

]]> La liste [6, 7], les bornes étant remises dans l'ordre

]]> Erreur : Python ne réordonne pas les
bornes. [6, 7] est L[1:3].

]]> Tuples et listes — Q70 : Modifier une tranche `python
L = [1, 2, 3, 4]
T = L[1:3]
T[0] = 99
print(L)
`
Que produit ce code ?

]]> Une tranche fabrique une nouvelle
séquence. C'est pourquoi L[:] sert à
copier une liste.

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

]]> Erreur : ce serait le cas si T était
un autre nom de la même liste. Une
tranche est une copie.

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

]]> Erreur : T[0] est le premier élément
de T, et T est de toute façon
distincte de L.

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

]]> Bonne réponse : T est une nouvelle
liste, [2, 3]. La modifier ne change
pas L.

]]> Une erreur, une tranche ne pouvant pas être modifiée

]]> Erreur : T est une liste ordinaire, on
peut la modifier.

]]> Tuples et listes — Q71 : Remplacer une portion de liste `python
L = ['a', 'b', 'c', 'd', 'e']
L[1:3] = ['X', 'Y', 'Z']
print(L)
`
Que produit ce code ?

]]> Sur une liste, on peut affecter une
tranche : la portion choisie est remplacée
par une autre, de taille quelconque.

]]> 1.0 0.0 0 true true abc Il affiche ['a', 'X', 'Y', 'Z', 'd', 'e']

]]> Bonne réponse : les éléments d'indice
1 et 2 ('b' et 'c') sont remplacés
par les trois nouveaux. La liste
s'allonge d'un élément.

]]> Il affiche ['a', 'X', 'Y', 'd', 'e'], la liste gardant sa taille

]]> Erreur : tous les éléments de droite
sont insérés, même s'ils sont plus
nombreux que ceux qu'ils remplacent.

]]> Une erreur, les deux tailles étant différentes

]]> Erreur : avec un pas de 1, Python
accepte un remplacement de taille
différente.

]]> Il affiche ['a', 'X', 'Y', 'Z', 'e']

]]> Erreur : la fin 3 est exclue, 'd'
n'est pas remplacé.

]]> Tuples et listes — Q72 : Modifier une tranche de chaîne `python
s = "python"
s[0:2] = "PY"
`
Que se passe-t-il ?

]]> On découpe une chaîne librement, mais on
ne la modifie pas : pour changer des
caractères, on fabrique une nouvelle
chaîne avec des tranches et +.

]]> 1.0 0.0 0 true true abc Une erreur TypeError : une chaîne ne se modifie pas

]]> Bonne réponse : une chaîne est
immuable. On construit une nouvelle
chaîne : s = "PY" + s[2:].

]]> s reste 'python', sans message d'erreur

]]> Erreur : Python signale l'opération
interdite par une erreur.

]]> s devient 'PYpython', "PY" étant inséré au début

]]> Erreur : même sur une liste, la portion
serait remplacée et non complétée. Et
sur une chaîne, Python refuse.

]]> s devient 'PYthon'

]]> Erreur : l'affectation d'une tranche
n'est permise que sur une liste.

]]> Tuples et listes — Q73 : Rotation d'une liste On dispose de L = [1, 2, 3, 4, 5].
Que vaut L[2:] + L[:2] ?

]]> L[k:] + L[:k] fait tourner la liste de
k crans vers la gauche : les k premiers
éléments passent à la fin.

]]> 1.0 0.0 0 true true abc La liste [3, 4, 5]

]]> Erreur : + met bout à bout les deux
tranches, aucun élément n'est perdu.

]]> La liste [1, 2, 3, 4, 5], inchangée

]]> Erreur : l'ordre des deux morceaux
compte. Ici, la fin passe devant.

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

]]> Bonne réponse : on met la fin de la
liste (à partir de l'indice 2)
devant ses 2 premiers éléments.

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

]]> Erreur : c'est la rotation dans l'autre
sens, L[-2:] + L[:-2].

]]> Tuples et listes — Q74 : Tranche d'un tuple avec un pas On dispose de T = ('a', 'b', 'c', 'd', 'e').
Que vaut T[::2] ?

]]> Les tuples acceptent toutes les tranches,
pas compris : seule l'affectation d'une
tranche leur est interdite.

]]> 1.0 0.0 0 true true abc La liste ['a', 'c', 'e']

]]> Erreur : une tranche garde le type de
départ. Sur un tuple, elle renvoie un
tuple.

]]> Le tuple ('a', 'c', 'e')

]]> Bonne réponse : un élément sur deux à
partir de l'indice 0, et le résultat
est un tuple, comme T.

]]> Le tuple ('a', 'b'), les deux premiers éléments

]]> Erreur : le 2 est ici le pas, pas la
fin : il faudrait T[:2].

]]> Le tuple ('b', 'd')

]]> Erreur : ce sont les indices impairs,
T[1::2]. Sans début, on part de
l'indice 0.

]]>