Algorithmique et programmation : les listes en Python

Ce que tu sais déjà. Tu connais les variables, les types (entier, flottant, booléen, chaîne), les conditions, les boucles for et while et les fonctions (Seconde — Python). Tu as déjà croisé des listes dans ce niveau : liste des premiers termes d’une suite (Première — Suites), valeurs et probabilités d’une loi (Première — Variables aléatoires). Ce chapitre les étudie pour elles-mêmes.

1. Créer une liste et accéder à ses éléments

Définition. Une liste est une suite ordonnée de valeurs, écrite entre crochets et séparées par des virgules. On peut la créer en extension, en écrivant tous ses éléments :

notes = [12, 15, 9, 17, 11]
vide = []            # une liste vide
print(len(notes))    # affiche 5 : la longueur (nombre d'éléments)

Indices. Chaque élément a une position, son indice, qui commence à 0. notes[0] est le premier élément, notes[4] le dernier. Les indices négatifs comptent à partir de la fin : notes[-1] est le dernier élément.

print(notes[0], notes[2], notes[-1])   # affiche 12 9 11
notes[2] = 10                           # on remplace le 3e élément
print(notes)                            # affiche [12, 15, 10, 17, 11]

Piège classique. notes[5] provoque une erreur IndexError : pour une liste de longueur $5$, le dernier indice est $4$, pas $5$.

→ S’entraîner : Exercice 1

2. Ajouter et supprimer des éléments

L = [4, 7, 1]
L.append(9)      # L vaut [4, 7, 1, 9]
L.pop(0)         # L vaut [7, 1, 9]
L.remove(1)      # L vaut [7, 9]
M = L + [0, 0]   # M vaut [7, 9, 0, 0]
print(L, M)      # affiche [7, 9] [7, 9, 0, 0]

Attention. append, pop et remove modifient la liste : on écrit L.append(9), pas L = L.append(9) (qui remplacerait L par la valeur spéciale None).

→ S’entraîner : Exercice 2

3. Générer une liste

Par ajouts successifs. On part d’une liste vide et on ajoute les éléments dans une boucle. C’est la méthode naturelle pour une suite définie par récurrence.

def termes(n):
    """Liste des termes u_0, ..., u_n de la suite u_0 = 1, u_(n+1) = 3 u_n - 1."""
    L = [1]
    for i in range(n):
        L.append(3 * L[-1] - 1)
    return L

print(termes(5))   # affiche [1, 2, 5, 14, 41, 122]

En compréhension. On décrit la liste par une formule, un peu comme en mathématiques ($\{n^2 \mid n \in \{0, \dots, 9\}\}$) :

carres = [n ** 2 for n in range(10)]
print(carres)      # affiche [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

pairs = [n for n in range(20) if n % 2 == 0]
print(pairs)       # affiche [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

La deuxième liste est construite avec une condition (un filtre) : on ne garde que les $n$ pairs.

Pour une suite définie explicitement, la compréhension est idéale : [5 - 2 * n for n in range(8)] donne les huit premiers termes de $u_n = 5 - 2n$.

→ S’entraîner : Exercice 3 · Exercice 4

4. Parcourir une liste

Deux façons de parcourir.

• Par les éléments : for x in L: — la variable x prend successivement chaque valeur de L.
• Par les indices : for i in range(len(L)): — la variable i prend les valeurs $0, 1, \dots$ et on accède à l’élément par L[i]. Indispensable quand on a besoin de la position, ou de deux listes à la fois.

def somme(L):
    s = 0
    for x in L:
        s = s + x
    return s

def maximum(L):
    m = L[0]
    for x in L:
        if x > m:
            m = x
    return m

def moyenne_ponderee(valeurs, coefficients):
    total = 0
    for i in range(len(valeurs)):
        total = total + valeurs[i] * coefficients[i]
    return total / somme(coefficients)

notes = [12, 15, 10, 17, 11]
print(somme(notes), maximum(notes))                 # affiche 65 17
print(moyenne_ponderee([12, 8, 16], [1, 2, 3]))     # affiche 12.666666666666666

Remarque. Python fournit déjà sum(L), max(L), min(L) et L.count(x) ; les réécrire soi-même est un excellent entraînement à l’algorithmique, et c’est ce qui est demandé dans les exercices.

→ S’entraîner : Exercice 5 · Exercice 6

5. Les listes au service des mathématiques

Statistiques et simulation. On stocke les résultats d’une simulation dans une liste, puis on les analyse.

from random import randint

def frequences_de(n):
    """Lance n fois un dé et renvoie la liste des fréquences des faces 1 à 6."""
    effectifs = [0, 0, 0, 0, 0, 0]
    for k in range(n):
        face = randint(1, 6)
        effectifs[face - 1] = effectifs[face - 1] + 1
    return [e / n for e in effectifs]

print(frequences_de(6000))   # six valeurs proches de 1/6 ≈ 0,167

Ici la liste effectifs sert de tableau de comptage : l’effectif de la face $f$ est rangé à l’indice $f - 1$.

Tableau de valeurs d’une fonction. xs = [k / 10 for k in range(11)] puis ys = [x ** 2 for x in xs] donnent les abscisses $0 ; 0{,}1 ; \dots ; 1$ et leurs images par $x \mapsto x^2$ — c’est ainsi qu’on prépare le tracé d’une courbe.

→ S’entraîner : Exercice 7 · Exercice 8

À retenir.

• L = [a, b, c] ; len(L) ; indices de 0 à len(L) - 1 ; L[-1] est le dernier élément.
• L.append(x) (ajout en fin), L.pop(i), L.remove(x) modifient la liste.
• Générer : boucle + append (récurrence) ou compréhension [f(n) for n in range(...) if condition].
• Parcourir : for x in L (valeurs) ou for i in range(len(L)) (indices).