Listes Python : indices, méthodes et parcours

Ce que tu vas savoir faire

Décrire ordre, indices, doublons et mutabilité d’une liste Python.
Générer une liste en extension, par ajouts successifs ou en compréhension.
Lire et modifier un élément avec un indice valide.
Distinguer append, extend et insert.
Distinguer remove, pop et del et anticiper leurs erreurs possibles.
Parcourir une liste par valeurs, indices ou couples indice-valeur.
Construire et tracer un accumulateur, un compteur ou une liste filtrée.
Distinguer alias et copie et éviter une mutation dangereuse pendant le parcours.

Vérifie tes prérequis

Lire une affectation, une condition et une boucle for en Python.
Connaitre range et len dans des exemples simples.
Distinguer une valeur, une variable et une expression booléenne.

Le chapitre en bref

Une liste Python est une séquence ordonnée et mutable : chaque valeur occupe un indice de 0 à $len(L)−1$ , les doublons sont conservés et une affectation comme L[i] = v modifie une case. On peut générer une liste en extension, par ajouts successifs ou en compréhension. append ajoute un objet, extend ajoute les éléments d’un objet parcourable, remove supprime une valeur et pop une position en renvoyant la valeur retirée. Le bon parcours dépend du besoin : for x in L pour les valeurs, range(len(L)) pour les indices, enumerate(L) pour les deux. Toute boucle doit enfin rendre visible son état : accumulateur, compteur ou nouvelle liste construite.

1. Qu’est-ce qu’une liste conserve exactement ?

Une liste Python conserve une suite ordonnée de valeurs entre crochets. La liste L = [12, 15, 12] possède trois éléments : le doublon 12 reste présent à deux positions. Contrairement à un ensemble mathématique, l’ordre et la répétition font donc partie de la donnée.

Les indices positifs commencent à 0. Si $len(L)=n$ , les indices valides vont de 0 à $n−1$ ; l’accès L[n] provoque une IndexError. Une liste est mutable : L[1] = 18 remplace la valeur d’indice 1 sans changer la longueur.

Valeurs + ordre + indices + mutabilité

Quel état la liste mémorise-t-elle ?

Codenotes = [12, 15, 12]Longueur3Valeur répétée12 deux foisContratordre conservé

Une liste n’élimine pas les doublons : chaque position reste une donnée.

2. Comment passer d’une règle à une liste ?

Une liste en extension écrit ses valeurs directement : carres = [0, 1, 4, 9]. Une construction par ajouts successifs part d’une liste vide, parcourt les valeurs utiles puis exécute carres.append(x**2). La trace des états [], [0], [0, 1], [0, 1, 4], [0, 1, 4, 9] rend l’algorithme contrôlable.

La compréhension carres = [x**2 for x in range(4)] construit la même liste. Lis-la en trois blocs : expression produite x**2 ; parcours for x in range(4) ; filtre éventuel if condition. [x for x in range(8) if x%2 == 0] conserve ainsi 0, 2, 4 et 6.

Extension ↔ ajouts successifs ↔ compréhension

Quelle construction produit exactement la liste voulue ?

Codecarres = [0, 1, 4, 9]Valeursécrites directementAvantageétat immédiatement visibleUsagepetite liste connue

Écrire en extension convient lorsque toutes les valeurs sont déjà connues.

3. La tâche porte-t-elle sur une valeur ou sur sa position ?

Avec L = [4, 7, 9], L[1] lit 7 et ne modifie rien. L[1] = 8 remplace 7 par 8 : la liste devient [4, 8, 9] et garde trois éléments. Pour un indice i fourni par un calcul ou une saisie, le contrôle $0≤i<len(L)$ doit précéder l’accès.

Python autorise des indices négatifs : L[-1] désigne le dernier élément et L[-2] l’avant-dernier. Ce raccourci ne supprime pas la question de la liste vide. Si la position est la donnée importante, conserve l’indice ; si seule la valeur sert au calcul, un accès direct ou un parcours par valeurs suffit.

Indice → lecture → modification → contrôle

La tâche porte-t-elle sur une valeur ou une position ?

ListeL = [4, 7, 9]InstructionL[1]Sortie7État de Linchangé

Lire une case n’altère pas la liste.

4. Pourquoi append([3,4]) et extend([3,4]) ne donnent-ils pas la même liste ?

append ajoute son argument comme un seul nouvel élément. Si L = [1, 2], alors L.append([3, 4]) produit [1, 2, [3, 4]]. extend parcourt son argument et ajoute chaque élément : L.extend([3, 4]) produit [1, 2, 3, 4]. insert(i, x) ajoute x avant l’indice i et décale les éléments suivants.

Ces méthodes modifient la liste sur place et renvoient None. Écrire L = L.append(5) perd donc le nom de la liste en lui affectant None. Pour contrôler une instruction, annonce avant l’exécution : objet ajouté, position visée, variation de longueur et valeur renvoyée.

append ≠ extend ≠ insert

Ajouter un objet ou ajouter tous ses éléments ?

Avant[1, 2]CodeL.append([3, 4])Après[1, 2, [3, 4]]Ajoutun seul objet

append place son argument comme un nouvel élément, même si cet argument est une liste.

5. Veux-tu supprimer une valeur ou une position ?

