# Python Add to List : ajout d’élément à une liste Python Les listes sont des structures de données fondamentales en informatique. De nombreux **algorithmes reposent sur la modification de listes**. Voici comment il est possible d’ajouter des éléments à une liste en Python. ## Comment ajouter des éléments à une liste Python ? Contrairement aux tuples et aux chaînes de caractères, **les listes Python sont « mutables », c’est-à-dire des structures de données modifiables**. Il est possible d’ajouter des éléments à une [liste Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-list/), d’en supprimer, voire d’en modifier l’ordre. Il existe pour cela différentes approches, chacune ayant ses propres avantages et inconvénients. Nous **présentons les quatre approches suivantes** pour ajouter des éléments à une liste en Python : 1. Ajouter des éléments à une liste Python à l’aide des méthodes Python-`list` ; 2. Ajouter des éléments à une liste Python avec la concaténation de listes ; 3. Ajouter des éléments à une liste Python avec Slice-Notation ; 4. Ajouter des éléments à une liste Python avec List Comprehension. ## Ajouter des éléments à une liste avec les méthodes Python-list En Python, **la classe `list` sert de base à toutes les opérations de liste**. La classe définit une série de méthodes pour les objets de liste. Cela comprend trois méthodes qui conviennent à l’ajout d’éléments à une liste :
méthode `list` arguments explication
`append()` `element` Ajouter un seul élément à la fin de la liste
`extend()` `[elements]` Ajouter plusieurs éléments à la fin de la liste
`insert()` `index, element` Ajouter un seul élément avant l’index donné
Il est important de comprendre que **la modification s’effectue « sur place » pour les trois méthodes mentionnées**. Cela signifie que l’on modifie l’objet liste au lieu de créer et renvoyer une nouvelle liste. Par conséquent, toutes ces méthodes renvoient `None` : ```Python # List of prime numbers primes = [2, 3, 5, 7] # Append additional prime number, saving returned result should_be_none = primes.append(11) # Show that the prime was added assert primes == [2, 3, 5, 7, 11] # Show that `None` was returned assert should_be_none is None ``` ### Ajouter un seul élément à la fin de la liste avec append() La méthode [Python-`append()`](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-append/) permet **d’ajouter un élément unique à la fin d’une liste existante**. Voici un exemple pour l’illustrer : ```Python # List containing single prime number primes = [2] # Add an element to the end of the list primes.append(3) # Show that the element was added assert primes == [2, 3] ``` Attention à l’utilisation de `append()` : la méthode **ajoute toujours un seul élément**. Si l’élément à ajouter est une autre liste, on obtient une liste imbriquée : ```Python # List with two prime numbers primes = [2, 3] # Try to appends multiple numbers at once primes.append([5, 7]) # Accidentally created a nested list assert primes == [2, 3, [5, 7]] ``` Notre essai pour créer la liste `[2, 3, 5, 7]` a échoué. Pour ajouter plusieurs éléments, mieux vaut passer par la méthode `extend()`. ### Ajouter des éléments à la fin de la liste avec extend() La méthode [Python-`extend()`](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-extend/) fonctionne de la même manière que la méthode `append()`, à la seule différence que **plusieurs éléments sont ajoutés à une liste existante**. Reprenons l’exemple précédent pour mieux comprendre : ```Python # List containing single prime number primes = [2] # Extend list by two elements primes.extend([3, 5]) # Show that both element were added assert primes == [2, 3, 5] ``` Attention cependant : la méthode `extend()` attend **un itérable comme argument et décompresse ses éléments**. Cela peut conduire à une sortie étonnante lorsqu’on appelle une chaîne de caractères : ```Python # List of friends friends = [‘Mary’, ‘Jim’] # Try to extend by additional friend friends.extend(‘Jack’) # String is unpacked into individual letters assert friends == [‘Mary’, ‘Jim’, ‘J’, ‘a’, ‘c’, ‘k’] ``` Pour ajouter un seul élément à une liste Python, on utilise soit `append()`, soit **on enferme l’élément dans une liste avec crochets**. Dans ce cas, l’appel à `extend()` fonctionne également : ```Python # List of friends friends = [‘Mary’, ‘Jim’] # Extend by additional friend inside list friends.extend([‘Jack’]) # Show that it worked assert friends == [‘Mary’, ‘Jim’, ‘Jack’] ``` ### Utiliser insert() pour ajouter un seul élément avant l’index spécifié Jusqu’à présent, nous avons montré comment ajouter un ou plusieurs éléments à la fin d’une liste Python. Mais que faire si nous voulons **insérer un élément à un endroit précis** ? C’est précisément la raison d’être de la méthode [Python-`insert()`](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-insert/). Celle-ci prend en compte un index numérique en plus de l’élément à insérer : ```Python # List of friends friends = [‘Mary’, ‘Jim’, ‘Jack’] # Insert additional friend `"Molly"` before index `2` friends.insert(2, ‘Molly’) # Show that "Molly" was added assert friends == [‘Mary’, ‘Jim’, ‘Molly’, ‘Jack’] ``` Attention en essayant d’ajouter plusieurs éléments avec `insert()` : comme `insert()` ajoute exactement un élément, **cela entraîne forcément la création d’une liste imbriquée** : ```Python # List of friends friends = [‘Mary’, ‘Jim’] # Try to insert multiple friends at once friends.insert(1, [‘Molly’, ‘Lucy’]) # Accidentally created a nested list assert friends == [‘Mary’, [‘Molly’, ‘Lucy’], ‘Jim’] ``` Pour **insérer correctement plusieurs éléments dans une liste**, il faut passer par une boucle `for`. Nous utilisons également la fonction `reversed()` pour conserver l’ordre des éléments insérés : ```Python # List of friends friends = [‘Mary’, ‘Jim’] # Using `reversed()` keeps order of inserted elements for friend in reversed([‘Molly’, ‘Lucy’]): friends.insert(1, friend) # Show that it worked assert friends == [‘Mary’, ‘Molly’, ‘Lucy’, ‘Jim’] ``` ## Ajouter des éléments à une liste par concaténation de listes Python En plus des méthodes `list` vues ci-dessus, il est possible de faire une **concaténation de listes pour ajouter des éléments à une liste Python**. Dans ce cas, on utilise l’opérateur Python `+`. La concaténation de listes correspond à peu de choses près à l’utilisation de la méthode `extend()`, à la différence près que la concaténation crée une nouvelle liste au lieu de modifier la liste « sur place ». En guise d’exemple, créons deux listes et ajoutons la seconde à la première. Comme **l’opération renvoie une nouvelle liste**, la valeur de retour est affectée à une nouvelle liste : ```Python # List of guys guys = [‘Jim’, ‘Jack’] # List of gals gals = [‘Molly’, ‘Mary’] # Concatenate both lists folks = guys + gals # Show that it worked assert folks == [‘Jim’, ‘Jack’, ‘Molly’, ‘Mary’] ``` En arrière-plan, **l’opérateur de concaténation appelle la méthode `__add__()`**. Les expressions `guys + gals` et `guys.__add__(gals)` sont ici équivalentes : ```Python # Show that both expressions return the same result assert guys + gals == guys.__add__(gals) ``` Si vous connaissez les [opérateurs Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-python/), vous vous en doutez peut-être déjà : **la concaténation de listes supporte aussi l’assignation augmentée**. On utilise l’opérateur `+=` pour ajouter des éléments à une liste « sur place » : ```Python # Shopping list groceries = [‘Milk’, ‘Bread’, ‘Eggs’] # Add butter groceries += [‘Butter’] # Show that it worked assert groceries == [‘Milk’, ‘Bread’, ‘Eggs’, ‘Butter’] ``` L’opérateur `+=` appelle la méthode `__iadd__()`, où le « i » signifie « in-place », pour « sur place ». Comme pour la méthode `extend()`, **le récepteur de la méthode est modifié directement**. Les lignes suivantes sont donc équivalentes : - `groceries = groceries + [‘Butter’]` - `groceries += [‘Butter’]` - `groceries.__iadd__([‘Butter’])` - `groceries.extend([‘Butter’])` Mieux vaut rester prudent lors de l’utilisation d’opérateurs de concaténation de listes pour ajouter un élément unique. **Un élément unique doit aussi être contenu dans une liste**, sinon il risque se passer une décompression d’itérable : ```Python # List of cities cities = [‘London’, ‘Paris’] # Attempt to add city; likely not what you intended cities += ‘Rome’ # String is unpacked into individual letters assert cities = [‘London’, ‘Paris’, ‘R’, ‘o’, ‘m’, ‘e’] ``` **L’utilisation d’une liste à un seul élément** aura probablement pour effet d’ajouter une ville supplémentaire à la liste : ```Python # List of cities cities = [‘London’, ‘Paris’] # Create a single-element list cities += [‘Rome’] # Now the entire string is added assert cities = [‘London’, ‘Paris’, ‘Rome’] ``` ## Ajouter des éléments à une liste en Python avec l’opérateur Slice Les Slices sont **une fonction Python qui permet de sélectionner des éléments d’une liste qui se suivent**. La syntaxe de Slice correspond à la célèbre fonction `range()` : ```Python # The `slice()` function constructs a new `slice` object slice(start, stop, step=1) ``` Il existe aussi **une notation abrégée pour créer des objets Slice** en combinaison avec l’opérateur d’index `[]` : ```Python # Select items of list lst[start:stop:step] ``` **Un objet Slice peut être utilisé à la place d’un index numérique** pour sélectionner plusieurs éléments d’une séquence : ```Python people = [‘Jim’, ‘John’, ‘Mary’, ‘Jack’] # Select elements between index `1` (inclusive) and `3` (exclusive) assert people[1:3] == [‘John’, ‘Mary’] # Select every other element assert people[::2] == [‘Jim’, ‘Mary’] ``` En **combinaison avec des affectations**, les Slices peuvent être utilisés comme alternative aux méthodes `list()`append(), `extend()` et `insert()` :
Méthode `list` Opérateur Slice correspondant Explication
`lst.append(element)` `lst[len(lst)+1 :] = [element]` Ajouter un élément à la fin d’une liste
`lst.extend([elements])` `lst[len(lst)+1 :] = [elements]` Ajouter plusieurs éléments à la fin d’une liste
`lst.insert(index, element)` `lst[index:index] = [element]` Ajouter un élément avant l’index donné
Pour comprendre le fonctionnement, voyons d’abord **comment affecter un élément de liste par index numérique**. Un seul élément de la liste est alors effacé : ```Python # List of groceries groceries = [‘Milk’, ‘Bread’, ‘Eggs’] # Overwrite element at index `1` groceries[1] = ‘Fruit’ # Show that it worked assert groceries == [‘Milk’, ‘Fruit’, ‘Eggs’] ``` Que faire maintenant si nous cherchons à **insérer un élément par affectation d’index** ? Nous utilisons un Slice qui contient l’index souhaité comme valeur `start` et `stop`. Pour que l’assignation Slice fonctionne, il faut impérativement une liste à droite du signe égal : ```Python # List of groceries groceries = [‘Milk’, ‘Bread’, ‘Eggs’] # Insert element before index `1` groceries[1:1] = [‘Fruit’] # Show that it worked assert groceries == [‘Milk’, ‘Fruit’, ‘Bread’, ‘Eggs’] ``` Cette astuce permet même **d’insérer plusieurs éléments à la fois dans une liste Python**, ce qui est impossible avec la méthode `insert()` : ```Python # List of groceries groceries = [‘Milk’, ‘Bread’, ‘Eggs’] # Insert elements before index `1` groceries[1:1] = [‘Fruit’, ‘Butter’] # Show that it worked assert groceries == [‘Milk’, ‘Fruit’, ‘Butter’, ‘Bread’, ‘Eggs’] ``` **Les assignations Slice permettent d’effacer de manière sélective les éléments d’une liste**. Dans l’ensemble, Slice reste une méthode très flexible qui a toute sa place dans la boîte à outils de toute personne qui développe en Python. ## Ajouter des éléments Python à une liste avec List Comprehension Une façon courante sous Python pour ajouter des éléments à une liste consiste à **remplir une nouvelle liste avec des éléments**. L’approche standard, qui fonctionne en Python comme dans la plupart des langages de programmation, est la suivante : 1. Créer une liste vide ; 2. Créer des éléments en boucle ; 3. Étendre la liste avec l’élément créé. À titre d’exemple, voyons comment **générer la liste des dix premiers carrés** : ```Python # Empty list to be filled squares = [] # Successively create numbers 0..9 for n in range(10): # Compute squared number squared = n * n # Append squared number to list squares.append(squared) # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` Il existe cependant une meilleure approche en Python. Nous utilisons ce que l’on appelle une **List Comprehension** pour créer la liste sans boucle `for` ni variable de liste vide : ```Python # Create first ten square numbers squares = [n ** 2 for n in range(10)] # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` Malgré leur élégance, les List Comprehensions **ne sont adaptées que pour remplir une nouvelle liste**. Pour étendre une liste existante, il faut recourir aux méthodes explicitées plus haut. Conseil Avec [Deploy Now](https://www.ionos.fr/hebergement/deploy-now "Deploy Now : déploiement de site Web ou d’appli via GitHub par IONOS") par IONOS, déployez vos sites Internet et vos applis avec GitHub ! This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/ajout-delement-a-une-liste-python/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/ajout-delement-a-une-liste-python/) for AI/LLM consumption.