Listes en Python (list) : méthodes, tranches, tri, append, tuples et ensembles

La liste en Python (list) est un ensemble ordonné de valeurs quelconques, entre crochets, que l'on peut modifier : ajouter des éléments à la fin, en insérer au milieu, en supprimer, les trier. C'est la collection la plus utilisée du langage : lignes d'un fichier, dépenses du mois, réponses d'une API — presque tout commence par une liste. Voyons la liste Python de bout en bout : création, méthodes, tranches, tri, compréhensions, copie, puis les tuples et les ensembles.

Qu'est-ce qu'une liste en Python

La liste conserve les éléments dans l'ordre où vous les avez placés, et on accède à chacun par son indice, en commençant à zéro. Une même liste peut contenir des valeurs de types différents, même si, en pratique, on stocke en général des données homogènes.

montants = [250, 1200, 99]
print(montants[0])     # 250 — premier élément
print(montants[-1])    # 99 — dernier
montants[1] = 1300     # la liste est modifiable
print(len(montants))   # 3 — longueur de la liste

La taille d'une liste s'obtient avec la fonction len(). Un indice qui n'existe pas provoque IndexError: list index out of range.

Créer une liste

vide = []                        # liste vide
aussi_vide = list()              # la même chose avec la fonction list
nombres = [1, 2, 3]
caracteres = list("abc")         # ['a', 'b', 'c']
chiffres = list(range(5))        # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

La fonction list() transforme en liste tout objet itérable : une chaîne, un range, un ensemble, les clés d'un dictionnaire.

append et les autres méthodes de liste

La méthode append ajoute un seul élément à la fin de la liste : c'est la méthode la plus fréquente en Python. Elle modifie la liste sur place et renvoie None.

montants = [250, 1200]
montants.append(450)          # [250, 1200, 450]
montants.extend([10, 20])     # [250, 1200, 450, 10, 20]
montants.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
montants.remove(1200)         # supprime la première valeur 1200
dernier = montants.pop()      # 20 — supprime et renvoie le dernier

Erreur fréquente : a.append([10, 20]) ajoute un seul élément, une liste imbriquée, et non deux nombres. Pour ajouter plusieurs éléments, utilisez extend.

On peut aussi supprimer un élément ou une plage avec l'instruction del : del a[0], del a[1:3]. Fonctions intégrées utiles avec les listes : len, sum, min, max, sorted, reversed, enumerate, zip.

Tranches de listes en Python

Une tranche extrait une partie de la liste selon la forme a[début:fin:pas] : du début inclus jusqu'à la fin exclue, avec le pas indiqué. Chaque partie peut être omise. Une tranche renvoie toujours une nouvelle liste.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — les deux premiers
print(a[-2:])     # [4, 5] — les deux derniers
print(a[::2])     # [0, 2, 4] — un élément sur deux
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — à l'envers
print(a[:])       # copie de toute la liste

Contrairement à un indice, une tranche hors des limites ne provoque pas d'erreur : a[10:20] renvoie simplement []. On peut aussi affecter une valeur à une tranche pour remplacer un morceau de liste : a[1:3] = ["x", "y", "z"].

Tranche d'une chaîne

Les tranches fonctionnent de la même manière sur toutes les séquences, y compris les chaînes et les tuples :

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

On ne peut pas modifier une chaîne par tranche : les chaînes sont immuables, la tranche crée une nouvelle chaîne.

Trier une liste : sort et sorted

C'est le point où les débutants se perdent le plus souvent. La méthode sort réordonne les éléments dans la liste elle-même et renvoie None. La fonction sorted ne touche pas à la liste d'origine et renvoie une nouvelle liste triée.

montants = [250, 1200, 99]
montants.append(450)
print(sorted(montants))    # [99, 250, 450, 1200] — nouvelle copie
print(montants)            # [250, 1200, 99, 450] — l'original est intact

resultat = montants.sort() # trie sur place
print(resultat, montants)  # None [99, 250, 450, 1200]

D'où l'erreur classique « pourquoi ai-je None ? » : a = a.sort() remplace la liste par la valeur None. Écrivez soit a.sort(), soit a = sorted(a).

Clé de tri et ordre décroissant

Les deux méthodes acceptent les paramètres key et reverse. key est une fonction dont le résultat sert de base à la comparaison.

mots = ["café", "Taxi", "abonnement"]
print(sorted(mots, key=len))               # ['café', 'Taxi', 'abonnement']
print(sorted(mots, key=str.lower))         # sans tenir compte de la casse
print(sorted([3, 1, 2], reverse=True))     # [3, 2, 1]

depenses = [("Alimentation", 650), ("Cinéma", 120), ("Taxi", 300)]
depenses.sort(key=lambda d: d[1])          # selon le montant

Le tri en Python est stable : les éléments ayant la même clé gardent leur ordre d'origine. Autre différence : sorted accepte toute séquence (chaîne, dictionnaire, ensemble), tandis que sort n'existe que pour les listes.

Inverser une liste

Trois méthodes au comportement différent :