L.remove(x) supprime la première occurrence égale à x et déclenche ValueError si x est absent. L.pop(i) supprime l’élément d’indice i et le renvoie ; sans indice, pop retire le dernier élément. del L[i] supprime aussi par position mais ne renvoie pas la valeur.

Le contrôle dépend donc de la question. Pour une suppression par valeur, teste x in L si l’absence est possible. Pour une suppression par indice positif, vérifie $0≤i<len(L)$ . Après la mutation, les indices des éléments suivants peuvent changer.

Valeur → remove ; position → pop ou del

Supprimes-tu une valeur ou une position ?

Avant[4, 7, 4]CodeL.remove(4)Après[7, 4]Règlepremière occurrence

remove cherche une valeur et échoue par ValueError si elle est absente.

6. As-tu besoin de la valeur, de l’indice ou des deux ?

for x in L parcourt directement les valeurs : c’est le choix le plus simple pour sommer, tester ou afficher. for i in range(len(L)) parcourt les indices de 0 à $len(L)−1$ et permet d’utiliser ou de modifier L[i]. for i, x in enumerate(L) fournit simultanément indice et valeur.

Ne choisis pas range(len(L)) par réflexe : il ajoute une opération d’indexation inutile si seule x est utilisée. Une liste vide produit zéro tour de boucle ; l’état initial d’un accumulateur reste alors l’état final, ce qui doit être interprété dans le problème.

for valeur ↔ range(len) ↔ enumerate

As-tu besoin de la valeur, de l’indice ou des deux ?

Codefor x in LVariable xvaleur couranteUsagesomme, test, affichageIndiceinutile

Parcours directement les valeurs lorsque leur position ne sert pas au calcul.

7. Comment suivre ce que la boucle a déjà accompli ?

Un accumulateur possède un invariant, c’est-à-dire un sens vrai après chaque tour. Si s = 0 puis s = s + x, s représente la somme des valeurs déjà parcourues. Si c = 0 et c augmente seulement lorsque $x≥10$ , c représente l’effectif des valeurs déjà lues qui vérifient la condition.

Pour filtrer, pars de R = [] puis ajoute à R les valeurs admissibles ; la compréhension construit directement une nouvelle liste équivalente. Une table de trace avec numéro du tour, valeur courante, condition et état après mise à jour révèle les erreurs d’initialisation, de test ou de placement de l’instruction.

Initialiser → parcourir → mettre à jour → interpréter

Quel invariant résume le parcours déjà effectué ?

Initialisations = 0Mise à jours = s + xInvariantsomme des valeurs déjà luesSortiesomme totale

L’accumulateur possède un sens à chaque étape, pas seulement à la fin.

8. Pourquoi B=A peut-il modifier A sans le nommer ?

Après B = A, les deux noms désignent la même liste. B.append(5) modifie donc aussi l’objet observé par A. Pour séparer les modifications de la liste extérieure, utilise B = A.copy() ou une construction nouvelle comme B = [2*x for x in A].

Modifier la longueur de L pendant for x in L décale les positions et peut faire sauter des éléments. Il est généralement plus sûr de construire une nouvelle liste à partir de L. Le contrôle final compare identité des objets, valeurs attendues, longueur et conservation de la source.

Affectation, mutation et copie

Deux noms désignent-ils la même liste ?

CodeB = AActionB.append(5)Effet sur B5 ajoutéEffet sur A5 ajouté aussi

L’affectation partage la même liste ; elle ne copie pas ses éléments.

Erreurs fréquentes

L'essentiel à mémoriser

Les indices commencent à zéro.
Une compréhension produit une nouvelle liste.
Lire, remplacer et ajouter sont trois opérations distinctes.
append et extend n’ajoutent pas la même chose.
Valeur et position choisissent la suppression.
Le besoin choisit le type de parcours.
Un invariant donne un sens à chaque tour.
Alias et copie produisent des mutations différentes.

Vérifier sa compréhension

Réponds aux 8 questions. Ton score et les réponses justes ou fausses apparaissent immédiatement.

1. Si L=[5,8,13], quel est l’indice de 8 ? 1 2 3

2. Que produit [x**2 for x in range(4)] ? [0,1,4,9] [1,4,9,16] [0,2,4,6]

3. Après L=[1,2] puis L.append([3,4]), que vaut L ? [1,2,[3,4]] [1,2,3,4] [3,4]

4. Quelle instruction ajoute séparément 3 et 4 à L ? L.extend([3,4]) L.append([3,4]) L.remove([3,4])

5. Quelle opération retire l’élément d’indice i et renvoie sa valeur ? L.pop(i) L.remove(i) len(L)

6. Quel parcours choisir si seule chaque valeur x est utile ? for x in L for i in range(len(L)) puis ignorer i L.append(x)

7. Après B=A puis B.append(5), que devient A ? A contient aussi 5 A reste toujours inchangée A vaut None

8. Pourquoi construit-on souvent une nouvelle liste pendant un filtrage ? Pour ne pas décaler les éléments de la liste parcourue Parce qu’une liste ne peut jamais être modifiée Pour commencer les indices à 1

Réviser au bon moment

Révèle chaque réponse, puis indique la difficulté de ton rappel pour programmer la prochaine révision dans ce navigateur.