QCM : Listes en Python — 25 questions

Questions et réponses du QCM

1. Quelle propriété caractérise une liste en Python par rapport à d’autres structures de données ?

Elle est immuable et sa taille ne peut jamais changer
Elle n’est qu’un type de tableau homogène
Elle peut contenir des objets de types différents, y compris d’autres listes
Elle ne peut contenir que des nombres entiers

Elle peut contenir des objets de types différents, y compris d’autres listes

Explication

Une liste est une séquence d’objets pouvant être de types différents, y compris d’autres listes. Par exemple, la comparaison avec un tuple porte notamment sur la mutabilité, mais la propriété testée ici concerne la composition des éléments.

2. Comment écrire correctement une liste en Python pour y placer des éléments séparés par des virgules ?

Entre parenthèses, les éléments étant séparés par des virgules
Avec des accolades et des éléments séparés par des virgules
En écrivant uniquement le nom de la variable sans symbole
Entre crochets, les éléments étant séparés par des virgules

Entre crochets, les éléments étant séparés par des virgules

Explication

Une liste s’écrit entre crochets, avec ses éléments séparés par des virgules. Les parenthèses renvoient plutôt à un tuple ou à une expression, pas à une liste.

3. Par quoi chaque élément d’une liste est-il repéré lors de l’accès ?

Par une étiquette unique non numérique
Par une position numérotée à partir de 1
Par une clé de type chaîne
Par un indice entier

Par un indice entier

Explication

Chaque élément d’une liste est repéré par un indice entier. On confond souvent avec les clés de dictionnaire, mais une liste n’utilise pas de clés nommées.

4. Quelle compréhension de liste produit une liste contenant les carrés des entiers de 0 à 9 ?

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

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

Explication

La compréhension [i**2 for i in range(10)] construit directement une nouvelle liste de carrés. Une simple boucle for seule ne construit pas automatiquement cette liste de façon équivalente.

5. Que renvoie l’expression len(L) pour une liste L ?

Le nombre d’éléments distincts de L
Le dernier indice de la liste L
Le nombre d’objets présents dans la liste L
La valeur maximale contenue dans L

Le nombre d’objets présents dans la liste L

Explication

len(L) renvoie la longueur de la liste, c’est-à-dire le nombre d’objets qu’elle contient. Ce n’est pas le dernier indice (qui est lié à la longueur).

6. Si une liste L a une longueur n, quel est le dernier indice positif de ses éléments ?

0
n+1
n-1
n

n-1

Explication

Avec l’indexation positive, le dernier indice est n-1. Le dernier indice n’est pas égal à n, car les indices commencent à 0.

7. Pour L = [1, 2.5, [1, 2], 'A'], que vaut L[-2] ?

1
'A'
[1, 2]
2.5

[1, 2]

Explication

Ici, L[-2] désigne l’avant-dernier élément, qui vaut [1, 2]. Par exemple, L[2] correspond bien à [1, 2], mais l’item demandé utilise l’indice négatif.

8. Quelle caractéristique fait qu’une liste peut être modifiée élément par élément ?

Elle est mutable, donc ses éléments peuvent être modifiés individuellement
Elle ne peut contenir que des nombres entiers
Elle n’est pas itérable
Elle est immuable, donc ses éléments ne peuvent pas changer

Elle est mutable, donc ses éléments peuvent être modifiés individuellement

Explication

Une liste est un objet mutable : on peut modifier ses éléments individuellement. Une chaîne est indexable mais n’offre pas la même mutabilité qu’une liste.

9. Quelle instruction modifie un élément d’une liste en Python ?

liste[1] = 3
liste(1) = 3
liste[1] + 3
liste[1] == 3

liste[1] = 3

Explication

L’affectation par indice (liste[1] = 3) modifie l’élément ciblé. L’opérateur == ne modifie rien : il teste seulement l’égalité.

10. Quel mécanisme de parcours fournit à la fois l’indice i et l’élément L[i] ?

for el in range(len(L)): accéder à el
for i in L: i donne uniquement les indices
for i in range(len(L)): accéder à L[i]
for el in L: accéder à el sans indice

for i in range(len(L)): accéder à L[i]

Explication

Le parcours par indice utilise typiquement for i in range(len(L)) pour accéder à L[i] et donc obtenir à la fois i et l’élément. Le parcours par élément donne directement les valeurs, pas leurs indices.

11. Pourquoi peut-on parcourir une liste directement avec un for du type for el in L ?

Parce qu’une liste est un objet itérable
Parce que chaque élément doit être une liste
Parce que la liste est immuable
Parce qu’une liste est indexée par des clés nommées

