Listes Python : ajouter, modifier et parcourir facilement

Les listes font partie des structures de données les plus utilisées en Python. Elles permettent de conserver plusieurs valeurs dans une seule variable, puis de les consulter, de les modifier, d'en ajouter ou d'en retirer au fil de l'exécution du programme. Une liste peut représenter une collection de courses, les notes d'un élève, les tâches d'une journée, les noms des participants à un atelier ou encore des données calculées par un script.

Dans ce tutoriel, vous allez découvrir comment créer une liste, accéder à ses éléments, ajouter de nouvelles valeurs, remplacer ou supprimer des éléments, puis parcourir une liste avec différentes boucles. Chaque opération est expliquée avec des exemples simples et progressifs. L'objectif n'est pas seulement de mémoriser des méthodes, mais aussi de comprendre ce qui change réellement dans la liste après chaque instruction.

Une liste se reconnaît à ses crochets. Par exemple, fruits = ['pomme', 'banane', 'orange'] crée une liste contenant trois chaînes de caractères. L'ordre est conservé : 'pomme' est le premier élément, 'banane' le deuxième et 'orange' le troisième. Cette notion d'ordre est essentielle pour utiliser les indices et les boucles correctement.

Prérequis

Ce tutoriel s'adresse aux débutants. Vous devez connaître les notions de variable, de chaîne de caractères, de nombre et d'affichage avec print(). Aucune bibliothèque externe n'est nécessaire.

Vous pouvez exécuter les exemples dans un fichier Python, dans un environnement interactif ou dans un éditeur proposant une console Python. Lancez les extraits un par un : cette habitude permet d'observer le contenu de la liste après chaque modification et de mieux repérer l'origine d'une erreur.

Matériel nécessaire

Python 3 installé ou un environnement Python en ligne
Un éditeur de texte ou un environnement de développement
Une console pour exécuter les exemples

Étapes

1
Créer une liste et comprendre sa structure

Une liste est une collection ordonnée d'éléments placés entre crochets et séparés par des virgules. On peut stocker la liste dans une variable, comme n'importe quelle autre valeur Python. Voici une liste de fruits :
python
```
fruits = ['pomme', 'banane', 'orange']
print(fruits)
```
L'affichage montre les crochets, les virgules et les valeurs contenues dans la collection. Dans cet exemple, chaque élément est une chaîne de caractères. Une liste peut aussi contenir des nombres :
python
```
notes = [12, 15, 18, 14]
print(notes)
```
Les listes peuvent même mélanger plusieurs types de valeurs. Cela est autorisé par Python, même s'il est souvent plus facile de manipuler une liste lorsque ses éléments représentent le même type d'information.
python
```
informations = ['Lina', 16, True]
print(informations)
```
Dans cet exemple, la liste contient une chaîne de caractères, un entier et une valeur booléenne. Pour une liste de notes, il est généralement plus cohérent de ne conserver que des nombres. Pour une liste de prénoms, il est plus cohérent de ne conserver que des textes. Cette cohérence rend le programme plus lisible et simplifie les traitements effectués dans les boucles.

Pour créer une liste vide, écrivez simplement deux crochets sans élément. C'est utile lorsqu'un programme doit construire une collection progressivement.
python
```
courses = []
print(courses)
```
Une liste vide n'est pas une erreur : elle contient zéro élément. Vous pourrez ensuite y ajouter des valeurs avec append(), méthode étudiée plus loin. Vous pouvez également créer une liste à partir d'une chaîne avec list(), mais il faut comprendre son effet : Python transforme alors la chaîne en une liste de caractères.
python
```
lettres = list('chat')
print(lettres)
```
Le résultat contient les caractères 'c', 'h', 'a' et 't'. Ce comportement est parfois utile, mais pour constituer une liste de mots, écrivez les mots explicitement ou récupérez-les avec un traitement adapté.

