La méthode append() en Python ajoute un unique élément à la fin d’une liste existante. Elle modifie la liste en place, sans créer de nouvel objet, et ne renvoie rien (son retour est None). Cette distinction a des conséquences directes sur la façon d’écrire du code correct, et c’est souvent là que les débutants trébuchent.
Pourquoi append() ne renvoie rien en Python
Beaucoup de débutants écrivent ma_liste = ma_liste.append(5) et se retrouvent avec None au lieu de leur liste. La méthode modifie directement l’objet liste en mémoire. Affecter son résultat à une variable écrase la liste par None.
Voici le piège classique :
fruits = ["pomme", "banane"]fruits = fruits.append("cerise")print(fruits) # affiche None
La version correcte :
fruits = ["pomme", "banane"]fruits.append("cerise")print(fruits) # affiche ["pomme", "banane", "cerise"]
Append modifie la liste en place, ne l’affectez jamais à une variable. Ce comportement vaut pour la majorité des méthodes de mutation de liste en Python (sort(), reverse(), extend()).
Exercice corrigé : identifier l’erreur
Que produit ce code ?
notes = [12, 15, 9]notes = notes.append(17)print(type(notes))
Correction : print affiche <class 'NoneType'>. La variable notes contient désormais None. Pour corriger, il suffit d’écrire notes.append(17) sans réaffectation.
Append, extend et opérateur + : choisir la bonne méthode pour une liste Python
La confusion entre append() et extend() génère des bugs silencieux. Les deux ajoutent des éléments, mais pas de la même façon.
append(element)ajoute un seul élément à la fin de la liste, quel que soit son type. Si cet élément est une liste, elle sera imbriquée comme sous-liste.extend(iterable)parcourt l’itérable passé en argument et ajoute chacun de ses éléments individuellement à la fin de la liste.- L’opérateur
+crée une nouvelle liste en concaténant deux listes. Il ne modifie pas les originales.
Exemple concret pour visualiser la différence :
a = [1, 2]a.append([3, 4])print(a) # [1, 2, [3, 4]]
b = [1, 2]b.extend([3, 4])print(b) # [1, 2, 3, 4]
La règle pratique : append pour un élément, extend pour en ajouter plusieurs. L’opérateur + convient quand on veut garder la liste d’origine intacte.
Exercice corrigé : append vs extend
Complétez ce code pour obtenir [10, 20, 30, 40, 50] à partir de deux listes :
partie1 = [10, 20]partie2 = [30, 40, 50]# votre code iciprint(partie1)
Correction : partie1.extend(partie2) donne le résultat attendu. Avec partie1.append(partie2), on obtiendrait [10, 20, [30, 40, 50]], ce qui n’est pas l’objectif.
Construire une liste avec append dans une boucle for
Le cas d’usage le plus fréquent de append() consiste à remplir une liste vide élément par élément dans une boucle for. Le schéma est toujours le même : initialiser une liste vide avant la boucle, puis appeler append() à chaque itération.
carres = []for i in range(1, 6): carres.append(i ** 2)print(carres) # [1, 4, 9, 16, 25]
L’initialisation carres = [] est obligatoire. Sans elle, Python lève une NameError parce que la variable n’existe pas encore.
Exercice corrigé : filtrer des éléments avec append
À partir d’une liste de notes, construisez une liste contenant uniquement les notes supérieures ou égales à 10 :
notes = [8, 14, 5, 17, 11, 3, 16]reussites = []for note in notes: if note >= 10: reussites.append(note)print(reussites)
Correction : le programme affiche [14, 17, 11, 16]. La condition if filtre chaque element avant l’ajout. Ce patron (boucle + condition + append) revient constamment en Python.
Append et performance en Python : temps amorti constant
Quand on construit des listes volumineuses dans une boucle, la question de la performance se pose. Sous le capot, une liste Python repose sur un tableau dynamique. Lorsque le tableau est plein, Python alloue un bloc mémoire plus grand et copie les éléments existants.
Cette copie est coûteuse, mais elle survient rarement. Python surdimensionne le tableau à chaque redimensionnement, de sorte que la grande majorité des appels à append() se font en temps amorti constant. Cela signifie que sur un grand nombre d’appels, le coût moyen par appel reste stable, même si un appel isolé peut être plus lent.
En pratique, append() dans une boucle reste la méthode recommandée pour construire des listes élément par élément, y compris sur de très grands volumes de données.
Exercice corrigé : calculer une moyenne avec append et range
Construisez une liste des multiples de 7 inférieurs à 50, puis calculez leur moyenne :
multiples = []for i in range(1, 50): if i % 7 == 0: multiples.append(i)moyenne = sum(multiples) / len(multiples)print(multiples)print(moyenne)
Correction : multiples contient [7, 14, 21, 28, 35, 42, 49]. La moyenne affichée est 28.0. La fonction sum() additionne les elements de la liste, et len() renvoie le nombre d’elements.
Append avec des types composites : listes imbriquées et dictionnaires
Quand l’argument passé à append() est un objet composite (une autre liste, un tuple, un dictionnaire), cet objet est ajouté tel quel comme élément unique. Python n’en extrait pas le contenu.
data = []data.append({"nom": "Alice", "score": 88})data.append({"nom": "Bob", "score": 72})print(data)
Le résultat est une liste de deux dictionnaires. Ce patron sert couramment à accumuler des enregistrements avant de les traiter ou de les exporter.
Exercice corrigé : construire une liste de dictionnaires
À partir de deux listes parallèles, construisez une liste de dictionnaires :
prenoms = ["Alice", "Bob", "Clara"]scores = [88, 72, 95]resultats = []for i in range(len(prenoms)): resultats.append({"prenom": prenoms[i], "score": scores[i]})print(resultats)
Correction : print affiche [{"prenom": "Alice", "score": 88}, {"prenom": "Bob", "score": 72}, {"prenom": "Clara", "score": 95}]. Chaque tour de boucle crée un nouveau dictionnaire et l’ajoute à resultats via append.
Maîtriser append() revient à comprendre deux principes : la mutation en place (pas de réaffectation) et l’ajout d’un seul élément par appel. Tous les exercices ci-dessus découlent de ces deux règles. Le reste, c’est de la pratique avec des boucles for, des conditions if et des types de données variés.