Parce qu’une liste est un objet itérable

Explication

Une liste est un objet itérable : on peut la parcourir directement par élément avec for el in L. L’indexation concerne plutôt l’accès par positions, pas l’itération directe.

12. Que fait la concaténation avec l’opérateur + entre deux listes ?

Elle crée une nouvelle liste en mettant les deux listes bout à bout
Elle ajoute seulement le premier élément de la seconde liste à la première
Elle compare les listes au lieu de les fusionner
Elle modifie la première liste sans en créer une nouvelle

Elle crée une nouvelle liste en mettant les deux listes bout à bout

Explication

La concaténation avec + met deux listes bout à bout et produit une nouvelle liste. À la différence, append ajoute un seul objet, alors que + combine les listes entières.

13. Quand l’expression L1 == L2 renvoie-t-elle True ?

Quand L1 et L2 ont la même longueur, même si les éléments diffèrent
Quand L1 et L2 ont les mêmes éléments dans le même ordre
Toujours, dès qu’elles sont deux listes
Quand L1 et L2 contiennent les mêmes éléments, dans n’importe quel ordre

Quand L1 et L2 ont les mêmes éléments dans le même ordre

Explication

L’égalité == entre listes renvoie True seulement si elles ont les mêmes éléments dans le même ordre. Un ordre différent conduit à False.

14. Quelle opération correspond à l’évaluation de 7 in L ?

Accès par indice : récupérer l’élément d’indice 7
Concaténation de la valeur 7 à la fin de L
Multiplication de la liste par 7
Test d’appartenance : vérifier si la valeur 7 se trouve dans la liste L

Test d’appartenance : vérifier si la valeur 7 se trouve dans la liste L

Explication

L’opérateur in teste l’appartenance d’une valeur à une liste, ce qui implique un parcours. Confondre avec l’accès par indice mène à chercher à une position précise au lieu de rechercher une valeur.

15. Que fait une instruction de slicing L[dep:fin:pas] par rapport à un accès simple L[i] ?

Elle modifie la liste en supprimant la partie extraite
Elle remplace la liste entière par une liste vide
Elle extrait une sous-liste, pas un seul élément
Elle retourne un seul élément correspondant à l’indice i

Elle extrait une sous-liste, pas un seul élément

Explication

Le slicing extrait une sous-liste avec la syntaxe L[dep:fin:pas], tandis qu’un accès simple L[i] renvoie un élément. Le slicing ne correspond donc pas à l’accès d’un seul item.

16. Dans une écriture du type L[dep:fin:pas], quelle règle s’applique à la borne fin ?

Elle est toujours remplacée par 0 automatiquement
Elle est exclue : elle ne fait pas partie du résultat
Elle est incluse : elle fait partie du résultat
Elle correspond au nombre d’éléments retournés

Elle est exclue : elle ne fait pas partie du résultat

Explication

Dans L[dep:fin:pas], les indices vont de dep inclus à fin exclu. La borne fin n’appartient pas au résultat, contrairement à la confusion des bornes incluses.

17. Quelle instruction supprime un élément ou une tranche d’une liste ?

del L[5] ou del L[:2]
L[5] = []
L.del(5)
L[:2] = None

del L[5] ou del L[:2]

Explication

del supprime un élément ou une tranche en connaissant son indice (par exemple del L[5] ou del L[:2]). Une affectation comme L[i] = [] n’a pas le même effet qu’une suppression.

18. Quelle est la conséquence de l’appel append(objet) sur une liste existante ?

Il ajoute l’objet à la fin de la liste.
Il ajoute tous les éléments d’une seconde liste fournie dans objet.
Il remplace l’objet présent à la fin de la liste par l’objet fourni.
Il insère l’objet à l’indice donné par objet.

Il ajoute l’objet à la fin de la liste.

Explication

append(objet) ajoute un seul objet à la fin de la liste. Une concaténation avec + correspondrait à une autre opération et ne décrit pas le rôle de append.

19. En quoi insert(indice, objet) diffère-t-elle d’une simple affectation du type L[indice] = objet ?

insert insère toujours une sous-liste entière comme élément unique, contrairement à l’affectation.
insert supprime l’élément à l’indice puis insère l’objet à la fin.
insert décale les éléments pour créer une nouvelle place, tandis que l’affectation remplace seulement l’élément existant.
insert remplace l’élément existant à l’indice, tandis que l’affectation crée une nouvelle place.

insert décale les éléments pour créer une nouvelle place, tandis que l’affectation remplace seulement l’élément existant.

Explication