Enfin, la fonction len() indique le nombre d'éléments présents dans une liste. Elle ne modifie pas la liste.
python
```
fruits = ['pomme', 'banane', 'orange']
nombre_de_fruits = len(fruits)
print(nombre_de_fruits)
```
Ici, le résultat est 3. Vérifier la longueur d'une liste est très utile avant d'accéder à ses éléments, notamment lorsque la liste peut être vide.
2
Accéder aux éléments avec les indices et les tranches

Chaque élément d'une liste possède une position appelée indice. En Python, le premier indice est toujours 0, et non 1. Avec la liste suivante, 'pomme' est à l'indice 0, 'banane' à l'indice 1 et 'orange' à l'indice 2.
python
```
fruits = ['pomme', 'banane', 'orange']
print(fruits[0])
print(fruits[1])
print(fruits[2])
```
Les crochets utilisés après le nom de la variable servent à demander un élément précis. Il est important de distinguer les crochets qui créent la liste et ceux qui servent à accéder à une position. Le résultat du premier print() est pomme.

Python accepte également les indices négatifs. L'indice -1 désigne le dernier élément, -2 l'avant-dernier, et ainsi de suite. C'est pratique quand on veut travailler avec la fin d'une liste sans calculer sa longueur.
python
```
fruits = ['pomme', 'banane', 'orange']
print(fruits[-1])
print(fruits[-2])
```
Le premier affichage renvoie orange. Si vous utilisez un indice qui n'existe pas, Python produit une erreur IndexError. Par exemple, une liste de trois éléments ne possède pas d'indice 3, car ses indices vont de 0 à 2.
python
```
fruits = ['pomme', 'banane', 'orange']
print(fruits[3])
```
Avant de demander une position calculée, vous pouvez vérifier la longueur avec len(). Par exemple, pour afficher le dernier élément seulement si la liste n'est pas vide :
python
```
fruits = ['pomme', 'banane', 'orange']

if len(fruits) > 0:
    print(fruits[-1])
```
Les listes permettent aussi d'extraire plusieurs éléments grâce aux tranches, appelées aussi slices. La syntaxe générale est liste[debut:fin]. La position de début est incluse, tandis que la position de fin est exclue.
python
```
fruits = ['pomme', 'banane', 'orange', 'kiwi', 'mangue']
print(fruits[1:4])
```
Cette instruction produit une nouvelle liste contenant 'banane', 'orange' et 'kiwi'. L'indice 1 est inclus ; l'indice 4 sert de limite et n'est pas inclus. Si vous omettez le début, Python commence au premier élément. Si vous omettez la fin, Python continue jusqu'au dernier élément.
python
```
fruits = ['pomme', 'banane', 'orange', 'kiwi', 'mangue']
print(fruits[:3])
print(fruits[2:])
```
La première tranche contient les trois premiers éléments. La seconde contient les éléments à partir de l'indice 2. Une tranche est particulièrement utile pour lire une partie d'une liste sans changer la liste d'origine.
3
Ajouter un ou plusieurs éléments

Une liste est modifiable : après sa création, vous pouvez ajouter des éléments. La méthode la plus courante est append(). Elle ajoute une seule valeur à la fin de la liste.
python
```
courses = ['pain', 'lait']
courses.append('pommes')
print(courses)
```
Après l'appel à append(), la liste contient 'pain', 'lait' et 'pommes'. La méthode modifie directement la liste existante. Elle ne crée pas une nouvelle liste à stocker dans une autre variable.

