\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\)

Vidéo 25 : La méthode append¶

`append` : adjoindre un élément à une liste¶

La méthode append modifie une liste en lui ajoutant un élément à sa fin. Exemple :

L = [65, 31, 9]
print(L)
print("taille de L :", len(L))
print()
L.append(81)
print(L)
print("taille de L :", len(L))

[65, 31, 9]
taille de L : 3

[65, 31, 9, 81]
taille de L : 4

Lignes 5, 11 : l’élément 81 est ajouté à la fin de la liste.
Lignes 9, 12 : on voit aussi que la taille de la liste a changé.
Lignes 5 et 6 : bien qu’ayant changée, la liste est toujours référencée par L.

On notera la syntaxe particulière de append utilisant un point (« la notation suffixe ») : chaque liste L admet un « attribut » append que l’on obtient par L.append et qui s’utilise comme une fonction.

La méthode append ne renvoie rien :

L = [65, 31, 9]
print(L)
x = L.append(81)
print(L)
print(x)

[65, 31, 9]
[65, 31, 9, 81]
None

Ligne 3 : le membre de droite est un appel de la méthode append. Le membre de gauche référence le retour de cet appel.
Ligne 8 : on observe qu’une fois l’appel à append effectué, x vaut None autrement dit rien.

Ainsi, contrairement à ce que l’on pourrait imaginer, L.append(truc) ne représente pas la liste L complétée par truc.

Adjoindre plusieurs éléments¶

Un unique appel à la méthode append ne permet pas d’ajouter plusieurs éléments. Pour ajouter plusieurs éléments, il faut appeler autant de fois la méthode append :

L = [65, 31, 9]
L.append(81)
L.append(100)
print(L)

5	[65, 31, 9, 81, 100]

Liste construite depuis la liste vide¶

Pour créer une liste d’éléments vérifiant une certaine propriété P, on procède souvent ainsi :

on crée une liste L, initialement vide,
on garnit successivement L d’éléments vérifiant P en utilisant la méthode append.

Exemple¶

Étant donné une liste t d’entiers, on veut extraire de t la liste L des entiers \(x\) tels que \(x\geq 42\).

Solution :

t = [65, 31, 9, 32, 81, 82, 46, 12]
L= []
for z in t:
    if z >= 42:
        L.append(z)
print(L)

7	[65, 81, 82, 46]

Ligne 2 : on crée une liste vide à laquelle on va adjoindre les éléments de L qui conviennent.
Lignes 3-5 : on parcourt la liste t.
Ligne 4 : on teste si l’élément courant vérifie la condition P.
Lignes 4-5 : si un élément la vérifie, l’élément est placé à la fin de la liste L.

Construction de petites listes¶

Pour construire de petites listes, ayant jusqu’à 3 ou 4 éléments, il est souvent plus simple de l’écrire directement avec ses éléments entre crochets plutôt que de la construire depuis la liste vide et après applications répétées de la méthode append.

Par exemple, on dispose de deux variables entières u et v et on veut regrouper dans une liste L ces éléments en sorte que l’élément ayant la plus petite valeur soit au début de la liste, ou ne mettre qu’un seul élément dans la liste si les deux éléments sont identiques. Par exemple,

si u = 42 et v = 42 alors L = [42] ;
si u = 81 et v = 42 alors L = [42, 81].

Le problème peut se résoudre ainsi :

u = 81
v = 42

if u == v:
    L = [u]
else:
    if u < v:
        L = [u, v]
    else:
        L = [v, u]

Il est maladroit d’utiliser append comme dans le code ci-dessous :

u = 81
v = 42

L = []

if u == v:
    L.append(u)
else:
    if u < v:
        L.append(u)
        L.append(v)
    else:
        L.append(v)
        L.append(u)

print(L)

Vidéo 25 : La méthode append