Méthodes de liste

Les listes Python sont des séquences mutables et ordonnées. Parce qu'elles sont mutables, le type liste propose onze méthodes intégrées qui permettent d'ajouter, de supprimer, de rechercher et de réordonner des éléments en place — sans aucun import nécessaire. Cette page couvre chaque méthode avec des exemples exécutables, les pièges courants et des conseils sur le moment d'en choisir une plutôt qu'une autre.

Chapitres associés : Listes Python · Trier les listes · Compréhension de liste · Copier les listes

Référence rapide

Ajouter des éléments

append()

append(x) ajoute un seul élément x à la fin de la liste. C'est une opération en O(1) amorti et la façon idiomatique de construire une liste élément par élément.

append() ajoute toujours l'argument comme un seul élément, même si cet argument est lui-même une liste :

fruits = ["banana", "orange"]
fruits.append(["apple", "mango"])
print(fruits)  # ['banana', 'orange', ['apple', 'mango']]
print(len(fruits))  # 3 — the nested list counts as one element

Pour fusionner tous les éléments d'une autre liste, utilisez plutôt extend().

extend()

extend(iterable) ajoute chaque élément de l'itérable donné à la fin de la liste. L'itérable peut être une liste, un tuple, un ensemble, une string ou tout autre itérable.

extend() est équivalent à fruits += more_fruits. Utilisez-le quand vous disposez déjà d'une collection d'éléments à fusionner ; utilisez append() pour un seul élément.

insert()

insert(i, x) insère l'élément x avant la position i. Tous les éléments existants à l'index i et au-delà se décalent d'une position vers la droite.

• insert(0, x) place l'élément au début (mais est en O(n) car tous les éléments se décalent).
• Si i est supérieur ou égal à la longueur de la liste, l'élément est ajouté à la fin — aucune erreur n'est levée.

Supprimer des éléments

remove()

remove(x) parcourt la liste de gauche à droite et supprime le premier élément égal à x. Si x n'est pas trouvé, une ValueError est levée.

Se prémunir contre ValueError :

fruits = ["banana", "orange"]
item = "mango"
if item in fruits:
    fruits.remove(item)
else:
    print(f"{item} not in list")
# mango not in list

pop()

pop(i) supprime l'élément à l'index i et le retourne. La valeur de retour est la différence clé avec remove().

pop() appelé sans argument supprime et retourne le dernier élément — un pattern de pile courant :

stack = ["a", "b", "c"]
last = stack.pop()
print(stack)  # ['a', 'b']
print(last)   # c

clear()

clear() supprime chaque élément de la liste, la laissant vide. C'est équivalent à del lst[:] mais plus lisible.

fruits = ["banana", "apple", "orange"]
fruits.clear()
print(fruits)  # []

Utilisez clear() quand vous souhaitez vider une liste que d'autres variables pourraient également référencer — fruits = [] ne ferait que rebinder le nom, tandis que clear() vide l'objet sous-jacent.

Rechercher des éléments

index()

index(x) retourne l'index entier de la première occurrence de x. Il accepte des arguments optionnels start et end pour limiter la recherche à une tranche.

Recherche dans une plage :

items = ["a", "b", "c", "b", "d"]
print(items.index("b"))       # 1  — first occurrence
print(items.index("b", 2))    # 3  — first occurrence at index >= 2

index() lève ValueError si l'élément est absent. Utilisez in pour vérifier d'abord lorsque l'absence est possible :

if "mango" in fruits:
    pos = fruits.index("mango")

count()

count(x) retourne le nombre de fois où x apparaît dans la liste.

Contrairement à index(), count() ne lève jamais d'erreur pour une valeur absente — il retourne 0.

Ordonner les éléments

sort()

sort() trie la liste en place par ordre croissant par défaut. Il accepte deux arguments nommés optionnels :

• reverse=True — trier par ordre décroissant.
• key=<callable> — une fonction appliquée à chaque élément avant la comparaison.

Trier par ordre décroissant :

numbers = [3, 1, 4, 1, 5]
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 1, 1]

Trier des strings sans tenir compte de la casse avec key :

words = ["banana", "Apple", "cherry", "date"]
words.sort(key=str.lower)
print(words)  # ['Apple', 'banana', 'cherry', 'date']

sort() modifie la liste et retourne None. Si vous avez besoin d'une copie triée sans modifier l'original, utilisez la fonction intégrée sorted() à la place :

original = [3, 1, 4]
result = sorted(original)
print(original)  # [3, 1, 4]  — unchanged
print(result)    # [1, 3, 4]

Consultez Trier les listes pour un guide approfondi incluant les comparateurs personnalisés et le tri d'objets.

reverse()

reverse() inverse la liste en place. Comme sort(), il retourne None.

Pour obtenir une copie inversée sans modifier l'original, utilisez reversed() (retourne un itérateur) ou le slicing :

fruits = ["banana", "apple", "orange"]
print(list(reversed(fruits)))  # ['orange', 'apple', 'banana']
print(fruits[::-1])            # ['orange', 'apple', 'banana']
print(fruits)                  # ['banana', 'apple', 'orange']  — unchanged

Copier

copy()

copy() retourne une copie superficielle de la liste — un nouvel objet liste contenant les mêmes références d'éléments.

original = ["banana", "apple", "orange"]
clone = original.copy()
clone.append("mango")

print(original)  # ['banana', 'apple', 'orange']  — unchanged
print(clone)     # ['banana', 'apple', 'orange', 'mango']

« Superficielle » signifie que les objets imbriqués (comme une liste dans une liste) ne sont pas dupliqués — l'original et la copie refléteront tous deux les modifications apportées à ces objets imbriqués. Pour un duplicata entièrement indépendant, utilisez copy.deepcopy() de la bibliothèque standard. Consultez Copier les listes pour une explication détaillée des copies superficielles et profondes.

Pièges courants

Toutes les méthodes mutantes retournent None. Une erreur courante consiste à assigner le résultat de sort(), reverse(), append(), etc. :

# Wrong — result is None, not a sorted list
numbers = [3, 1, 2]
numbers = numbers.sort()
print(numbers)  # None

# Correct — sort() mutates in place
numbers = [3, 1, 2]
numbers.sort()
print(numbers)  # [1, 2, 3]

remove() et index() lèvent ValueError pour les éléments absents. Vérifiez toujours avec in d'abord, ou interceptez l'exception, lorsque l'élément pourrait ne pas être présent.

append() vs extend() pour les listes. Utiliser append(another_list) imbrique la liste comme un seul élément ; extend(another_list) fusionne ses éléments.

Pratique