Une erreur fréquente consiste à écrire une affectation avec le résultat de append(). Il ne faut pas le faire, car cette méthode sert à modifier la liste en place et ne fournit pas la liste modifiée comme résultat utile.
python
```
courses = ['pain', 'lait']
courses.append('pommes')
print(courses)
```
Pour insérer un élément à une position précise, utilisez insert(index, valeur). Le premier argument indique l'endroit où le nouvel élément doit apparaître. Les éléments déjà présents à cette position et après elle sont décalés vers la droite.
python
```
courses = ['pain', 'lait', 'pommes']
courses.insert(1, 'cafe')
print(courses)
```
Le résultat place 'cafe' après 'pain' : ['pain', 'cafe', 'lait', 'pommes']. Notez que insert(0, valeur) place un élément au début de la liste. Cette opération peut être utile, par exemple, pour ajouter une tâche prioritaire au début d'une liste de tâches.
python
```
taches = ['repondre aux messages', 'preparer le repas']
taches.insert(0, 'appeler le client')
print(taches)
```
Pour ajouter tous les éléments d'une autre liste, utilisez extend(). Cette méthode parcourt la collection fournie et ajoute ses éléments un à un à la fin de la liste cible.
python
```
courses = ['pain', 'lait']
produits_frais = ['tomates', 'salade']
courses.extend(produits_frais)
print(courses)
```
La liste finale contient quatre éléments. Il faut bien différencier append() et extend(). Si vous donnez une liste à append(), cette liste devient un seul élément imbriqué.
python
```
courses = ['pain', 'lait']
produits_frais = ['tomates', 'salade']
courses.append(produits_frais)
print(courses)
```
Le dernier élément est alors lui-même une liste. Cette structure peut être voulue dans certains cas, mais elle est différente d'une liste plate contenant quatre chaînes. Si votre intention est d'ajouter les deux produits séparément, choisissez extend().

Vous pouvez aussi employer l'opérateur + pour construire une nouvelle liste combinant deux listes. Contrairement à extend(), l'opérateur ne modifie pas directement la première liste si vous stockez le résultat dans une nouvelle variable.
python
```
courses = ['pain', 'lait']
produits_frais = ['tomates', 'salade']
toutes_les_courses = courses + produits_frais
print(toutes_les_courses)
```
La variable courses conserve ici son contenu initial. Ce choix est utile lorsque vous souhaitez garder les listes source intactes.
4
Modifier et supprimer des éléments

Comme une liste est modifiable, vous pouvez remplacer un élément en utilisant son indice à gauche du signe =. Cette écriture sélectionne une position, puis y enregistre une nouvelle valeur.
python
```
couleurs = ['rouge', 'vert', 'bleu']
couleurs[1] = 'jaune'
print(couleurs)
```
L'élément 'vert', situé à l'indice 1, est remplacé par 'jaune'. La longueur de la liste ne change pas. Le remplacement est approprié lorsqu'une valeur existante doit être corrigée ou mise à jour.

Vous pouvez également remplacer une tranche par plusieurs éléments. Le nombre de valeurs de remplacement peut être différent du nombre de valeurs retirées, ce qui peut changer la longueur de la liste.
python
```
couleurs = ['rouge', 'vert', 'bleu', 'noir']
couleurs[1:3] = ['jaune', 'violet']
print(couleurs)
```
Dans cet exemple, les éléments aux indices 1 et 2 sont remplacés. Cette syntaxe est pratique, mais pour débuter, il est préférable de vérifier attentivement les indices et le résultat attendu.

