Ctrl+K

Les listes

13. Les listes#

13.1. Les bases#

Les listes sont des séquences mutables, on peut modifier les valeurs qu’elles contiennent, en supprimer ou en ajouter. Elles sont représentées par des crochets [] contenant des valeurs séparées par des virgules. Les valeurs peuvent être de types différentes. Comme toute séquence, pour accéder aux valeurs qu’elles contiennent on utilise la notation crochet. Voici un exemple dans lequel on définie des listes, où l’on accède à des valeurs et où on les modifie.

liste = ['a', 3.14, 38.86]    # Création d'une liste de 3 valeurs
print(liste)

print(liste[1]+liste[2])      # Utilisation de valeurs contenues référencées par leurs indices
liste[0] = "zero"             # Modification d'une valeur
print(liste)

vide = []                     # Création d'une liste vide
print(vide)

['a', 3.14, 38.86]
42.0
['zero', 3.14, 38.86]
[]

Les listes étant mutables, elles disposent d’un grand nombre de méthodes pour les traitements courant. Entre autres :

  • ajout en fin de liste d’un élément, append ;

  • insertion d’un élement à une certaine position, insert(position, valeur) ;

  • retrait d’un élement à une certaine position, pop(position) ;

  • tri des élements (possible uniquement si tous les élements sont comparables entre eux), sort() ;

  • reversement de la liste, reverse().

liste = [3, 4, 3.0]
print(liste)
liste.append("n")           # ajout d'un élément en fin de liste
print(liste)

[3, 4, 3.0]
[3, 4, 3.0, 'n']

liste = [3, 4, 3.0]
print(liste)
liste.insert(0, "zero")     # insertion d'un élément, ici en position 0 (début de liste)
print(liste)

[3, 4, 3.0]
['zero', 3, 4, 3.0]

liste = [3, 4, 3.0]
print(liste)
print(liste.pop(0))         # suppression de l'élément d'indice 0,
print(liste)                # ce dernier est retourné par la méthode, on peut l'afficher

[3, 4, 3.0]
3
[4, 3.0]

liste = [3, 4, 3.0]
print(liste)
print(liste.pop())         # pop sans paramètre supprime le dernier élément de la liste.
print(liste)

[3, 4, 3.0]
3.0
[3, 4]

liste = [3, 4, 3.0]
print(liste)
liste.sort()               #  tri des éléments
print(liste)

[3, 4, 3.0]
[3, 3.0, 4]

liste = [3, 4, 3.0]
print(liste)
liste.reverse()            # renversement des valeurs
print(liste)

[3, 4, 3.0]
[3.0, 4, 3]

13.2. Exercices#

Question : Écrivez une fonction add qui prend en paramètre une liste l et ajoute un élément e à la fin de cette liste. A-t-on besoin du mot clef return dans la fonction ?

def add(l, e):
    pass
    
t = [0, 2, 7, 1]
print(t)
add(t, 10)
print(t)

[0, 2, 7, 1]
[0, 2, 7, 1]

Voici une correction possible.

Il n’est pas nécessaire d’utiliser le mot clef return. La variable t est liée à une liste en mémoire. Quand on appelle la fonction add(t, 10), on lie la variable locale t, le paramètre de la fonction à cette même liste en mémoire. Lors de l’appel de la fonction append on modifie alors cette l’unique liste qui existe en mémoire. La fonction ne calcule pas une valeur qu’il est nécessaire de renvoyer. Notre fonction fait quelque chose dans la mémoire, elle modifie la liste.

def add(l, e):
    l.append(e)

Question : Écrivez une fonction complete qui prend en paramètre une liste l et une séquence s. La fonction ajoute à la fin de l tous les éléments de la séquence s.

def complete(l, s):
    pass

u = [0, 3, 7, 1]
v = [10, 2, 98]
print(u)
complete(u, v)
print(u)

[0, 3, 7, 1]
[0, 3, 7, 1]

Voici une correction possible.

def complete(l, s):
    for e in s:
        l.append(e)

Question : Que se passe-t-il si l’on exécute les instructions suivantes ? Cela pose-t-il un problème ?

u = [0, 3, 7, 1]
complete(u, [2, 3] )
complete(u, (83, 3) )
complete(u, "what" )

Voici une correction possible.

Cela ne pose aucun problème car [2, 3], (83, 3) ou "what" sont des séquences. Notre fonction complete itère sur les éléments de la séquence et les ajoute un à un à la liste u. C’est tout à fait possible, ce d’autant qu’une liste peut contenir des types différents.

À la fin de l’exécution, u contiendra les valeurs suivantes : [0, 3, 7, 1, 2, 3, 83, 3, "w", "h", "a", "t"].

