Les listes en Python : le guide complet (méthodes & astuces)

La liste Python est sans doute la structure de données que vous manipulerez le plus souvent. Elle stocke une collection ordonnée d’éléments, modifiable à volonté, capable de mélanger nombres, chaînes et même d’autres listes. Ce guide passe en revue, de façon exhaustive, chaque opération courante — création, indexation, slicing, ajout, suppression, tri, parcours et list comprehension — avec un exemple de code réel à chaque fois.

Créer une liste

Une liste s’écrit entre crochets, ses éléments séparés par des virgules. Elle peut être vide ou contenir n’importe quel type.

vide = []
fruits = ["pomme", "banane", "cerise"]
mixte = [1, "deux", 3.0, True]
nombres = list(range(5))   # [0, 1, 2, 3, 4]

La fonction list() convertit tout itérable (chaîne, tuple, range) en liste. Par exemple list("abc") donne ['a', 'b', 'c'].

Accéder aux éléments (indexation)

Chaque élément possède un indice, qui commence à 0. Les indices négatifs comptent à partir de la fin.

fruits = ["pomme", "banane", "cerise"]
print(fruits[0])    # pomme
print(fruits[2])    # cerise
print(fruits[-1])   # cerise (dernier)
print(fruits[-2])   # banane

Un indice hors limites lève une IndexError. Pour tester la présence d’une valeur, utilisez l’opérateur in : "banane" in fruits renvoie True.

Le slicing (découpage)

Le slicing extrait une sous-liste avec la syntaxe liste[début:fin:pas]. La borne fin est exclue.

nombres = [0, 1, 2, 3, 4, 5, 6]
print(nombres[1:4])    # [1, 2, 3]
print(nombres[:3])     # [0, 1, 2]
print(nombres[3:])     # [3, 4, 5, 6]
print(nombres[::2])    # [0, 2, 4, 6] (un sur deux)
print(nombres[::-1])   # [6, 5, 4, 3, 2, 1, 0] (inversé)

Le slicing renvoie toujours une nouvelle liste, sans modifier l’originale. C’est aussi la façon la plus rapide de copier une liste : copie = nombres[:].

Ajouter des éléments

Plusieurs méthodes existent selon le besoin.

fruits = ["pomme", "banane"]

fruits.append("cerise")          # ajoute à la fin
# ['pomme', 'banane', 'cerise']

fruits.insert(1, "kiwi")         # insère à l'indice 1
# ['pomme', 'kiwi', 'banane', 'cerise']

fruits.extend(["mangue", "figue"])  # ajoute plusieurs éléments
# ['pomme', 'kiwi', 'banane', 'cerise', 'mangue', 'figue']

Attention à la différence entre append et extend : fruits.append(["a", "b"]) ajoute la liste ["a", "b"] comme un seul élément imbriqué, tandis que extend ajoute chaque élément séparément.

Supprimer des éléments

fruits = ["pomme", "kiwi", "banane", "cerise"]

fruits.remove("kiwi")   # supprime la première occurrence de "kiwi"
dernier = fruits.pop()  # retire ET renvoie le dernier élément ("cerise")
premier = fruits.pop(0) # retire l'élément à l'indice 0 ("pomme")
del fruits[0]           # supprime par indice, sans rien renvoyer
fruits.clear()          # vide totalement la liste -> []

remove lève une ValueError si la valeur est absente ; pop lève une IndexError si l’indice n’existe pas. Utilisez pop() quand vous voulez récupérer la valeur retirée, del ou remove quand vous voulez seulement l’éliminer.

Modifier des éléments

Comme une liste est mutable, on réassigne directement par indice ou par tranche.

notes = [12, 8, 15]
notes[1] = 10           # [12, 10, 15]
notes[0:2] = [20, 20]   # remplace une tranche -> [20, 20, 15]

Parcourir une liste (boucle for)

La boucle for reste la manière la plus lisible de parcourir une liste.

fruits = ["pomme", "banane", "cerise"]

for fruit in fruits:
    print(fruit)

# Avec l'indice grâce à enumerate
for i, fruit in enumerate(fruits):
    print(f"{i} : {fruit}")

enumerate fournit à la fois l’indice et la valeur — bien plus propre que range(len(fruits)). Pour parcourir deux listes en parallèle, zip(liste1, liste2) est votre allié.

La list comprehension

La list comprehension construit une liste en une seule ligne. C’est l’un des idiomes les plus puissants du langage.

carres = [n ** 2 for n in range(6)]
# [0, 1, 4, 9, 16, 25]

pairs = [n for n in range(10) if n % 2 == 0]
# [0, 2, 4, 6, 8]

majuscules = [mot.upper() for mot in ["a", "b", "c"]]
# ['A', 'B', 'C']

On peut y ajouter une condition (if) pour filtrer, voire un if/else en début d’expression pour transformer. Si la logique devient illisible, revenez à une boucle classique : la lisibilité prime.

Trier une liste

Deux approches : sort() modifie la liste en place, sorted() renvoie une copie triée.

nombres = [3, 1, 4, 1, 5, 9, 2]

nombres.sort()               # en place -> [1, 1, 2, 3, 4, 5, 9]
nombres.sort(reverse=True)   # décroissant -> [9, 5, 4, 3, 2, 1, 1]

copie = sorted([3, 1, 2])    # renvoie [1, 2, 3], liste d'origine intacte

mots = ["banane", "kiwi", "pomme"]
mots.sort(key=len)           # tri par longueur -> ['kiwi', 'pomme', 'banane']

Le paramètre key accepte n’importe quelle fonction, y compris une lambda comme key=lambda x: x[-1] pour trier selon le dernier caractère.

Autres méthodes utiles

nombres = [1, 2, 2, 3, 2]
print(nombres.count(2))   # 3 (nombre d'occurrences)
print(nombres.index(3))   # 3 (indice de la première occurrence)
nombres.reverse()         # inverse la liste en place
print(len(nombres))       # 5 (longueur)
print(sum([1, 2, 3]))     # 6
print(min([4, 1, 7]), max([4, 1, 7]))  # 1 7

Les listes imbriquées

Une liste peut contenir d’autres listes, ce qui permet de représenter des matrices ou des tableaux.

matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

print(matrice[1][2])   # 6 (ligne 1, colonne 2)

# Parcourir toutes les cases
for ligne in matrice:
    for valeur in ligne:
        print(valeur, end=" ")

# Aplatir avec une comprehension
plat = [v for ligne in matrice for v in ligne]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Attention lors de la copie : copie = matrice[:] ne copie que le premier niveau. Pour une copie totalement indépendante, utilisez copy.deepcopy(matrice).

Piège classique : la copie de liste

a = [1, 2, 3]
b = a          # b et a pointent vers la MÊME liste
b.append(4)
print(a)       # [1, 2, 3, 4] — a est modifié aussi !

c = a[:]       # copie indépendante
c.append(5)
print(a)       # [1, 2, 3, 4] — inchangé

Retenez cette règle : b = a ne crée pas de copie, seulement un nouveau nom pour la même liste. Utilisez a[:], a.copy() ou list(a) pour une vraie copie.

Conclusion

Vous disposez désormais d’un panorama complet des listes : création, indexation, slicing, ajout, suppression, tri, parcours, comprehensions et structures imbriquées. La meilleure façon d’ancrer ces notions reste de coder de petits exercices. Une fois les listes maîtrisées, passez aux dictionnaires Python pour associer des clés à des valeurs.