> Tout sur la liste Python : créer, indexer, slicing, trier, parcourir, list comprehension et toutes les méthodes (append, pop, sort) avec des exemples de code. *Source : https://coder-studio.com/tutoriels/listes-python/* --- [// Python](https://coder-studio.com/tutoriels/) # Les listes en Python : le guide complet (méthodes & astuces) Par **Kévin Papot** · publié le 15 septembre 2025 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](https://coder-studio.com/tutoriels/dictionnaires-python/) pour associer des clés à des valeurs. ### À lire ensuite - [Les fonctions en Python](https://coder-studio.com/tutoriels/fonctions-python/) - [Les dictionnaires en Python](https://coder-studio.com/tutoriels/dictionnaires-python/) - [Apprendre Python en 2026](https://coder-studio.com/tutoriels/apprendre-python/)