Question : On suppose que l’on dispose de deux listes de même taille. Écrivez une fonction fusion qui prend deux listes de même taille et les renvoie une nouvelle liste, contenant des couples (tuple avec deux valeurs), comme sur l’exemple suivant.

l1 = [42, 35, 76]
l2 = [2, 31, 219]
f = fusion(l1, l2)

Après ces instructions, f vaudra : [(42, 2), (35, 31), (76, 219)].

Indice : Besoin d’un indice ?

Si l’on doit oppérer sur deux listes à la fois, alors il faut itérer sur les indices des listes (nous verrons une autre solution plus tard). Il faut donc

  1. créer une nouvelle liste vide ;

  2. pour chaque indice i, ajouter dance cette nouvelle liste un couple composé des ièmes éléments des deux listes données en paramètre

  3. pour terminer il faut, renvoyer la nouvelle liste.

def fusion(u, v):
    pass

l1 = [42, 35, 76]
l2 = [2, 31, 219]
f = fusion(l1, l2)
f

Voici une correction possible.

def fusion(u, v):
    n = []
    for i in range(len(u)):
        n.append( (u[i],v[i]) )
    return n

Question : On veut filter tous les éléments négatifs d’une liste. Écrivez une fonction filter_negative qui prend en paramètre une liste de nombres et renvoie une nouvelle liste ne contenant aucun élément négatif.

l = [-1, 0, 2, 9, -10, 3]
l2 = filter_negative(l)

La liste l2 vaudra [0, 2, 9, 3].

def filter_negative(l):
    pass

l = [-1, 0, 2, 9, -10, 3]
l2 = filter_negative(l)

Voici une correction possible.

def filter_negative(l):
    n = []
    for e in l:
        if e >= 0:
            n.append(e)
    return n

Question : Cette fois ci on ne veut pas créer une nouvelle liste mais modifier la liste actuelle pour supprimer les valeurs négatices. Écrivez une fonction remove_negative qui prend en paramètre une liste de nombres et supprime de cette liste les éléments négatifs.

l = [-1, 0, 2, 9, -10, 3]
remove_negative(l)

La liste l vaudra [0, 2, 9, 3].

Indice : On ne peut pas utiliser une boucle for pour parcourir une liste que l’on modifie, il est nécessaire d’utiliser une boucle while.

Pas d’inquiétude si vous ne parvenez pas à réaliser cette question, nous la traiterons en cours. Passez à la suite.

13.3. Listes en compréhension#

Python dispose d’une notation très efficace pour créer des listes suivants un schéma : les listes en compréhension. Il s’agit de définir la façon dont est générée chaque élément. Voici un premier exemple pour créer la liste des entiers de 1 à 10.

liste=[i for i in range(1,11)]
print(liste)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

On indique que l’on va ajouter l’élément i pour chaque valeur que prend i dans le générateur range(1,11). Le résultat est donc identique à ce que l’on aurait obtenu avec les instructions suivantes.

liste=[]
for i in range(1,11):
    liste.append(i)
print(liste)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Plutôt que d’ajouter la valeur i dans la liste, nous pouvons ajouter le résultat d’un calcul.

liste=[i for i in range(1,11)]
liste2=[i*i for i in liste]      # i prend toutes les valeurs contenues dans liste q'il élève au carré pour créer liste2
print(liste2)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

liste = [i for i in range(1,11)]
liste2=[]                       # Ou autrement
for i in liste:
    liste2.append(i*i)
print(liste2)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Il est possible de filtrer certaines des valeurs et de n’ajouter que celle qui vérifie une certaine condition. Ici, on ajoute que les valeurs impaires.

liste = [i for i in range(1,11)]
liste3=[i*i for i in liste if i % 2 == 1]
print(liste3)

[1, 9, 25, 49, 81]

13.4. Listes de listes#

Python ne dispose pas dans la bibliothèque standard d’un type matrice mais il est possible de le représenter en utilisant des listes de listes. Autrement dit, une matrice est une liste de lignes.

On peut alors accéder aux différentes valeurs de la matrice en utilisant deux fois la notation crochets. La première paire de crochets permet de sélectionner une ligne, la seconde permet de sélectionner un élément de cette ligne (l’indice est donc le numéro de la colonne).

matrix=[[1,2],[3,4],[5,6]]
print(matrix)
print(matrix[1][0])

[[1, 2], [3, 4], [5, 6]]
3

Il est également possible de générer des matrices avec la notation en compréhension.

matrix=[[i for i in range(3)] for j in range(3)]
print(matrix)

[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
Contenu