Les listes Python : un guide complet

Cette page couvre tout ce que vous devez savoir sur les listes Python — comment les créer, lire et modifier leur contenu, utiliser le slicing, appliquer les méthodes intégrées, écrire des compréhensions de liste, travailler avec des listes imbriquées et décompresser des valeurs de liste dans des variables.

Qu'est-ce qu'une liste Python ?

Une liste est la structure de données intégrée la plus polyvalente de Python. Elle stocke une séquence ordonnée d'éléments, où chaque élément peut être de n'importe quel type : un nombre, une string, un boolean, une autre liste ou n'importe quel objet. Les listes sont :

• Ordonnées — les éléments conservent la position que vous leur donnez.
• Mutables — vous pouvez ajouter, supprimer ou modifier des éléments après la création de la liste.
• Indexées — chaque élément possède un index entier commençant à 0.
• Hétérogènes — une seule liste peut contenir des valeurs de types différents.

Créez une liste avec des crochets, en séparant les éléments par des virgules :

Une liste vide s'écrit []. Les listes peuvent également contenir des types mixtes :

mixed = [42, 'hello', True, 3.14, None]
print(mixed)
# [42, 'hello', True, 3.14, None]

Accéder aux éléments d'une liste

Indexation positive

Accédez à un élément par sa position à base zéro entre crochets :

Indexation négative

Les indices négatifs comptent à rebours depuis la fin. -1 est le dernier élément, -2 l'avant-dernier, et ainsi de suite — utile quand vous connaissez la position depuis la fin mais pas la longueur totale :

Slicing

Un slice extrait une sous-liste en utilisant la syntaxe list[start:stop:step]. L'index stop est exclusif (non inclus).

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

print(fruits[1:4])   # ['banana', 'cherry', 'date']
print(fruits[:2])    # ['apple', 'banana']   — start defaults to 0
print(fruits[2:])    # ['cherry', 'date', 'elderberry'] — stop defaults to end
print(fruits[::2])   # ['apple', 'cherry', 'elderberry'] — every other item
print(fruits[::-1])  # ['elderberry', 'date', 'cherry', 'banana', 'apple'] — reversed copy

Le slicing renvoie toujours une nouvelle liste et ne lève jamais d'IndexError, même si les indices sont hors limites.

Modifier les éléments d'une liste

Comme les listes sont mutables, vous pouvez assigner une nouvelle valeur à n'importe quel index :

Vous pouvez également remplacer une plage d'éléments à l'aide d'une affectation par slice :

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30]
print(nums)
# [1, 20, 30, 4, 5]

Ajouter des éléments

append() — Ajouter à la fin

append() ajoute un seul élément à la fin de la liste en place :

insert() — Ajouter à une position spécifique

insert(index, value) place un nouvel élément avant l'index donné sans rien supprimer :

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'mango')
print(fruits)
# ['apple', 'mango', 'banana', 'cherry']

extend() — Ajouter plusieurs éléments

extend() ajoute tous les éléments d'un autre itérable (liste, tuple ou string) à la fin :

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
# [1, 2, 3, 4, 5, 6]

L'opérateur + fait la même chose mais retourne une nouvelle liste au lieu de modifier l'originale :

combined = [1, 2, 3] + [4, 5, 6]
print(combined)
# [1, 2, 3, 4, 5, 6]

Supprimer des éléments

remove() — Supprimer par valeur

remove() supprime la première occurrence d'une valeur. Il lève ValueError si la valeur n'est pas dans la liste :

pop() — Supprimer par index

pop() supprime et retourne l'élément à un index donné (par défaut : le dernier élément). C'est utile quand vous avez besoin à la fois de récupérer et de supprimer un élément :

fruits = ['apple', 'banana', 'cherry']
last = fruits.pop()
print(last)    # cherry
print(fruits)  # ['apple', 'banana']

first = fruits.pop(0)
print(first)   # apple
print(fruits)  # ['banana']

del — Supprimer par index ou slice

L'instruction del supprime un élément par son index ou une tranche entière :

clear() — Supprimer tous les éléments

clear() vide la liste sans la supprimer elle-même :

fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits)
# []

Méthodes de liste utiles

Les listes Python disposent d'un ensemble complet de méthodes intégrées. Consultez Python List Methods pour la référence complète.

len() — Longueur de la liste

sort() — Tri en place

sort() trie la liste par ordre croissant par défaut. Utilisez reverse=True pour un ordre décroissant :

Utilisez le paramètre key pour trier selon un critère personnalisé — par exemple, par longueur de mot :

words = ['banana', 'apple', 'cherry', 'date']
words.sort(key=len)
print(words)
# ['date', 'apple', 'banana', 'cherry']

sort() modifie la liste en place. Pour obtenir une copie triée sans modifier l'originale, utilisez la fonction intégrée sorted() :

original = [3, 1, 2]
s = sorted(original)
print(original)  # [3, 1, 2]
print(s)         # [1, 2, 3]

Consultez Sort Lists pour plus de modèles de tri.

reverse() — Inversion en place

count() — Compter les occurrences

count(value) retourne le nombre de fois qu'une valeur apparaît :

nums = [1, 2, 2, 3, 2, 4]
print(nums.count(2))
# 3

index() — Trouver une valeur

index(value) retourne l'index de la première occurrence. Il lève ValueError si non trouvé :

nums = [1, 2, 3, 4]
print(nums.index(3))
# 2

copy() — Copie superficielle

copy() retourne une nouvelle liste avec les mêmes éléments de premier niveau. La modification de la copie n'affecte pas l'originale :

original = [1, 2, 3]
copy = original.copy()
copy.append(4)
print(original)  # [1, 2, 3]
print(copy)      # [1, 2, 3, 4]

Tri et inversion : différence essentielle

sort() et reverse() modifient tous deux la liste en place et retournent None. Une erreur courante est d'écrire my_list = my_list.sort(), ce qui remplace la liste par None. Appelez-les toujours comme des instructions :

fruits = ['banana', 'apple', 'cherry']
fruits.sort()   # correct — modifies in place
# fruits = fruits.sort()  # wrong — sets fruits to None
print(fruits)
# ['apple', 'banana', 'cherry']

Listes imbriquées

Une liste peut contenir d'autres listes comme éléments, formant une structure à 2 dimensions (ou plus) :

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

print(matrix[0])     # [1, 2, 3]
print(matrix[1][2])  # 6  — row 1, column 2

Les listes imbriquées sont couramment utilisées pour représenter des grilles, des tableaux et des matrices.

Compréhensions de liste

Une compréhension de liste est une expression concise sur une ligne pour construire une nouvelle liste en transformant ou filtrant un itérable existant. La syntaxe est :

[expression for item in iterable if condition]

La partie if condition est facultative.

Carrés de 1 à 10 :

Nombres pairs uniquement :

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)
# [2, 4, 6, 8, 10]

Transformer des strings :

fruits = ['apple', 'banana', 'cherry']
upper = [f.upper() for f in fruits]
print(upper)
# ['APPLE', 'BANANA', 'CHERRY']

Les compréhensions de liste sont généralement plus rapides qu'une boucle for équivalente avec append(). Consultez List Comprehension pour des modèles avancés.

Décompression de listes

Vous pouvez assigner des éléments de liste à des variables individuelles en une seule étape :

a, b, c = ['x', 'y', 'z']
print(a, b, c)
# x y z

L'opérateur * (étoile) capture un nombre quelconque d'éléments restants :

first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

La décompression lève ValueError si le nombre de variables ne correspond pas au nombre d'éléments (sauf si vous utilisez *).

Quand utiliser une liste

Pratique