Demander « une liste de zéro titre » en python mélange souvent trois idées différentes: une liste vide (aucun élément), une liste contenant le nombre zéro (un seul élément, valeur 0), ou une liste de n zéros (n éléments initialisés à 0). À cela s’ajoute une autre confusion fréquente: une liste numérotée, qui n’est pas une liste de zéros mais une liste de nombres (ou une liste d’éléments accompagnés de leur index). Clarifier ces cas, c’est éviter des bugs discrets: tailles inattendues, références dupliquées avec la multiplication de liste, et erreurs d’indexation qui passent les tests « par hasard ».
- « liste de 0 » peut vouloir dire: liste vide [], liste [0], ou liste de n zéros [0] * n
- une liste est ordonnée, mutable, indexée à partir de 0: l’index n’est pas la valeur
- la multiplication de liste duplique des références: piège majeur avec les listes imbriquées
- range() génère des nombres, enumerate() associe un index aux éléments
- copie et références: l’affectation ne copie pas, elle partage le même objet
Table des matières
Ce que veut dire « créer une liste de 0 » en python
En python, une liste (type list) est un conteneur ordonné d’objets, potentiellement hétérogènes, défini avec les crochets [ et ]. Elle est mutable: on peut modifier ses éléments et même sa structure (ajout, suppression), ce qui fait varier sa longueur. C’est précisément cette souplesse qui rend la requête « créer une liste de 0 » ambiguë.
Dans la pratique, on rencontre au moins quatre interprétations:
- Une liste vide: aucune donnée pour l’instant, mais une structure prête à recevoir des éléments: [].
- Une liste contenant zéro: une donnée unique, la valeur numérique 0: [0].
- Une liste de n zéros: une initialisation de taille fixe, typique d’un tableau de compteurs: [0] * n ou une compréhension de liste.
- Une liste numérotée: une suite d’entiers (souvent via range()) ou une liste de couples (index, valeur) via enumerate().
La confusion vient d’un détail: l’index commence à 0. Beaucoup de tutos montrent des exemples où le premier élément est à l’index 0, et certains lecteurs concluent qu’une « liste de 0 » est une liste « qui commence à 0 ». Or l’index est une position, pas une valeur stockée. Une liste peut commencer à l’index 0 tout en contenant 42 en premier élément.
Pour lever l’ambiguïté, le bon réflexe est de formuler l’objectif en termes de contenu (quelles valeurs), de taille (combien d’éléments), et de forme (entiers seuls ou couples indexés). Cela amène naturellement à la question suivante: créer une nouvelle liste, vide, alimentée par des valeurs, ou obtenue par copie.
Créer une nouvelle liste: vide, à partir de valeurs, ou par copie
La création la plus directe est la liste vide: l = []. C’est la base quand la taille n’est pas connue au départ et que l’on va ajouter des éléments ensuite. L’alternative list() crée aussi une liste vide sans argument: l = list().
Pour créer une liste à partir de valeurs, on peut:
- écrire les éléments: scores = [10, 0, 7];
- convertir un itérable: chars = list(« abc ») (une liste est une séquence comme une chaîne, mais mutable);
- générer des nombres: nums = list(range(10)) produit une liste de 0 à 9.
Ensuite, vient un piège central: affectation n’est pas copie. En python, une liste est un objet; écrire b = a ne crée pas une nouvelle liste, cela crée une nouvelle référence vers le même objet. Modifier b modifie alors a, ce qui surprend dans les initialisations.
Pour obtenir une copie superficielle (nouvel objet liste, mais éléments internes partagés si ce sont des objets mutables), plusieurs options classiques existent:
- b = a.copy();
- b = list(a);
- b = a[:] (slicing).
La distinction « référence vs copie » est décisive dès qu’on initialise des structures, puis qu’on les remplit avec append() (plus rapide en pratique que insert(), car l’ajout en fin est optimisé) ou extend() (ajout en bloc). Elle l’est encore plus quand on veut préremplir une liste, par exemple avec des zéros, ce qui mène à l’étape suivante: initialiser une liste de n zéros sans se tromper.
Initialiser une liste de n zéros sans se tromper
Si l’objectif est une liste de taille n remplie de zéros, la forme la plus lisible est souvent la multiplication de liste: zeros = [0] * n. Pour des éléments immuables comme l’entier 0, c’est sûr: chaque position contient la valeur 0, et modifier un élément (par affectation) n’affecte pas les autres.
La compréhension de liste est une alternative robuste et expressive: zeros = [0 for _ in range(n)]. Elle est particulièrement utile si l’initialisation n’est pas un simple zéro, ou si l’on veut calculer une valeur par index: vals = [i * 2 for i in range(n)].
Le vrai piège, trop peu expliqué dans les tutos rapides, apparaît avec les listes imbriquées. Beaucoup écrivent:
grille = [[0] * 3] * 2
Intention: 2 lignes de 3 zéros. Problème: la multiplication de liste duplique des références vers la même sous-liste. Résultat: modifier grille[0][0] modifie aussi grille[1][0], car ce sont les mêmes objets internes.
La bonne méthode est de créer chaque sous-liste séparément, typiquement avec une compréhension:
grille = [[0] * 3 for _ in range(2)]
Ce principe s’applique à toute préallocation de structures 2D, y compris des matrices, des tableaux de scores par joueur, ou des buffers. Pour illustrer une liste de listes valide et indépendante, on peut organiser des valeurs paires de 2 à 128 en 8 sous-listes de 8 éléments, par exemple:
[[2, 4, 6, 8, 10, 12, 14, 16], [18, 20, 22, 24, 26, 28, 30, 32], [34, 36, 38, 40, 42, 44, 46, 48], [50, 52, 54, 56, 58, 60, 62, 64], [66, 68, 70, 72, 74, 76, 78, 80], [82, 84, 86, 88, 90, 92, 94, 96], [98, 100, 102, 104, 106, 108, 110, 112], [114, 116, 118, 120, 122, 124, 126, 128]]
Une fois l’initialisation maîtrisée, reste l’autre sens courant de « liste de 0 »: une liste « qui numérote ». Cela se traite avec index, range et enumerate.
Créer une liste numérotée: index, range et enumerate
Une liste numérotée peut désigner deux résultats différents, et c’est là que l’on se trompe souvent en lisant des exemples.
Premier cas: on veut une liste d’entiers. La solution canonique est range() combiné à list(). Par exemple, list(range(10)) génère les nombres de 0 à 9. On obtient des valeurs, pas des index « attachés » à autre chose.
Deuxième cas: on veut associer un index à chaque élément d’une liste existante. Par défaut, l’itération en python se fait sur les éléments, pas sur les index. Quand l’index est requis, on utilise enumerate():
items = [« pomme », « poire », « prune »] num = list(enumerate(items))
Résultat: une liste de couples (index, valeur) comme [(0, « pomme »), (1, « poire »), (2, « prune »)]. C’est souvent ce que les lecteurs appellent « liste numérotée ».
On peut aussi garder la forme itérative sans convertir en liste, mais si l’objectif explicite est une liste numérotée, la conversion rend le résultat tangible.
| Besoin | Outil | Résultat | Exemple |
|---|---|---|---|
| suite d’entiers | list(range(n)) | liste d’int | [0, 1, 2, …, n-1] |
| index + élément | list(enumerate(l)) | liste de couples | [(0, l[0]), (1, l[1]), …] |
À noter: l’indexation commence à 0, et l’indexation négative existe aussi (-1 pour le dernier élément). Ces détails nourrissent des erreurs de décalage et des confusions « index vs valeur », qu’on rencontre immédiatement en situation. Passons donc aux cas pratiques et aux erreurs courantes, là où les listes imbriquées et les tailles réelles font trébucher.
Cas pratiques et erreurs courantes: taille, types et listes imbriquées
Cas pratique 1: tableau de scores. Si vous suivez 5 joueurs et que chaque score commence à zéro, une initialisation claire est scores = [0] * 5. Ensuite, on incrémente par index: scores[i] += 1. L’erreur typique est de confondre « joueur numéro 1 » avec l’index 1, alors que le premier joueur est souvent à l’index 0. Pour rendre le code explicite, on peut stocker un mapping séparé ou utiliser enumerate() quand on affiche.
Cas pratique 2: préallocation puis remplissage. Une liste est mutable et sa longueur peut changer: on peut partir de [], puis ajouter avec append() élément par élément. Si vous devez ajouter une autre liste d’un coup, extend() est fait pour ça; et l’opérateur + sur les listes se comporte presque comme une concaténation équivalente à un extend, mais en produisant une nouvelle liste. L’erreur fréquente est de mélanger append() et extend(): append([1, 2]) ajoute une sous-liste, alors que extend([1, 2]) ajoute deux éléments.
Cas pratique 3: numérotation d’items pour un export. On veut souvent une liste de lignes du type « 1. texte », « 2. texte ». En python, l’index commence à 0, donc on adapte: [(i + 1, v) for i, v in enumerate(items)]. L’erreur classique est l’off-by-one: oublier le + 1 et livrer une numérotation qui démarre à 0.
Cas pratique 4: types. Le zéro numérique 0 n’est pas la chaîne « 0 ». Ils ne se comparent pas de la même façon et ne servent pas aux mêmes calculs. Une liste peut contenir des types différents (entiers, chaînes, booléens, flottants, autres listes), mais cette liberté peut masquer une erreur d’entrée. Si vous testez l’appartenance avec in, 0 in [« 0 »] est faux, et c’est souvent un signal utile.
Cas pratique 5: listes imbriquées et duplication. Le bug le plus coûteux en temps est la duplication de références via la multiplication de liste sur une sous-liste. Règle opérationnelle:
- ok: [0] * n pour des immuables (comme 0);
- à éviter: [[0] * m] * n;
- à faire: [[0] * m for _ in range(n)].
Enfin, quand vous devez modifier une portion de liste, le slicing peut aussi servir d’outil d’insertion, suppression ou remplacement: la forme s[i : j] = t remplace la tranche par une autre séquence, même de taille différente. C’est puissant, mais cela change la longueur et peut décaler des index, ce qui explique des bugs « fantômes » si l’on continue à itérer sur des positions calculées avant modification.
FAQ
Python créer une liste de 0 ?
Précisez le besoin: [] pour une liste vide, [0] pour une liste contenant un seul zéro, [0] * n (ou [0 for _ in range(n)]) pour une liste de n zéros. Évitez [[0] * m] * n si vous créez des listes imbriquées, car cela duplique des références.
Comment créer une liste numéroté ?
Pour une liste de nombres: list(range(n)). Pour numéroter des éléments: list(enumerate(liste)), ou [(i + 1, v) for i, v in enumerate(liste)] si vous voulez démarrer à 1.
Quel élément pouvez-vous utiliser pour créer une liste numérotée ?
range() sert à générer une suite de nombres, et enumerate() sert à associer un index aux éléments lors d’une itération.
Comment puis-je créer une nouvelle liste ?
Avec [] ou list() pour une liste vide, avec list(iterable) pour convertir un itérable, et avec a.copy() ou a[:] pour copier une liste existante au lieu de partager la même référence.
Une « liste de 0 » n’est pas une formule magique mais un objectif à préciser: taille, contenu, et forme attendue. En python, choisir entre liste vide, initialisation à zéro, ou liste numérotée revient surtout à éviter les confusions entre valeur et index, et à maîtriser les références quand la liste devient imbriquée.
