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, 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 :

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 :

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’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 :

# 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() 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 :

# 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 :

# 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 :

# 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(). 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 exactement 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 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 :

# 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 :

# 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 :

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

Si vous connaissez les opérateurs 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 » :

# 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 :

# 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 :

# 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() :

# 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 [] :

# 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 :

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() :

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é :

# 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 :

# 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() :

# 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 :

# 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 :

# 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.