Itérer en arrière en Python

Itérer à rebours consiste à parcourir une séquence de son dernier élément au premier. Python propose plusieurs façons de procéder ; le choix dépend de vos besoins : récupérer uniquement les valeurs, modifier la séquence ou obtenir l’indice d’origine de chaque élément. Les exemples ci-dessous utilisent des listes, mais reversed() et le découpage en tranches fonctionnent aussi avec les chaînes de caractères et les tuples.

Parcourir une séquence à rebours avec reversed()

Utilisez reversed() pour lire une séquence de la fin vers le début sans la modifier. Cette fonction renvoie un itérateur : elle ne crée donc pas une seconde liste contenant les valeurs. La liste d’origine conserve son ordre.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

items = ["first", "second", "third"]
for item in reversed(items):
    print(item)

third
second
first

C’est généralement le meilleur choix lorsque vous souhaitez simplement traiter les valeurs d’une séquence à rebours. L’itérateur est consommé au fil des tours de boucle ; si vous devez le parcourir une nouvelle fois, appelez de nouveau reversed(items). La séquence doit permettre l’itération inverse.

Parcourir à rebours avec range() en Python

Utilisez range() si la boucle a besoin de positions numériques, par exemple pour modifier des éléments à l’aide de leur indice. Les arguments sont range(start, stop, step). Un pas négatif compte à rebours et la valeur de fin est exclue. Par exemple, range(10, 0, -1) produit les valeurs de 10 à 1 ; range(10, -1, -1) produit celles de 10 à 0.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

items = ["first", "second", "third"]
for index in range(len(items) - 1, -1, -1):
    print(index, items[index])

Le premier indice est len(items) - 1, c’est-à-dire la dernière position valide. La valeur de fin est -1 afin que la boucle inclue l’indice 0 avant de s’arrêter. Une erreur fréquente consiste à écrire range(len(items) - 1, 0, -1), ce qui omet l’indice 0, car range() n’inclut jamais sa valeur de fin.

Inverser une séquence avec le découpage en tranches

Une tranche avec un pas de -1, écrite items[::-1], crée une nouvelle liste dont les éléments sont dans l’ordre inverse. Vous pouvez ensuite parcourir cette liste ou la conserver pour plus tard.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

items = ["first", "second", "third"]
backward = items[::-1]
print(backward)

Contrairement à reversed(), le découpage en tranches alloue une copie inversée. C’est utile si vous devez conserver les valeurs dans cet ordre, mais la mémoire supplémentaire utilisée est proportionnelle à la longueur de la séquence. Choisissez reversed() pour simplement parcourir les éléments ; choisissez le découpage en tranches pour obtenir une séquence inversée distincte.

Utiliser une boucle while

Une boucle while vous donne un contrôle direct sur l’indice et sur les opérations effectuées entre deux itérations. Commencez par le dernier indice valide, traitez l’élément correspondant, puis décrémentez l’indice. Veillez à ce que la condition de la boucle inclue l’indice 0 et que l’indice change à chaque passage ; sinon, la boucle risque de s’arrêter trop tôt ou de ne plus avancer.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

items = ["first", "second", "third"]
index = len(items) - 1
while index >= 0:
    print(items[index])
    index -= 1

Cette méthode est utile lorsque la règle d’arrêt de la boucle ou la mise à jour des indices fait partie d’un algorithme plus vaste. Pour un simple parcours à rebours, reversed() est généralement plus court et exprime plus clairement l’intention. La forme avec while fonctionne aussi avec une liste vide : son indice initial vaut -1, donc le corps de la boucle ne s’exécute pas.

Conserver les indices d’origine avec enumerate()

enumerate() compte normalement à partir de zéro lorsqu’il parcourt un itérable. Pour associer les valeurs parcourues à rebours à leurs positions dans la liste d’origine, appliquez enumerate à reversed(items), puis convertissez chaque décalage inverse en indice d’origine.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

items = ["first", "second", "third"]
for reverse_offset, item in enumerate(reversed(items)):
    original_index = len(items) - 1 - reverse_offset
    print(original_index, item)

Le premier décalage inverse vaut 0 et correspond au dernier indice d’origine. Chaque décalage suivant correspond à la position précédente. Cette approche évite de créer une liste inversée et est pratique lorsque vous avez besoin à la fois des valeurs et de leurs positions d’origine. Si vous avez seulement besoin d’un indice pour rechercher ou affecter une valeur, la méthode avec range() est plus directe.

Choisir une méthode

Utilisez reversed(sequence) pour parcourir clairement et sans copie les valeurs dans l’ordre inverse. Utilisez range(len(sequence) - 1, -1, -1) si la boucle doit manipuler des indices. Utilisez sequence[::-1] si vous avez besoin d’une copie inversée distincte et que la mémoire supplémentaire vous convient. Utilisez une boucle while lorsque le contrôle personnalisé des indices est au cœur de l’algorithme. Combinez enumerate(reversed(sequence)) avec un calcul d’indice si vous avez besoin des valeurs dans l’ordre inverse et de leurs positions d’origine.

Ces mêmes choix s’appliquent aux chaînes de caractères, car une chaîne est une séquence : reversed(text) parcourt ses caractères à rebours, tandis que text[::-1] crée une chaîne inversée. Ces méthodes concernent l’ordre des séquences ; ne supposez pas qu’elles permettent de parcourir à rebours n’importe quel conteneur. Choisissez celle qui correspond au besoin de la boucle et tenez compte de la création éventuelle d’une copie et de l’accès aux indices d’origine.