• a.reverse() — inverse sur place, renvoie None ;
• a[::-1] — nouvelle liste inversée ;
• reversed(a) — itérateur paresseux, pratique dans une boucle : for x in reversed(a):.

Parcourir une liste

articles = ["café", "métro", "cinéma"]
for article in articles:
    print(article)

for i, article in enumerate(articles, start=1):
    print(i, article)          # 1 café, 2 métro, 3 cinéma

print("cinéma" in articles)    # True — test d'appartenance

Ne supprimez pas d'éléments de la liste pendant qu'une boucle la parcourt : certains éléments seraient sautés. Construisez une nouvelle liste avec une compréhension, ou parcourez une copie a[:].

Compréhension de liste (list comprehension)

La compréhension de liste construit une nouvelle liste en une seule ligne : une expression, une boucle et une condition facultative.

carres = [n * n for n in range(6)]              # [0, 1, 4, 9, 16, 25]
grands = [m for m in [250, 1200, 99] if m > 200]  # [250, 1200]
noms = [s.strip().title() for s in [" anna ", "oleg"]]

Les compréhensions sont en général plus rapides et plus lisibles qu'une boucle avec append. Mais si la logique ne tient pas dans une ligne compréhensible, une boucle classique est préférable.

Concaténer, additionner et soustraire des listes

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — nouvelle liste
a += b             # équivalent de a.extend(b)
print([*a, *b])    # décompression dans une nouvelle liste

Il n'existe pas d'opérateur - entre deux listes. Pour retirer d'une liste les éléments d'une autre, utilisez une compréhension : [x for x in a if x not in set(b)]. Pour l'intersection, le plus simple est de passer par les ensembles : set(a) & set(b) (l'ordre et les doublons disparaissent alors).

Listes imbriquées et tableaux à deux dimensions

Une liste de listes permet de stocker un tableau ou une matrice :

matrice = [[1, 2, 3], [4, 5, 6]]
print(matrice[1][2])                  # 6
grille = [[0] * 3 for _ in range(2)]  # correct
mauvaise = [[0] * 3] * 2              # piège : deux références vers la même liste
mauvaise[0][0] = 9
print(mauvaise)                       # [[9, 0, 0], [9, 0, 0]]

Décomposer une liste

premier, second, troisieme = [10, 20, 30]
tete, *reste = [1, 2, 3, 4]      # tete=1, reste=[2, 3, 4]
print(*["a", "b"], sep=", ")     # a, b — afficher une liste sans crochets

Si le nombre de variables ne correspond pas à la longueur de la liste, on obtient une ValueError — l'astérisque permet de l'éviter.

Copier une liste

b = a ne copie pas la liste : cela crée une seconde étiquette sur le même objet, et les modifications faites via b sont visibles dans a. Pour obtenir une copie indépendante, faites-la explicitement : a.copy(), list(a) ou a[:]. Pour les données imbriquées, cela ne suffit pas : les listes internes restent communes, il faut copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — la liste imbriquée est commune
c = copy.deepcopy(a)     # copie totalement indépendante

Tuples : une liste non modifiable

Le tuple (tuple) ressemble à une liste, mais on ne peut plus le modifier après sa création. C'est un signal clair pour le lecteur : il s'agit d'un enregistrement à champs fixes, et non d'un ensemble qui grandit. Les tuples se décomposent facilement, et ce sont eux que les fonctions renvoient lorsqu'elles retournent plusieurs valeurs.

depense = (250, "Café")
montant, article = depense
depense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Un tuple composé de valeurs non modifiables est hachable, et peut donc servir de clé de dictionnaire. Un tuple d'un seul élément s'écrit avec une virgule : (5,).

Ensembles : seulement des valeurs uniques

L'ensemble (set) ne conserve que des valeurs uniques et ne garde pas l'ordre. C'est le moyen le plus rapide d'éliminer les doublons ou de vérifier « cet élément existe-t-il ? ». Il sait aussi calculer l'intersection, la réunion et la différence.

janvier = {"Alimentation", "Taxi", "Cinéma"}
fevrier = {"Alimentation", "Abonnements"}
print(janvier & fevrier)    # {'Alimentation'}
print(fevrier - janvier)    # {'Abonnements'}
uniques = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — sans doublons, ordre conservé
vide = set()                # {} — ceci est un dictionnaire vide !

Quelle collection choisir

Le test x in liste parcourt les éléments un à un, alors que x in ensemble est presque instantané. Si vous testez souvent l'appartenance dans une grande liste, convertissez-la en ensemble.

En bref

La liste Python est une collection ordonnée et modifiable : append et extend ajoutent, pop et remove suppriment, les tranches a[début:fin:pas] extraient des morceaux, sort trie sur place et renvoie None, tandis que sorted produit une nouvelle liste. Copiez explicitement, utilisez un tuple pour les enregistrements à champs fixes et un ensemble pour les valeurs uniques. Listes, tuples, dictionnaires et ensembles sont mis en pratique dans le cours sur Python.