Pour supprimer un élément dont vous connaissez la valeur, utilisez remove(). Cette méthode supprime la première occurrence de la valeur demandée.
python
```
participants = ['Aya', 'Noe', 'Lina', 'Noe']
participants.remove('Noe')
print(participants)
```
Il reste encore un 'Noe' dans la liste, car remove() s'arrête après la première correspondance. Si la valeur n'est pas présente, Python produit une erreur ValueError. Vous pouvez éviter cette erreur en vérifiant d'abord l'appartenance avec in.
python
```
participants = ['Aya', 'Lina']

if 'Noe' in participants:
    participants.remove('Noe')
```
Pour supprimer selon une position, utilisez pop(). Sans argument, elle retire et renvoie le dernier élément. Vous pouvez donc récupérer la valeur supprimée dans une variable.
python
```
taches = ['lire', 'coder', 'marcher']
tache_terminee = taches.pop()
print(tache_terminee)
print(taches)
```
La variable tache_terminee contient 'marcher', tandis que la liste ne contient plus cette tâche. Avec un indice, pop(index) retire l'élément situé à cet endroit.
python
```
taches = ['lire', 'coder', 'marcher']
tache = taches.pop(1)
print(tache)
print(taches)
```
Pour supprimer un élément sans avoir besoin de le récupérer, vous pouvez employer l'instruction del. Elle fonctionne avec un indice ou une tranche.
python
```
taches = ['lire', 'coder', 'marcher']
del taches[0]
print(taches)
```
Enfin, clear() enlève tous les éléments et laisse une liste vide. La variable existe toujours après l'opération.
python
```
taches = ['lire', 'coder', 'marcher']
taches.clear()
print(taches)
```
Utilisez clear() lorsque vous voulez réutiliser la même liste depuis zéro. Si vous voulez seulement supprimer une variable, l'instruction del taches a un effet différent : le nom de variable n'est alors plus disponible.
5
Parcourir une liste avec une boucle for

Parcourir une liste consiste à traiter ses éléments un par un. La boucle for est l'outil le plus naturel pour cette tâche. Elle affecte successivement chaque élément à une variable temporaire, puis exécute le bloc indenté.
python
```
fruits = ['pomme', 'banane', 'orange']

for fruit in fruits:
    print(fruit)
```
À chaque passage, fruit contient une valeur de la liste. Le premier passage affiche pomme, le suivant affiche banane, puis le dernier affiche orange. Le nom fruit est choisi par le programmeur. Employez un nom singulier et descriptif quand c'est possible : nom dans noms, note dans notes, ou tache dans taches.

Une boucle sert souvent à réaliser un traitement. Voici comment afficher un message différent selon la note :
python
```
notes = [8, 12, 16, 10]

for note in notes:
    if note >= 10:
        print('note validee')
    else:
        print('note a ameliorer')
```
La boucle ne modifie pas la liste dans cet exemple : elle lit chaque valeur et affiche une information. Vous pouvez aussi calculer un total progressivement. Il faut alors initialiser l'accumulateur avant la boucle.
python
```
notes = [8, 12, 16, 10]
total = 0

for note in notes:
    total = total + note

print(total)
```
La variable total commence à zéro. À chaque passage, la note courante y est ajoutée. Cette logique permet de comprendre le calcul avant d'utiliser des fonctions plus spécialisées.

Quand vous avez besoin à la fois de l'indice et de la valeur, utilisez enumerate(). Cette fonction fournit deux valeurs à chaque tour : une position et l'élément correspondant.
python
```
fruits = ['pomme', 'banane', 'orange']

for index, fruit in enumerate(fruits):
    print(index, fruit)
```
Les indices affichés commencent à 0, comme les indices des listes. Pour présenter une numérotation destinée à une personne, vous pouvez demander à enumerate() de commencer à 1.
python
```
fruits = ['pomme', 'banane', 'orange']

for position, fruit in enumerate(fruits, start=1):
    print(position, fruit)
```
Cette approche est plus claire que de gérer vous-même un compteur dans de nombreux cas. Elle évite aussi de confondre l'indice technique de la liste et le numéro affiché à l'utilisateur.
6
Parcourir avec les indices, filtrer et organiser une liste

Il est parfois nécessaire de travailler explicitement avec les indices, notamment pour modifier un élément selon sa position. La fonction range(), associée à len(), produit une suite d'indices valides allant de 0 jusqu'à la longueur de la liste exclue.
python
```
notes = [8, 12, 16, 10]

for index in range(len(notes)):
    print(index, notes[index])
```
Cette forme fonctionne, mais si vous n'avez besoin que des valeurs, préférez la forme directe for note in notes. Elle est plus courte et réduit le risque d'erreur d'indice. Employez range(len(...)) quand l'indice est réellement nécessaire.

