Parcourir les tuples en Python

Parcourir un tuple vous permet de visiter chaque élément un à un et d'agir dessus. Parce que les tuples sont des séquences immuables — leur contenu ne peut pas changer — les itérer est sûr et simple. Cette page couvre toutes les techniques courantes : les boucles for, les boucles while, enumerate(), range(len()), zip(), la traversée de tuples imbriqués, et le contrôle de boucle avec break/continue.

Si vous débutez avec les tuples, lisez d'abord Python Tuples. Pour la syntaxe générale des boucles, consultez Python For Loops et Python While Loops.

Utiliser une boucle for

La façon la plus simple et la plus pythonique d'itérer sur un tuple est une boucle for. Python parcourt chaque élément dans l'ordre et l'assigne à la variable de boucle.

Parcourir un tuple avec une boucle for

Résultat :

1
2
3
4
5

La boucle se termine automatiquement lorsqu'elle atteint le dernier élément — aucune arithmétique d'indice n'est nécessaire.

Utiliser une boucle while

Une boucle while vous donne un contrôle manuel sur l'indice. Elle est utile lorsque vous devez avancer ou reculer de plus d'un pas, ou lorsque la condition d'arrêt dépend d'autre chose que la longueur du tuple.

Parcourir un tuple avec une boucle while

my_tuple = ('apple', 'banana', 'cherry')
i = 0

while i < len(my_tuple):
    print(my_tuple[i])
    i += 1

Résultat :

apple
banana
cherry

Incrémentez toujours i dans le corps de la boucle, sinon la boucle s'exécute indéfiniment.

Accéder à l'indice avec enumerate()

Lorsque vous avez besoin à la fois de la position et de la valeur, utilisez enumerate(). Il enveloppe chaque élément avec son indice à base zéro et retourne les deux ensemble.

Parcourir un tuple avec enumerate

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors):
    print(index, color)

Résultat :

0 red
1 green
2 blue

Vous pouvez commencer à compter à partir de n'importe quel nombre en passant un second argument :

Démarrer enumerate à partir de 1

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors, start=1):
    print(index, color)

Résultat :

1 red
2 green
3 blue

enumerate() est préféré à range(len()) lorsque vous avez besoin à la fois de l'indice et de la valeur, car il est plus lisible et évite l'étape d'indexation supplémentaire.

Accéder à l'indice avec range(len())

Un modèle plus ancien mais toujours valide utilise range(len()) pour générer les indices valides, puis accède à chaque élément par position.

Parcourir un tuple avec range et len

fruits = ('apple', 'banana', 'cherry')

for i in range(len(fruits)):
    print(i, fruits[i])

Résultat :

0 apple
1 banana
2 cherry

Cette approche est pratique lorsque vous devez comparer des éléments adjacents ou modifier une liste dérivée en fonction de la position, car l'indice et la valeur sont disponibles en même temps.

Itérer sur des tuples imbriqués

Un tuple peut contenir d'autres tuples. Utilisez une boucle for imbriquée pour accéder aux valeurs internes.

Itérer sur un tuple imbriqué (matrice)

matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

Résultat :

1 2 3 
4 5 6 
7 8 9 

Chaque itération de la boucle externe vous donne un tuple interne (row). La boucle interne parcourt ensuite ce tuple interne élément par élément.

Vous pouvez également décompacter le tuple interne directement dans l'en-tête de la boucle si la forme est fixe :

Décompacter les tuples internes lors du parcours

points = ((0, 0), (1, 2), (3, 4))

for x, y in points:
    print(f'x={x}, y={y}')

Résultat :

x=0, y=0
x=1, y=2
x=3, y=4

Cela rend le code presque lisible comme de l'anglais courant et évite les indices row[0] / row[1]. Pour en savoir plus sur le décompactage, consultez Unpack Tuples.

Parcourir deux tuples en parallèle avec zip()

zip() associe les éléments de deux (ou plusieurs) tuples par position et vous permet de les décompacter dans une seule boucle.

Parcourir deux tuples en parallèle

names = ('Alice', 'Bob', 'Carol')
scores = (95, 87, 92)

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

Résultat :

Alice 95
Bob 87
Carol 92

zip() s'arrête dès que le tuple le plus court est épuisé, de sorte que des longueurs différentes ne déclenchent pas d'erreur — elles sont silencieusement tronquées. Si vous avez besoin de toutes les paires et souhaitez combler les lacunes, utilisez plutôt itertools.zip_longest() de la bibliothèque standard.

Contrôle de boucle : break et continue

Arrêt anticipé avec break

break quitte la boucle immédiatement lorsqu'une condition est remplie.

Arrêter une boucle de tuple tôt avec break

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n == 4:
        break
    print(n)

Résultat :

1
2
3

La boucle affiche 1, 2, 3, puis s'arrête lorsqu'elle rencontre 4.

Ignorer des éléments avec continue

continue passe à l'itération suivante sans exécuter le reste du code dans le corps de la boucle.

Ignorer les nombres pairs avec continue

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n % 2 == 0:
        continue
    print(n)

Résultat :

1
3
5

Seuls les nombres impairs sont affichés ; les nombres pairs sont silencieusement ignorés.

Construire une liste à partir d'une boucle de tuple

Parce que les tuples sont immuables, vous ne pouvez pas les modifier en place. Un modèle courant consiste à itérer sur un tuple et à collecter les résultats dans une nouvelle liste.

Créer une liste de carrés à partir d'un tuple

numbers = (1, 2, 3, 4, 5)
squares = [n ** 2 for n in numbers]
print(squares)

Résultat :

[1, 4, 9, 16, 25]

La compréhension de liste itère sur le tuple comme une boucle for et est plus concise pour les transformations simples. Consultez Python Tuples et Tuple Methods pour en savoir plus sur l'utilisation des données de tuple.

Quand utiliser chaque technique

Pratique