insert(indice, objet) insère et décale les éléments pour créer une place. L’affectation L[indice] = objet ne fait qu’écraser l’élément existant.

20. Quelle expression correspond à l’insertion d’une sous-liste [3, 4] comme un seul élément à l’indice 2 ?

L.insert(2, 3, 4)
L[2:2] = [3, 4]
L[2:2] = [[3, 4]]
L.insert(2, [3, 4])

L.insert(2, [3, 4])

Explication

L.insert(2, [3, 4]) insère la sous-liste comme élément unique à l’indice 2. À l’inverse, L[2:2] = [3, 4] insère les éléments 3 et 4 séparément.

21. Que fait pop() lorsqu’il est appelé sans argument sur une liste ?

Il supprime la première occurrence d’une valeur donnée.
Il supprime tous les éléments qui valent la valeur fournie.
Il renvoie un nouvel objet liste sans modifier la liste d’origine.
Il renvoie le dernier élément puis le supprime de la liste.

Il renvoie le dernier élément puis le supprime de la liste.

Explication

pop() renvoie le dernier élément puis le retire de la liste. La suppression par valeur correspond à remove(valeur), pas à pop().

22. Que produit une affectation du type L2 = L1 sur les listes en mémoire ?

Elle copie les éléments et crée une liste indépendante en mémoire.
Elle crée une deuxième étiquette pointant vers le même objet liste.
Elle rend les deux listes immuables et sans lien.
Elle effectue une copie profonde des sous-listes.

Elle crée une deuxième étiquette pointant vers le même objet liste.

Explication

Une affectation L2 = L1 ne duplique pas la liste : elle crée une autre étiquette vers le même objet. Une copie indépendante nécessiterait une autre méthode (par exemple une copie par tranche ou deepcopy).

23. Si L2 = L1 puis qu’on modifie L1, que se passe-t-il pour L2 ?

La modification ne concerne que la variable L2, pas la liste.
L’effet dépend uniquement du fait que les éléments soient entiers.
Aucune modification ne se reflète sur L2, car les listes sont séparées.
La modification est répercutée sur L2, car elles partagent le même objet liste.

La modification est répercutée sur L2, car elles partagent le même objet liste.

Explication

Les listes étant mutables, modifier via L1 après L2 = L1 se répercute sur L2 puisque les deux étiquettes pointent vers le même objet. Le cas des entiers ne supprime pas ce mécanisme pour les listes elles-mêmes.

24. Que duplique exactement L3 = L1[:] par rapport à L1 ?

Elle duplique la liste extérieure, sans dupliquer les sous-listes internes.
Elle crée une copie indépendante des éléments internes sans dupliquer la liste extérieure.
Elle effectue une copie profonde et recopie récursivement toutes les sous-listes.
Elle supprime des éléments et remplace la tranche copiée par une nouvelle liste vide.

Elle duplique la liste extérieure, sans dupliquer les sous-listes internes.

Explication

L3 = L1[:] duplique la liste extérieure mais ne duplique pas les éléments internes s’ils sont eux-mêmes des listes. Cela reste donc une copie superficielle des sous-listes.

25. Dans le cas où L2 = L1, L3 = L1[:] et L4 = deepcopy(L1), quelle conséquence correspond à l’isolement fourni par deepcopy ?

Une modification de L1 n’affecte que L3, jamais L2.
Une modification de L1[3][0] affecte L4 mais n’affecte pas L3.
Une modification de L1[3][0] n’affecte pas L2, mais affecte L4.
Une modification de L1[3][0] n’affecte pas L4, mais peut affecter L2 et affecter partiellement L3.

Une modification de L1[3][0] n’affecte pas L4, mais peut affecter L2 et affecter partiellement L3.

Explication

deepcopy(L1) isole totalement les sous-listes, donc une modification de L1[3][0] n’affecte pas L4. En revanche, L2 réagit (même objet) et L3 ne protège que partiellement contre les modifications des sous-listes.

Révisez avec les flashcards

Mémorisez les réponses avec 46 flashcards sur Listes en Python.

Qu'est-ce qu'une liste ?

Une séquence d'objets.

Comment s'écrit une liste ?

Entre crochets, avec des virgules entre les éléments.

Par quoi chaque élément d'une liste est-il repéré ?

Par un indice entier.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Listes en Python.

Voir la fiche →

Cours similaires

Gestion des fichiers en PHP

Programmation

Identification utilisateur en PHP

Programmation

Automated PCB Fault Diagnosis

Intelligence Artificielle

Rôle d'un système d'exploitation

Questions techniques projet Compawgnon

Bases de Python pour débutants

Programmation

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM