Itérer sur des listes

Parcourir une liste — visiter chaque élément un par un — est l'une des opérations les plus courantes en Python. Ce chapitre couvre toutes les façons pratiques de le faire : les boucles for, les boucles while, enumerate(), zip(), break et continue, ainsi que les compréhensions de liste. Il explique également les pièges à éviter lorsqu'on modifie une liste pendant l'itération.

Pourquoi parcourir une liste ?

Une liste Python contient une séquence ordonnée d'éléments. Les boucles permettent d'agir sur chaque élément sans écrire une ligne de code par élément. Que vous additionniez des prix, filtriez des enregistrements ou transformiez des chaînes de caractères, une boucle est généralement le bon outil.

Parcourir avec une boucle for

La façon la plus simple et la plus lisible d'itérer sur une liste est la boucle for.

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

apple
banana
cherry

Python assigne chaque élément à fruit tour à tour, exécute le bloc indenté, puis passe à l'élément suivant. La boucle s'arrête automatiquement quand la liste est épuisée — aucune gestion d'index n'est nécessaire.

Parcourir avec range() et un index

Lorsque vous avez besoin à la fois de l'index et de la valeur, vous pouvez combiner range() avec len() :

colors = ['red', 'green', 'blue']
for i in range(len(colors)):
    print(i, colors[i])

0 red
1 green
2 blue

Cela fonctionne, mais enumerate() (présenté ensuite) est plus élégant pour ce cas.

Parcourir avec enumerate()

enumerate() associe chaque élément à son index et constitue l'approche idiomatique Python quand vous avez besoin des deux :

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Vous pouvez démarrer le compteur à un autre nombre en passant un second argument :

for index, fruit in enumerate(['apple', 'banana', 'cherry'], start=1):
    print(index, fruit)

1 apple
2 banana
3 cherry

Parcourir deux listes avec zip()

zip() associe les éléments de deux listes (ou plus) pour les itérer côte à côte :

names  = ['Alice', 'Bob', 'Carol']
scores = [92, 85, 78]

for name, score in zip(names, scores):
    print(name, '->', score)

Alice -> 92
Bob -> 85
Carol -> 78

Si les listes ont des longueurs différentes, zip() s'arrête à la plus courte. Utilisez itertools.zip_longest() si vous devez aller jusqu'à la fin de la liste la plus longue.

Parcourir avec une boucle while

Une boucle while continue de s'exécuter tant qu'une condition est True. Vous gérez l'index vous-même :

numbers = [10, 20, 30, 40, 50]
i = 0
while i < len(numbers):
    print(numbers[i])
    i += 1

10
20
30
40
50

Les boucles while sont utiles quand la condition d'arrêt n'est pas simplement « fin de liste » — par exemple, rechercher un élément et s'arrêter dès qu'il est trouvé.

Contrôler l'exécution de la boucle

break — Sortir prématurément

break arrête la boucle immédiatement. C'est utile quand vous avez trouvé ce que vous cherchiez et n'avez pas besoin de continuer à itérer :

fruits = ['apple', 'banana', 'cherry', 'date']
for fruit in fruits:
    if fruit == 'cherry':
        print('Found it!')
        break
    print(fruit)

apple
banana
Found it!

continue — Ignorer un élément

continue passe à l'itération suivante sans exécuter les lignes restantes du bloc courant :

numbers = [1, 2, 3, 4, 5, 6]
for n in numbers:
    if n % 2 == 0:
        continue        # skip even numbers
    print(n)

1
3
5

La clause else sur une boucle

Une boucle for ou while peut avoir un bloc else qui s'exécute quand la boucle se termine sans avoir atteint un break. C'est pratique pour les motifs « rechercher et signaler » :

target = 7
numbers = [1, 3, 5, 9]

for n in numbers:
    if n == target:
        print('Found', target)
        break
else:
    print(target, 'not in list')

7 not in list

Parcourir une tranche de liste

Vous pouvez itérer sur une partie d'une liste en la découpant :

items = ['a', 'b', 'c', 'd', 'e']
for item in items[1:4]:   # indices 1, 2, 3
    print(item)

b
c
d

Parcourir en sens inverse avec une tranche :

for item in items[::-1]:
    print(item)

e
d
c
b
a

Boucles imbriquées

Vous pouvez imbriquer des boucles for pour travailler avec des listes de listes ou calculer des combinaisons :

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

1 2 3 
4 5 6 
7 8 9 

La boucle interne effectue toutes ses itérations pour chaque itération unique de la boucle externe.

Les compréhensions de liste comme alternative aux boucles

Une compréhension de liste crée une nouvelle liste en appliquant une expression à chaque élément — c'est une alternative compacte et lisible à une boucle for qui construit une liste :

numbers = [1, 2, 3, 4, 5]

# for loop approach
squares = []
for n in numbers:
    squares.append(n ** 2)

# list comprehension — same result in one line
squares = [n ** 2 for n in numbers]

print(squares)

[1, 4, 9, 16, 25]

Vous pouvez ajouter une condition pour filtrer les éléments en même temps :

evens = [n for n in range(1, 11) if n % 2 == 0]
print(evens)

[2, 4, 6, 8, 10]

Erreur courante : modifier une liste pendant l'itération

Ne pas ajouter ou supprimer des éléments d'une liste dans une boucle for qui itère sur cette même liste. L'index interne de la boucle est basé sur la longueur d'origine, ce qui peut entraîner des éléments ignorés ou visités deux fois.

# BAD — skips items
numbers = [1, 2, 3, 4, 5]
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)   # mutates the list mid-loop
print(numbers)              # [1, 3, 5] may look correct here but...

Le motif sûr consiste à itérer sur une copie de la liste, ou à construire une nouvelle liste avec une compréhension :

numbers = [1, 2, 3, 4, 5]
numbers = [n for n in numbers if n % 2 != 0]
print(numbers)

[1, 3, 5]

Opérations de base sur les listes utilisées avec les boucles

Les sections ci-dessous récapitulent les méthodes de liste les plus souvent utilisées avec les boucles. Voir Méthodes de liste Python pour la référence complète.

Ajouter des éléments

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

[1, 2, 3, 4]

Supprimer des éléments

remove() supprime la première valeur correspondante et lève une ValueError si l'élément n'est pas trouvé.

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)

[1, 2, 4, 5]

Trier une liste

my_list = [3, 1, 4, 2, 5]
my_list.sort()
print(my_list)

[1, 2, 3, 4, 5]

sort() modifie la liste en place. Pour obtenir une copie triée sans modifier l'original, utilisez la fonction intégrée sorted(). Voir Trier des listes pour le tri en ordre inverse, le tri par clé, et plus encore.

Sujets connexes

• Listes Python — créer, indexer et découper des listes
• Boucles for Python — la référence complète de la boucle for
• Boucles while Python — syntaxe et motifs de la boucle while
• Compréhension de liste — construction de liste compacte en une ligne
• Méthodes de liste — append, extend, pop, insert, et plus
• Trier des listes — tri en place contre copies triées
• Supprimer des éléments de liste — remove, pop, del et clear
• Parcourir des dictionnaires — itérer sur des paires clé–valeur
• Parcourir des tuples — itérer sur des séquences immuables

Pratique