Comprendre rapidement ce qu’est une liste en python, comment la créer (vide, avec n éléments, numérotée), la modifier et la parcourir, avec les erreurs fréquentes à éviter et des exemples directement réutilisables.
- une liste python (type list) est une collection ordonnée et modifiable d’objets, potentiellement de types différents
- on crée une liste avec [], list(), list(range(…)) ou une compréhension de liste selon le besoin (vide, remplie, n éléments)
- l’accès se fait par index (0 à n-1), par indice négatif (-n à -1) et par slice (tranches) avec début inclus et fin exclue
- pour modifier: append, extend, insert, puis remove, pop ou del pour supprimer, en évitant d’insérer/supprimer pendant un for
- attention aux copies: affectation ≠ copie; shallow copy pour une liste simple, deep copy pour une liste imbriquée
Table des matières
Comprendre ce qu’est une liste en python et à quoi elle sert
En python, une liste est une structure de données séquentielle: un objet qui contient une collection ordonnée d’objets. « Ordonnée » signifie que chaque élément a une position stable, accessible via un index (appelé aussi indice). C’est ce qui rend une liste très pratique dès qu’il faut créer une collection, la remplir progressivement, puis la parcourir pour produire un résultat.
Autre caractéristique clé: une liste est modifiable. On peut remplacer un élément, insérer, supprimer, ou extraire des sous-listes. Cette mutabilité change la manière de coder: on peut partir d’une liste vide, ajouter au fil de l’eau, puis nettoyer ou réordonner.
La liste python (type list) accepte des éléments de types différents. Une même liste peut mélanger entier, chaîne de caractères, booléen, float, et même d’autres listes. Cette souplesse est utile pour prototyper ou manipuler des données hétérogènes, mais elle impose aussi de rester clair sur ce que l’on stocke, surtout quand on parcourt et transforme.
Dans la pratique, on rencontre plusieurs « types de listes » au sens usage:
- liste ordonnée: une suite d’éléments dans un ordre significatif (étapes, priorités, historique)
- liste numérotée: une liste dont on exploite explicitement la paire (index, valeur), par exemple pour afficher des lignes « 1. …, 2. … »
- liste imbriquée: une liste de listes, utile pour représenter un tableau, une grille, des groupes, des lots
Une fois ces besoins posés (collecter, modifier, parcourir), le plus efficace est d’enchaîner avec les façons concrètes de démarrer: créer une liste : vide, avec des éléments, ou de n éléments.
Créer une liste : vide, avec des éléments, ou de n éléments
La création d’une liste en python se fait d’abord avec la syntaxe littérale: des crochets [] et des éléments séparés par des virgules. C’est la forme la plus lisible quand les valeurs sont connues.
Créer une liste vide:
Code:
todo = []
Une liste a une longueur finie, et la liste vide a une longueur de 0. Pour le vérifier, len(liste) retourne le nombre d’éléments:
len(todo) # 0
Créer une liste avec des éléments:
scores = [12, 18, 9]
mixte = [1, « ok », True, 3.14, [« a », « b »]]
Créer une liste via list() est utile lorsqu’on part d’un itérable (ou quand on veut être explicite sur la conversion). Par exemple, transformer une séquence en liste:
chars = list(« python ») # [‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]
Créer une liste de n éléments dépend de l’intention:
- initialiser avec une valeur (attention aux objets mutables, on y revient plus loin): zeros = [0] * 5
- générer une suite d’entiers avec range: nums = list(range(0, 10))
- calculer des valeurs avec une compréhension de liste: carres = [x * x for x in range(0, 10)]
range(a, b) produit une séquence d’entiers de a inclus à b exclu. Si range() reçoit un seul argument, la séquence commence à 0. Et si un troisième argument est fourni, il correspond au pas entre deux valeurs successives:
pairs = list(range(0, 10, 2)) # 0, 2, 4, 6, 8
Ces constructions couvrent l’essentiel: démarrer vide, instancier rapidement, ou générer une base de travail. L’étape suivante consiste à lire efficacement ce que l’on a créé, sans se tromper d’indice: accéder aux éléments : index, indice négatif et tranches.
Accéder aux éléments : index, indice négatif et tranches
Les éléments d’une liste sont accessibles par leur position, appelée indice (ou index). Pour une liste de n éléments, les indices positifs valides vont de 0 à n-1. C’est un point central pour éviter les erreurs de lecture.
Exemple orienté lecture:
logs = [« ok », « warn », « ok », « error »]
premier = logs[0] # « ok »
dernier = logs[3] # « error »
Si l’on tente d’accéder à un indice hors de 0..n-1, python lève une erreur (typiquement IndexError). C’est fréquent quand on confond longueur et dernier index:
n = len(logs) # 4
logs[n] # erreur: l’indice 4 n’existe pas
Python supporte aussi l’indiçage négatif: -1 désigne le dernier élément, -2 l’avant-dernier, etc. Pour une liste de taille n, les indices valides (en incluant les négatifs) sont tous les entiers de -n à n-1 inclus.
dernier = logs[-1] # « error »
avant_dernier = logs[-2] # « ok »
Quand on a besoin d’un extrait, on utilise un slice (tranche) avec la forme liste[d : f], où d est inclus et f est exclu. Cette règle « fin exclue » simplifie beaucoup les découpages.
top3 = logs[0:3] # [« ok », « warn », « ok »]
du_deuxieme = logs[1:] # [« warn », « ok », « error »]
jusqua_deux = logs[:2] # [« ok », « warn »]
Un slicing peut inclure un pas: liste[d : f : pas]. Exemple avec pas = 2:
echantillon = logs[0:4:2] # [« ok », « ok »]
Ces accès sont faits pour parcourir et lire sans friction. Dès qu’on commence à corriger une valeur, ajouter une entrée ou supprimer du bruit, il faut passer aux opérations d’édition: modifier une liste : ajouter, remplacer et supprimer.
Modifier une liste : ajouter, remplacer et supprimer
La liste étant modifiable, on dispose de plusieurs outils, à choisir selon le besoin: ajouter un élément, ajouter plusieurs éléments, insérer à un endroit précis, remplacer une zone, ou supprimer.
Ajouter un seul élément à la fin: append() est la méthode standard quand on « remplit » au fil de l’eau.
events = []
events.append(« start »)
events.append(« stop »)
Ajouter plusieurs éléments: extend() ajoute chaque élément d’un itérable, là où append() ajouterait l’objet comme un seul bloc.
a = [1, 2]
a.extend([3, 4]) # [1, 2, 3, 4]
a.append([5, 6]) # [1, 2, 3, 4, [5, 6]]
Pour concaténer, les listes supportent aussi l’opérateur +:
full = [1, 2] + [3, 4]
Et pour dupliquer (répéter) une liste, l’opérateur *:
pattern = [« A », « B »] * 3 # [« A », « B », « A », « B », « A », « B »]
Insérer à un index précis: insert(index, valeur) est utile quand l’ordre compte, par exemple pour injecter un élément en tête.
queue = [« b », « c »]
queue.insert(0, « a ») # [« a », « b », « c »]
Remplacer se fait par affectation via l’index, ou via un slice si l’on vise une portion.
scores = [10, 11, 12]
scores[1] = 99 # [10, 99, 12]
scores[0:2] = [1, 2] # [1, 2, 12]
Supprimer: trois approches principales, à choisir selon ce que l’on sait.
- remove(valeur) supprime la première occurrence de la valeur: pratique si l’on connaît le contenu, pas sa position
- pop(index) supprime et retourne l’élément (sans index, la fin): pratique quand on veut consommer la liste
- del supprime par index ou tranche, sans retour: utile pour retirer un segment
items = [« a », « b », « c », « b »]
items.remove(« b ») # [« a », « c », « b »]
last = items.pop() # last = « b », items = [« a », « c »]
del items[0] # [« c »]
items.clear() # []
Critères simples pour choisir:
- si l’on ajoute une entrée à la fin: append
- si l’on fusionne des éléments: extend (ou + si l’on veut une nouvelle liste)
- si l’on doit supprimer et récupérer l’élément: pop
- si l’on supprime une valeur connue: remove
- si l’on coupe une zone: del sur un slice
Après l’édition, le besoin le plus fréquent est d’itérer proprement, souvent en affichant un numéro de ligne ou en construisant une structure (index, valeur): parcourir une liste et créer une liste numérotée.
Parcourir une liste et créer une liste numérotée
Parcourir une liste, c’est le cœur du travail: filtrer, transformer, agréger, afficher. Le parcours standard utilise for, qui lit la liste dans l’ordre.
names = [« ana », « li », « sam »]
for name in names:
print(name)
Quand on a besoin de l’index en plus de la valeur, enumerate est l’outil le plus lisible. Il produit des paires (index, valeur) sans calculer soi-même les indices.
for i, name in enumerate(names):
print(i, name) # 0 ana, 1 li, 2 sam
Pour créer une liste numérotée au sens « affichage à partir de 1 », on combine enumerate avec un décalage:
for num, name in enumerate(names, start=1):
Si l’objectif est de construire une liste de couples (numéro, valeur), on peut la matérialiser:
numerotee = [(i, v) for i, v in enumerate(names, start=1)]
# [(1, « ana »), (2, « li »), (3, « sam »)]
On peut aussi parcourir par index via range quand on doit écrire dans une autre structure avec des positions alignées, mais c’est souvent plus verbeux:
for i in range(0, len(names)):
print(i, names[i])
Point de vigilance important: il est fortement déconseillé de supprimer ou d’insérer des éléments dans une liste pendant son parcours. Cela peut sauter des éléments ou produire des résultats inattendus. Stratégies plus sûres:
- construire une nouvelle liste filtrée (souvent via compréhension de liste)
- parcourir une copie (si c’est acceptable)
- parcourir à l’envers quand on supprime par index (cas spécifiques)
Une fois à l’aise avec l’itération et la numérotation, on peut passer à un cas d’usage très concret: représenter des tableaux et des grilles avec une liste imbriquée.
Listes imbriquées : comprendre et manipuler une liste de listes
Une liste imbriquée est une liste dont certains éléments sont eux-mêmes des listes. C’est la représentation la plus directe d’un tableau 2D en python: lignes et colonnes. C’est aussi un format courant pour des données groupées (par lots, par catégories, par pages).
Exemple: une grille 3×3
grille = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
Accéder à un élément se fait par double index: d’abord la ligne, puis la colonne.
centre = grille[1][1] # 5
dernier = grille[-1][-1] # 9 (indice négatif sur deux niveaux)
Parcourir une liste de listes se fait naturellement avec une double boucle for:
for ligne in grille:
for valeur in ligne:
print(valeur)
Pour un affichage numéroté par ligne, enumerate reste pertinent:
for i, ligne in enumerate(grille, start=1):
print(i, ligne)
Le piège classique, quand on veut initialiser une grille, est d’utiliser la multiplication de liste avec un objet mutable, ce qui duplique des références plutôt que des lignes indépendantes.
À éviter:
grille = [[0] * 3] * 3
grille[0][0] = 1
# surprise: la première colonne de toutes les lignes change
À faire: créer chaque sous-liste séparément, typiquement avec une compréhension de liste.
grille = [[0] * 3 for _ in range(0, 3)]
Ce comportement mène directement au sujet le plus source d’effets de bord: la différence entre affectation, copie et duplication de références. D’où l’étape suivante: éviter les pièges : copies, références et effets de bord.
Éviter les pièges : copies, références et effets de bord
En python, faire b = a ne crée pas une copie de liste: c’est une affectation qui fait pointer deux variables vers le même objet. Modifier l’une modifie donc l’autre, car c’est la même liste.
a = [1, 2, 3]
b = a
b.append(4)
# a est aussi devenu [1, 2, 3, 4]
Pour une copie de liste « simple » (liste plate), une shallow copy suffit. Elle copie le conteneur, mais pas les objets référencés à l’intérieur. On peut la faire de plusieurs façons, dont le slicing:
a = [1, 2, 3]
b = a[:] # shallow copy via slice
b[0] = 99
# a reste [1, 2, 3]
On peut aussi passer par le constructeur list():
b = list(a)
Le problème apparaît avec une liste imbriquée. Une copie superficielle du conteneur laisse les sous-listes partagées, car elles restent les mêmes objets internes.
a = [[1, 2], [3, 4]]
b = a[:] # shallow copy
b[0].append(99)
# a a aussi changé, car b[0] et a[0] sont la même sous-liste
Quand on veut dupliquer toute la structure, y compris les sous-objets mutables, il faut une deep copy. En pratique, on passe par deepcopy pour éviter les références partagées.
from copy import deepcopy
a = [[1, 2], [3, 4]]
b = deepcopy(a)
b[0].append(99)
# a reste inchangé
Règle opérationnelle:
- liste plate: shallow copy (slice, list()) suffit généralement
- liste imbriquée: privilégier une deep copy si l’on doit modifier des sous-listes sans effet de bord
Une fois ces pièges neutralisés, on peut accélérer le travail quotidien avec les outils de lecture, de test et de transformation les plus utilisés: len, in, min, max, sum, tri et compréhensions.
Outils et idiomes utiles : len, in, min, max, sum, tri et compréhensions
Pour exploiter une liste, quelques fonctions et idiomes reviennent partout, parce qu’ils répondent à des besoins concrets: mesurer, tester la présence, agréger, trier, transformer.
Mesurer avec len:
items = [« a », « b », « c »]
n = len(items) # 3
Tester la présence avec in:
if « b » in items:
print(« présent »)
Agréger avec min, max, sum (sur des listes numériques):
vals = [10, 2, 7]
mini = min(vals) # 2
maxi = max(vals) # 10
total = sum(vals) # 19
Trier: deux approches selon si l’on veut modifier la liste ou produire une nouvelle liste.
- vals.sort() trie sur place
- sorted(vals) renvoie une nouvelle liste triée
vals = [10, 2, 7]
vals_triee = sorted(vals) # vals reste inchangée
Pour transformer une liste en texte, join s’applique sur une liste de chaînes:
mots = [« liste », « python », « rapide »]
phrase = » « .join(mots) # « liste python rapide »
Compréhension de liste: l’idiome le plus rentable quand on veut créer une nouvelle liste à partir d’une autre, en une expression lisible. Elle remplace avantageusement une boucle for + append quand il s’agit d’un simple mapping ou filtrage.
nums = list(range(0, 10))
pairs = [x for x in nums if x % 2 == 0]
carres = [x * x for x in nums]
Quand préférer une boucle explicite:
- si la transformation nécessite plusieurs étapes, des conditions complexes, ou des effets (journalisation, appels multiples)
- si la lisibilité souffre d’une expression trop dense
Avec ces outils, on couvre la majorité des opérations « créer, remplir, parcourir ». Reste un dernier choix structurant: parfois, la liste n’est pas la meilleure structure. Il faut alors choisir le bon type de structure selon le besoin.
Choisir le bon type de structure selon le besoin
On parle souvent de « types de liste », alors que le vrai enjeu est: quelle structure de données utiliser selon les opérations dominantes. La liste (list) est idéale quand l’ordre compte et que l’on doit accéder par index, modifier, découper avec un slice. Mais d’autres structures peuvent mieux répondre à certains besoins.
| Besoin dominant | Structure conseillée | Pourquoi |
|---|---|---|
| ordre + accès par index + modifications | liste (list) | collection ordonnée, indices, slices, append/insert/remove |
| ordre fixe, données immuables | tuple | structure séquentielle non modifiable, utile pour des enregistrements stables |
| unicité des éléments, test d’appartenance fréquent | set | pas de doublons, pratique pour dédupliquer et tester la présence |
| association clé/valeur, accès par clé | dict | récupération par clé plus directe qu’un parcours de liste |
En clair:
- si l’on manipule une collection ordonnée et que l’on doit souvent « aller au i-ème élément », la liste est naturelle
- si l’objectif est une liste « sans doublons », un set répond mieux au besoin qu’une liste filtrée en boucle
- si l’on cherche « une valeur à partir d’un identifiant », un dict évite de parcourir une liste pour trouver le bon élément
Ce choix n’empêche pas de revenir à la liste pour l’affichage, l’export ou les traitements séquentiels. L’important est de partir de l’opération dominante: créer, remplir, parcourir, ou rechercher.
FAQ
Python Comment créer une liste ?
Avec [] (ex.: [], [1, 2, 3]), avec list() pour convertir un itérable (ex.: list(« abc »)), ou avec list(range(…)) et une compréhension de liste (ex.: [x * x for x in range(0, 10)]).
Comment créer une liste numéroté ?
Utilise enumerate: for i, v in enumerate(ma_liste, start=1): print(i, v). Pour obtenir une liste de couples, fais [(i, v) for i, v in enumerate(ma_liste, start=1)].
Quels sont les différents types de liste ?
Au sens python, une liste est le type list. Au sens usage, on rencontre surtout des listes ordonnées, des listes numérotées (index, valeur) et des listes imbriquées (liste de listes). Selon le besoin, on peut aussi préférer tuple, set ou dict.
Qu’est-ce qu’une liste imbriquée ?
Une liste imbriquée est une liste qui contient d’autres listes (ex.: [[1, 2], [3, 4]]). On y accède avec deux indices (ligne puis colonne) et il faut faire attention aux copies et à l’initialisation par multiplication.
Une liste python devient vraiment utile quand on la traite comme un outil de production: on la crée selon l’objectif, on lit avec index, indice négatif et slice, on modifie avec les bonnes méthodes, puis on parcourt proprement sans provoquer d’effets de bord, surtout avec les listes imbriquées.
