SunuLab
Notre savoir
SunuCode/ Parcours
CoursIntermédiaire13 min de lecture

Les listes

Ranger plusieurs valeurs dans une seule variable, les parcourir, les modifier, les trier

§1.Le problème que les listes résolvent

Imagine que tu veuilles stocker les notes d'une classe de trente élèves. Avec ce que tu sais, il te faudrait trente variables : note1, note2, note3… Et pour calculer la moyenne, trente additions écrites à la main. Ajouter un élève voudrait dire réécrire le programme.

Une LISTE règle ça : une seule variable qui contient autant de valeurs que tu veux, dans un ordre défini, que tu peux parcourir avec une boucle.

Bonne nouvelle : tu connais déjà presque toute la notation. Index à partir de 0, index négatifs, tranches, len(), parcours par for, opérateur in — tout ce que tu as appris sur les chaînes s'applique à l'identique.

Créer et lire une liste
python
notes = [12, 8, 15, 17, 9]
 
print(notes)
print(notes[0])       # le premier
print(notes[-1])      # le dernier
print(len(notes))     # combien d'éléments
print(notes[1:3])     # une tranche
Résultat : [12, 8, 15, 17, 9] 12 9 5 [8, 15]

Les crochets servent à deux choses : créer la liste, et atteindre un élément. Le contexte lève l'ambiguïté.

§3.La grande différence avec les chaînes : c'est MODIFIABLE

Une chaîne est immuable — tu ne peux pas changer une de ses lettres. Une liste, si. On dit qu'elle est MUTABLE.

C'est ce qui rend les listes si utiles, et c'est aussi ce qui provoque les bugs les plus déroutants pour un débutant, comme tu le verras plus bas.

Modifier une liste
python
notes = [12, 8, 15]
 
notes[1] = 10          # remplacer
notes.append(20)       # ajouter à la fin
notes.insert(0, 5)     # insérer en position 0
print(notes)
 
notes.remove(15)       # retirer LA VALEUR 15
dernier = notes.pop()  # retirer et récupérer le dernier
print(notes, dernier)
Résultat : [5, 12, 10, 15, 20] [5, 12, 10] 20

Attention à la nuance : remove() cherche une VALEUR, pop() retire à une POSITION. Confondre les deux est une erreur classique.

§5.Les méthodes de listes à connaître

.append(x)
Ajoute x à la fin. C'est de loin la plus utilisée : elle sert à construire une liste petit à petit.
.insert(i, x)
Insère x à la position i, en décalant le reste vers la droite.
.remove(x)
Retire la PREMIÈRE occurrence de la valeur x. Lève une ValueError si x est absent.
.pop(i)
Retire l'élément à la position i et le RENVOIE. Sans argument, retire le dernier.
.index(x)
Renvoie la position de la première occurrence de x.
.count(x)
Compte combien de fois x apparaît.
.sort() et sorted()
sort() trie la liste SUR PLACE et ne renvoie rien. sorted(liste) laisse l'original tranquille et renvoie une nouvelle liste triée. Choisis en fonction de ce que tu veux préserver.
Manipule une liste
Chargement de l'éditeur Python…

§8.Parcourir une liste

Comme pour les chaînes, deux façons — et la première est presque toujours la bonne. On ne passe par les index que si on a besoin de la POSITION.

Quand tu as besoin des deux à la fois, la valeur et sa position, Python offre enumerate() qui te donne les deux d'un coup.

Trois parcours
python
notes = [12, 8, 15]
 
# Sur les valeurs — à privilégier
for n in notes:
    print(n)
 
# Par les index — quand la position compte
for i in range(len(notes)):
    print(i, notes[i])
 
# Les deux à la fois
for i, n in enumerate(notes):
    print("Élève", i + 1, ":", n)
Résultat : 12 8 15 0 12 1 8 2 15 Élève 1 : 12 Élève 2 : 8 Élève 3 : 15
Le motif de l'accumulateur, appliqué aux listes

Construire une nouvelle liste à partir d'une autre est l'une des opérations les plus fréquentes.

python
notes = [12, 8, 15, 17, 9]
 
# Filtrer
reussies = []
for n in notes:
    if n >= 10:
        reussies.append(n)
print(reussies)
 
# Transformer
doublees = []
for n in notes:
    doublees.append(n * 2)
print(doublees)
Résultat : [12, 15, 17] [24, 16, 30, 34, 18]

§11.Les compréhensions de listes

Les deux boucles ci-dessus suivent un schéma si courant que Python offre une écriture condensée : la COMPRÉHENSION de liste.

Elle se lit presque comme une phrase en français : « la liste des n × 2, pour chaque n dans notes, si n est supérieur à 10 ».

Utilise-la quand elle rend le code plus clair — pas quand elle le rend plus court au prix de la lisibilité. Une compréhension qui tient sur trois lignes et contient deux conditions est moins lisible qu'une boucle honnête.

La même chose, en compréhension
python
notes = [12, 8, 15, 17, 9]
 
reussies = [n for n in notes if n >= 10]
doublees = [n * 2 for n in notes]
carres = [x * x for x in range(1, 6)]
 
print(reussies)
print(doublees)
print(carres)
Résultat : [12, 15, 17] [24, 16, 30, 34, 18] [1, 4, 9, 16, 25]

La structure est toujours la même : [ ce_qu_on_garde for element in source if condition ]. La condition est facultative.

La démonstration du piège
python
a = [1, 2, 3]
 
b = a              # même objet !
b.append(4)
print(a)
 
c = list(a)        # vraie copie
c.append(5)
print(a)
print(c)
Résultat : [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4, 5]

La première liste a été modifiée sans qu'on la touche directement. C'est la source d'innombrables bugs — pense à copier dès qu'une fonction reçoit une liste qu'elle ne doit pas altérer.

§15.Les listes de listes

Une liste peut contenir des listes. C'est ainsi qu'on représente un tableau, une grille de jeu, ou les notes de plusieurs élèves dans plusieurs matières.

grille[1][2] se lit de gauche à droite : dans la grille, prends la ligne 1, puis dans cette ligne, la colonne 2.

Une grille
python
grille = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
 
print(grille[1][2])
 
for ligne in grille:
    total = sum(ligne)
    print(ligne, "->", total)
Résultat : 6 [1, 2, 3] -> 6 [4, 5, 6] -> 15 [7, 8, 9] -> 24
Statistiques d'une classe

Tout le chapitre en un programme. Modifie les notes et observe.

Chargement de l'éditeur Python…

À retenir

  • Une liste range plusieurs valeurs ordonnées ; l'indexation et les tranches marchent comme sur les chaînes.
  • Contrairement à une chaîne, une liste est MUTABLE : on peut la modifier en place.
  • append, insert, remove, pop, index, count, sort — la trousse de base.
  • sort() trie sur place et renvoie None ; sorted() renvoie une nouvelle liste. Ne les mélange jamais.
  • for x in liste pour les valeurs, enumerate(liste) quand il faut aussi la position.
  • Les compréhensions [x * 2 for x in liste if x > 0] condensent filtrage et transformation.
  • b = a ne copie PAS : utilise list(a) pour une copie indépendante.
Mots-cléslisteappendindextrancheparcourscompréhensiontrimutable