Python Add to List : ajout d’élément à une liste Python

Les listes sont des struc­tures de données fon­da­men­tales en in­for­ma­tique. De nombreux al­go­rithmes reposent sur la mo­di­fi­ca­tion de listes. Voici comment il est possible d’ajouter des éléments à une liste en Python.

Comment ajouter des éléments à une liste Python ?

Con­trai­re­ment aux tuples et aux chaînes de ca­rac­tères, les listes Python sont « mutables », c’est-à-dire des struc­tures de données mo­di­fiables. Il est possible d’ajouter des éléments à une liste Python, d’en supprimer, voire d’en modifier l’ordre. Il existe pour cela dif­fé­rentes approches, chacune ayant ses propres avantages et in­con­vé­nients.

Nous pré­sen­tons 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 con­ca­té­na­tion de listes ;
3. Ajouter des éléments à une liste Python avec Slice-Notation ;
4. Ajouter des éléments à une liste Python avec List Com­pre­hen­sion.

Ajouter des éléments à une liste avec les méthodes Python-list

En Python, la classe list sert de base à toutes les opé­ra­tions de liste. La classe définit une série de méthodes pour les objets de liste. Cela comprend trois méthodes qui con­vien­nent à l’ajout d’éléments à une liste :

Il est important de com­prendre que la mo­di­fi­ca­tion s’effectue « sur place » pour les trois méthodes men­tion­nées. Cela signifie que l’on modifie l’objet liste au lieu de créer et renvoyer une nouvelle liste. Par con­sé­quent, toutes ces méthodes renvoient None :

# 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() permet d’ajouter un élément unique à la fin d’une liste existante. Voici un exemple pour l’illustrer :

# 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’uti­li­sa­tion 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 :

# 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() fonc­tionne de la même manière que la méthode append(), à la seule dif­fé­rence que plusieurs éléments sont ajoutés à une liste existante. Reprenons l’exemple précédent pour mieux com­prendre :

# 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é­com­presse ses éléments. Cela peut conduire à une sortie étonnante lorsqu’on appelle une chaîne de ca­rac­tères :

# 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() fonc­tionne également :

# 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é­ci­sé­ment la raison d’être de la méthode Python-insert(). Celle-ci prend en compte un index numérique en plus de l’élément à insérer :

# 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 exac­te­ment un élément, cela entraîne forcément la création d’une liste imbriquée :

# 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 cor­rec­te­ment 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 :

# 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 con­ca­té­na­tion de listes Python

En plus des méthodes list vues ci-dessus, il est possible de faire une con­ca­té­na­tion de listes pour ajouter des éléments à une liste Python. Dans ce cas, on utilise l’opérateur Python +. La con­ca­té­na­tion de listes cor­res­pond à peu de choses près à l’uti­li­sa­tion de la méthode extend(), à la dif­fé­rence près que la con­ca­té­na­tion 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 :

# 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 con­ca­té­na­tion appelle la méthode __add__(). Les ex­pres­sions guys + gals et guys.__add__(gals) sont ici équi­va­lentes :

# Show that both expressions return the same result
assert guys + gals == guys.__add__(gals)

Si vous con­nais­sez les opé­ra­teurs Python, vous vous en doutez peut-être déjà : la con­ca­té­na­tion de listes supporte aussi l’as­sig­na­tion augmentée. On utilise l’opérateur += pour ajouter des éléments à une liste « sur place » :

# 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é di­rec­te­ment. Les lignes suivantes sont donc équi­va­lentes :

• groceries = groceries + [‘Butter’]
• groceries += [‘Butter’]
• groceries.__iadd__([‘Butter’])
• groceries.extend([‘Butter’])

Mieux vaut rester prudent lors de l’uti­li­sa­tion d’opé­ra­teurs de con­ca­té­na­tion 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é­com­pres­sion d’itérable :

# 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’uti­li­sa­tion d’une liste à un seul élément aura pro­ba­ble­ment pour effet d’ajouter une ville sup­plé­men­taire à la liste :

# 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é­lec­tion­ner des éléments d’une liste qui se suivent. La syntaxe de Slice cor­res­pond à la célèbre fonction range() :

# 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 com­bi­nai­son avec l’opérateur d’index [] :

# Select items of list
lst[start:stop:step]

Un objet Slice peut être utilisé à la place d’un index numérique pour sé­lec­tion­ner plusieurs éléments d’une séquence :

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 com­bi­nai­son avec des af­fec­ta­tions, les Slices peuvent être utilisés comme al­ter­na­tive aux méthodes list()append(), extend() et insert() :

Pour com­prendre le fonc­tion­ne­ment, voyons d’abord comment affecter un élément de liste par index numérique. Un seul élément de la liste est alors effacé :

# 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 main­te­nant si nous cherchons à insérer un élément par af­fec­ta­tion d’index ? Nous utilisons un Slice qui contient l’index souhaité comme valeur start et stop. Pour que l’as­sig­na­tion Slice fonc­tionne, il faut im­pé­ra­ti­ve­ment une liste à droite du signe égal :

# 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 im­pos­sible avec la méthode insert() :

# 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 as­sig­na­tions Slice per­met­tent 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 Com­pre­hen­sion

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 fonc­tionne en Python comme dans la plupart des langages de pro­gram­ma­tion, 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 :

# 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 Com­pre­hen­sion pour créer la liste sans boucle for ni variable de liste vide :

# 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 Com­pre­hen­sions ne sont adaptées que pour remplir une nouvelle liste. Pour étendre une liste existante, il faut recourir aux méthodes ex­pli­ci­tées plus haut.