Voici un exemple de modification par indice. Le programme augmente chaque note d'un point, en limitant la valeur maximale à 20.
python
```
notes = [8, 12, 20, 10]

for index in range(len(notes)):
    nouvelle_note = notes[index] + 1
    if nouvelle_note > 20:
        nouvelle_note = 20
    notes[index] = nouvelle_note

print(notes)
```
La lecture de notes[index] récupère la valeur actuelle. L'affectation finale à cette même position remplace la valeur de la liste. Cette technique doit être utilisée avec attention : modifier une liste pendant qu'on la parcourt peut être nécessaire, mais le traitement doit rester simple et prévisible.

Pour savoir si une valeur est présente, utilisez in. Le résultat est une valeur booléenne.
python
```
fruits = ['pomme', 'banane', 'orange']
print('banane' in fruits)
print('kiwi' in fruits)
```
Vous pouvez combiner ce test avec une condition afin d'éviter un traitement inutile ou une suppression impossible. L'opérateur not in vérifie au contraire l'absence d'une valeur.
python
```
fruits = ['pomme', 'banane']

if 'orange' not in fruits:
    fruits.append('orange')

print(fruits)
```
Pour créer une nouvelle liste ne contenant que certaines valeurs, une boucle et une condition offrent une méthode très lisible. L'exemple suivant conserve les notes supérieures ou égales à 10.
python
```
notes = [8, 12, 16, 10, 7]
notes_validees = []

for note in notes:
    if note >= 10:
        notes_validees.append(note)

print(notes_validees)
```
La liste d'origine n'est pas modifiée. Une seconde liste reçoit uniquement les valeurs répondant à la condition. Cette distinction est importante : selon le besoin, vous pouvez conserver les données brutes et produire une liste filtrée séparée.

Une liste peut être triée avec sort(), qui la modifie directement. Pour des nombres, l'ordre est croissant par défaut.
python
```
notes = [12, 8, 16, 10]
notes.sort()
print(notes)
```
Pour l'ordre décroissant, utilisez l'argument nommé reverse=True.
python
```
notes = [12, 8, 16, 10]
notes.sort(reverse=True)
print(notes)
```
Si vous souhaitez obtenir une liste triée sans modifier la liste existante, utilisez sorted(). Cette fonction renvoie une nouvelle liste.
python
```
notes = [12, 8, 16, 10]
notes_triees = sorted(notes)
print(notes)
print(notes_triees)
```
Cette différence entre une méthode qui modifie l'objet et une fonction qui retourne une nouvelle valeur est fondamentale. Observez toujours le contenu de vos variables après un tri ou une suppression pour confirmer que le comportement correspond à votre intention.

Enfin, méfiez-vous des copies. L'affectation copie = fruits ne fabrique pas une seconde liste indépendante : les deux variables désignent la même liste. Une modification visible via l'une est alors visible via l'autre.
python
```
fruits = ['pomme', 'banane']
autres_fruits = fruits
autres_fruits.append('orange')
print(fruits)
```
Pour obtenir une nouvelle liste indépendante à un niveau simple, vous pouvez utiliser une tranche complète ou la méthode copy().
python
```
fruits = ['pomme', 'banane']
copie_fruits = fruits.copy()
copie_fruits.append('orange')
print(fruits)
print(copie_fruits)
```
La première liste reste ici inchangée. Cette précaution est utile lorsqu'une fonction ou une étape de programme doit travailler sur une variante de données sans altérer la collection initiale.

Erreurs fréquentes & dépannage

Oublier que le premier indice est 0

Écrire fruits[1] pour demander le premier fruit renvoie en réalité le deuxième. Retenez que les indices d'une liste de longueur n commencent à 0 et se terminent à n - 1.

Accéder à un indice inexistant

Une instruction telle que fruits[5] échoue si la liste ne contient pas au moins six éléments. Vérifiez le contenu ou la longueur de la liste avant un accès calculé, surtout si la liste peut être vide.

