# Listes en Python (list) : méthodes, tranches, tri, append, tuples et ensembles URL: https://skillaria.top/fr/guides/python/listes-python Une liste en Python (list) est une collection ordonnée et modifiable de valeurs entre crochets, par exemple [250, 1200, 99] : on peut ajouter des éléments avec append, en insérer, en supprimer, prendre des tranches et trier. La méthode sort trie la liste sur place et renvoie None, alors que la fonction sorted renvoie une nouvelle liste triée. 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`. | Méthode | Ce qu'elle fait | | --- | --- | | `append(x)` | ajoute x à la fin | | `extend(iter)` | ajoute tous les éléments d'une séquence | | `insert(i, x)` | insère x avant l'indice i | | `remove(x)` | supprime la première occurrence de x (ValueError si absente) | | `pop(i=-1)` | supprime et renvoie l'élément à l'indice i | | `index(x)` | indice de la première occurrence | | `count(x)` | nombre d'occurrences de x | | `sort()` | trie sur place | | `reverse()` | inverse sur place | | `copy()` | copie superficielle | | `clear()` | vide la liste | 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 | Besoin | Collection | | --- | --- | | Ordre et modifications | `list` | | Enregistrement à champs fixes | `tuple` | | Recherche par clé | `dict` | | Unicité, test d'appartenance | `set` | | Réglages non modifiables | `frozendict` (Python 3.15) | 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. ## FAQ **Quelle est la différence entre une liste et un tableau en Python ?** Il n'existe pas de tableau intégré au sens d'autres langages : la liste joue ce rôle et peut contenir des valeurs de types différents. Pour des tableaux numériques compacts, on utilise le module array ou la bibliothèque NumPy. **Comment trouver l'indice d'un élément dans une liste ?** La méthode a.index(x) renvoie l'indice de la première occurrence et lève ValueError si l'élément est absent. Vérifiez donc d'abord x in a. **Comment supprimer les doublons d'une liste en conservant l'ordre ?** Utilisez list(dict.fromkeys(a)) : un dictionnaire ne garde que des clés uniques, dans l'ordre d'insertion. L'écriture list(set(a)) supprime aussi les doublons, mais sans conserver l'ordre. **Comment assembler une liste de chaînes en une seule chaîne ?** Avec la méthode join de la chaîne : ", ".join(["a", "b", "c"]) donne "a, b, c". Tous les éléments doivent être des chaînes ; pour des nombres, convertissez-les d'abord avec map(str, a). **Peut-on mélanger des types différents dans une liste ?** Oui, une liste peut contenir à la fois des nombres, des chaînes, d'autres listes et des objets quelconques. Mais un tel mélange se trie rarement sans paramètre key : comparer un nombre à une chaîne provoque une TypeError. --- Source: Skillaria.Top (https://skillaria.top)