Listes Python : comment créer, indexer, ajouter, trier et itérer

Les listes sont des séquences ordonnées et mutables

La liste est le type de collection le plus utilisé en Python. Si tu gardes un ensemble ordonné de valeurs qui pourraient changer — ajouter, retirer, trier, mettre à jour — une liste est presque toujours le bon choix.

Tu en crées une avec des crochets :

Les listes peuvent contenir n'importe quoi, même d'autres listes. En pratique, la plupart des listes finissent par contenir une seule sorte de chose — une liste d'utilisateurs, une liste de nombres — parce que c'est ce qui est le plus facile à raisonner.

Indexation

Chaque élément a une position, à partir de 0. Accès avec des crochets :

Demander un indice qui n'existe pas lève IndexError. Si tu risques d'être hors limites, soit vérifie la longueur d'abord, soit enveloppe l'accès dans un try.

Découpage

Le découpage (slicing) te donne une plage d'éléments. La syntaxe est list[start:stop:step], la même que pour les chaînes :

Deux choses à bien ancrer :

• Le découpage renvoie toujours une nouvelle liste. Modifier la tranche n'affecte pas l'original.
• L'indice stop est exclusif — nums[2:5] donne les indices 2, 3 et 4, pas 5.

Comment ajouter, étendre et insérer des éléments

Les trois méthodes d'« ajout à une liste » font des choses différentes, et les confondre est une source courante de bugs :

• append(x) ajoute x comme un seul élément — même si x est une liste. items.append([1, 2]) ajoute la liste elle-même comme une seule entrée.
• extend(iterable) ajoute chaque élément de l'itérable. items.extend([1, 2]) ajoute deux entrées.
• insert(i, x) insère à un indice précis, en décalant tout ce qui est à i ou après d'une position vers la droite.

+= avec une liste à droite fonctionne comme extend :

Et pour retirer :

Si tu essaies de remove() quelque chose qui n'est pas dans la liste, Python lève ValueError. Si tu as besoin de « retirer si présent », soit vérifie avec in d'abord, soit utilise un try.

Tu peux aussi supprimer par indice avec del :

Longueur, appartenance, comptage

in est la façon lisible de vérifier si une liste contient une valeur. Si tu vas poser cette question beaucoup de fois sur une grande liste, utilise plutôt un set — l'appartenance à un set est en O(1), alors que l'appartenance à une liste est en O(n).

Tri

Deux façons, et le choix compte :

Les deux acceptent reverse=True pour l'ordre décroissant :

Et une fonction key pour un ordre personnalisé :

key est appliquée à chaque élément, et c'est le résultat qui est comparé. Cas courants : trier par longueur, par un attribut spécifique ou par la forme en minuscules d'une chaîne.

Inversion

Trois versions, selon ton besoin :

Utilise « sur place » quand tu n'as pas besoin de l'original. Utilise le découpage quand tu veux une nouvelle copie. Utilise reversed() quand tu as juste besoin d'itérer à l'envers sans matérialiser une nouvelle liste.

Le piège de la référence partagée

Les listes sont mutables, et les variables sont des références. Ça veut dire que deux variables peuvent pointer vers la même liste :

b = a n'a pas copié la liste ; ça a fait de b un second nom pour la même liste. Si tu veux une copie, demande-la :

Ça mord chaque programmeur Python au moins une fois. Rappelle-toi : = entre deux listes ne copie pas.

Boucler et construire

Tu connais déjà le motif de base depuis la page sur la boucle for :

C'est lisible et ça ira toujours. Une fois à l'aise, l'équivalent en compréhension de liste fait la même chose en une ligne :

On couvrira les compréhensions en détail dans deux pages.

Une antisèche rapide

Méthodes utiles à connaître, d'un coup d'œil :

• append(x) — ajoute à la fin
• extend(iter) — ajoute chaque élément d'un itérable
• insert(i, x) — insère à l'indice i
• pop() / pop(i) — retire et renvoie
• remove(x) — retire la première occurrence de x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x) — position du premier x
• count(x) — nombre de x
• copy() — copie superficielle

La suite

Les listes sont le cheval de trait. Ensuite, on regarde les tuples — leur cousin immuable — et quand choisir un tuple à la place est la meilleure option.