Confondre append et extend

append(['a', 'b']) ajoute une liste comme unique élément, tandis que extend(['a', 'b']) ajoute séparément 'a' et 'b'. Choisissez la méthode selon la structure que vous voulez obtenir.

Supprimer une valeur absente avec remove

remove() provoque une erreur si la valeur demandée n'existe pas. Testez d'abord avec in lorsque cette absence est possible.

Modifier une liste pendant une boucle de suppression

Supprimer des éléments de la même liste pendant un parcours direct peut faire sauter certaines valeurs, car les indices changent après chaque suppression. Préférez construire une nouvelle liste filtrée, comme dans l'exemple des notes validées.

Créer un alias au lieu d'une copie

L'affectation copie = liste ne copie pas les éléments. Utilisez liste.copy() si vous souhaitez modifier la nouvelle liste sans modifier la première dans les cas simples présentés ici.

Astuces & pour aller plus loin

Afficher la liste après une étape importante

Au début, ajoutez régulièrement print(ma_liste) après un ajout, une suppression ou un tri. Cette vérification simple rend l'effet de chaque instruction visible et accélère le débogage.

Choisir des noms au pluriel

Un nom comme notes, clients ou taches indique immédiatement qu'une variable contient plusieurs éléments. Dans une boucle, utilisez le singulier correspondant : for note in notes.

Préférer la boucle directe pour lire

Si vous n'avez pas besoin de l'indice, écrivez for element in liste. Utilisez enumerate() lorsque vous voulez aussi la position, et range(len(liste)) lorsque vous devez travailler explicitement avec les indices.

Utiliser une liste vide comme point de départ

Pour collecter des résultats répondant à une condition, créez une liste vide puis employez append() dans une boucle. Cette méthode est claire pour construire une liste filtrée sans modifier les données initiales.

Distinguer modification et nouvelle liste

sort(), append() et remove() modifient une liste existante. À l'inverse, une tranche, sorted() ou l'opérateur + peuvent servir à produire une nouvelle liste. Poser cette distinction avant d'écrire le code évite de perdre des données par inadvertance.

Questions fréquentes

Une liste Python peut-elle contenir plusieurs types de valeurs ?

Oui. Une liste peut contenir par exemple du texte, des nombres et des booléens. Dans beaucoup de programmes, conserver des éléments de même nature reste toutefois plus simple à lire et à traiter.

Quelle est la différence entre append() et insert() ?

append() ajoute une valeur à la fin de la liste. insert(index, valeur) ajoute une valeur à une position choisie et décale les éléments suivants.

Comment retirer le dernier élément d'une liste ?

Utilisez pop() sans argument. Cette méthode retire le dernier élément et vous permet de récupérer sa valeur dans une variable.

Comment parcourir une liste avec son numéro de position ?

Utilisez enumerate(liste) dans une boucle for. La boucle reçoit alors un indice et l'élément correspondant à chaque passage.

Pourquoi une modification apparaît-elle dans deux variables de liste ?

Cela arrive si vous avez écrit une affectation comme copie = liste. Les deux variables désignent alors la même liste. Utilisez liste.copy() pour créer une copie indépendante dans les cas simples.

Conclusion

Vous savez maintenant créer une liste Python et manipuler son contenu avec les opérations essentielles. Vous pouvez lire un élément grâce à son indice, ajouter des données avec append(), insert() ou extend(), remplacer une valeur par affectation et supprimer des éléments avec remove(), pop(), del ou clear().

Vous avez également vu plusieurs façons de parcourir une liste : une boucle for pour lire les valeurs, enumerate() pour obtenir les positions et range(len(...)) lorsque les indices sont nécessaires. La meilleure manière de progresser consiste à adapter les exemples à vos propres données : une liste de livres, de dépenses, de tâches ou de résultats. Observez la liste après chaque opération afin de consolider votre compréhension de son évolution.