La méthode append() en Python ajoute un élément unique à la fin d’une liste existante et renvoie None. Cette opération modifie la liste sur place, sans en créer de nouvelle.
Utilisée dans une boucle for ou while, elle permet de construire progressivement une liste à partir de données filtrées, transformées ou lues depuis une source externe. Plusieurs erreurs courantes surgissent précisément à l’intersection de append() et des boucles, là où le comportement in-place de la méthode entre en conflit avec des réflexes de programmation mal calibrés.
A découvrir également : Ajoutez facilement une liste déroulante sur Excel en quelques étapes
Le retour None de append() : source d’erreur silencieuse dans une boucle Python
Quand on écrit resultat = ma_liste.append(x) dans le corps d’une boucle, la variable resultat vaut None à chaque itération. La liste est bien modifiée, mais la valeur de retour n’est pas la liste mise à jour.
Le piège classique consiste à chaîner l’affectation et l’appel. Par exemple, réécrire une liste à chaque tour avec ma_liste = ma_liste.append(valeur) écrase la référence à la liste par None dès la première itération. Au tour suivant, l’appel append() sur None lève une AttributeError. Le programme plante, et le message d’erreur ne mentionne jamais le mot « append » directement, ce qui déroute les débutants.
A découvrir également : Débutant en data ? parse XML using Python étape par étape
Append() ne renvoie rien : il ne faut jamais affecter son résultat. L’appel correct est toujours nu, sur une ligne seule : ma_liste.append(valeur), sans signe égal à gauche. Cette règle s’applique dans le corps d’une boucle comme partout ailleurs, mais c’est dans les boucles que l’erreur survient le plus souvent, parce qu’on accumule les résultats et qu’on cherche instinctivement à « récupérer » quelque chose.
Modifier une liste Python pendant son itération avec append()
Ajouter des éléments à une liste pendant qu’on la parcourt avec une boucle for crée un comportement imprévisible. La boucle for utilise un index interne qui avance d’un cran à chaque tour. Si la liste grandit entre deux tours, l’itérateur ne s’arrête pas au point prévu initialement.
Boucle infinie par append() dans une boucle for
Le scénario le plus dangereux est une boucle for qui ajoute un élément à la liste parcourue à chaque itération sans condition d’arrêt. Comme la taille de la liste augmente à chaque tour, la boucle ne se termine jamais. Le programme consomme la mémoire disponible jusqu’au crash.
Le cas moins visible, mais tout aussi problématique, concerne les éléments sautés ou traités deux fois. Si vous combinez append() et remove() sur la même liste dans la même boucle, les index se décalent. Un élément peut être ignoré parce que l’itérateur avance alors que la liste vient de rétrécir à gauche.
Deux solutions fiables
- Itérer sur une copie de la liste originale (
for x in ma_liste[:]oufor x in list(ma_liste)) et faire les append() sur la liste originale. L’itérateur parcourt un objet figé, les modifications n’affectent que la liste de travail. - Construire une nouvelle liste séparée dans la boucle. Au lieu d’injecter dans la liste source, accumulez les résultats dans une variable distincte, puis fusionnez après la boucle si nécessaire.
- Utiliser une boucle while avec un index géré manuellement, en ajustant explicitement le compteur quand la taille de la liste change. Cette approche reste fragile et n’est recommandée que pour des cas spécifiques où l’ordre d’insertion compte.
Boucle for avec append() ou compréhension de liste Python : quand choisir
Le pattern classique pour construire une liste dans une boucle ressemble à ceci : on initialise une liste vide, on ouvre une boucle for, et on appelle append() à chaque tour. Ce schéma fonctionne, mais Python offre une syntaxe dédiée pour ce cas précis : la compréhension de liste (list comprehension).
Une compréhension de liste condense l’initialisation, la boucle et l’ajout en une seule expression. Pour une transformation directe (appliquer une opération à chaque élément d’un itérable), elle produit un code plus court et plus lisible. Elle est aussi généralement plus rapide, parce que l’interpréteur Python optimise cette construction en interne.
Le pattern for + append() reste le bon choix dans plusieurs situations précises :
- Quand la logique d’ajout dépend de conditions multiples imbriquées. Deux ou trois if/else dans une compréhension de liste deviennent difficiles à lire.
- Quand chaque itération produit des effets de bord (écriture dans un fichier, appel réseau, affichage) en plus de l’ajout à la liste.
- Quand le nombre d’éléments ajoutés par tour varie. Une itération peut ajouter zéro, un ou plusieurs éléments selon un calcul intermédiaire, ce que la compréhension de liste ne gère pas nativement.
- Quand le code doit rester compréhensible pour une équipe qui débute en Python. La boucle explicite décompose chaque étape.
Pour une transformation simple, la compréhension de liste remplace avantageusement le pattern for + append(). Dès que la logique se complexifie, la boucle explicite reprend l’avantage sur la lisibilité.
Coût mémoire de append() dans une boucle Python sur de grands volumes
Une liste Python ne stocke pas ses éléments dans un bloc mémoire de taille fixe. Chaque fois que la capacité interne est atteinte, l’interpréteur alloue un nouveau bloc plus grand et copie les références existantes. Ce redimensionnement suit un facteur de croissance qui évite de réallouer à chaque append(), mais le coût cumulé devient perceptible quand la boucle traite plusieurs millions d’éléments.
Sur de grands volumes, les réallocations mémoire successives peuvent ralentir sensiblement la boucle. L’allocation initiale d’une liste vide est minimale. Si le nombre d’éléments attendus est connu à l’avance, pré-allouer avec une compréhension de liste ou avec [None] * n puis affecter par index évite les copies intermédiaires.
Pour les cas où la liste finale sert uniquement de passage vers un traitement séquentiel (parcours unique, écriture dans un fichier), un générateur remplace avantageusement la liste. Au lieu de stocker tous les éléments en mémoire, le générateur produit chaque valeur à la demande. La boucle qui consomme le générateur ne voit aucune différence, mais la mémoire utilisée reste constante quel que soit le nombre d’éléments.
Append() dans une boucle reste l’outil adapté quand le programme a besoin d’accéder à la liste complète après construction (tri, accès par index, passage à une fonction). Si seul le parcours compte, le générateur est l’alternative à considérer.
