Inverser des chaînes en Python : un guide complet

Inverser une chaîne consiste à changer l'ordre de ses caractères afin que le dernier devienne le premier, et ainsi de suite. Python offre plusieurs façons de le faire, chacune avec des compromis différents en termes de lisibilité, de performance et d'utilisation de la mémoire.

Ce chapitre couvre :

• Le one-liner idiomatique utilisant la notation de slice ([::-1])
• reversed() combiné avec join()
• Une inversion de liste en place
• Une approche récursive (utile pour apprendre, pas pour la production)
• Des cas d'usage pratiques : détection de palindromes et inversion de l'ordre des mots

Les chaînes Python sont immuables — aucune de ces méthodes ne modifie la chaîne d'origine ; elles retournent toutes une nouvelle chaîne.

Méthode 1 : Notation de slice (recommandée)

La façon la plus idiomatique en Python d'inverser une chaîne est le slice étendu [::-1]. Le slice en trois parties [start:stop:step] prend par défaut start et stop sur toute la chaîne s'ils sont omis, et un pas de -1 parcourt chaque caractère en sens inverse.

Cela fonctionne sur toute séquence — listes, tuples — pas uniquement les chaînes. Comme le slice est implémenté en C dans CPython, c'est l'option la plus rapide en pratique.

sentence = "Python is great"
print(sentence[::-1])  # taerg si nohtyP

Pour approfondir la syntaxe start/stop/step, consultez le chapitre Slicing Strings.

Méthode 2 : reversed() et join()

La fonction intégrée reversed() renvoie un itérateur qui produit les caractères de la fin vers le début. ''.join() rassemble ces caractères dans une nouvelle chaîne.

Quand préférer ceci au slicing

reversed() est plus explicite quant à l'intention — on peut lire « joindre les caractères inversés de cette chaîne ». Certaines équipes le préfèrent lors des revues de code car il ne laisse aucune ambiguïté sur ce que signifie le slice vide [::-1]. En termes de performance, le slicing est environ 5× plus rapide pour des longueurs de chaînes typiques, car il évite le surcoût de l'itérateur.

Méthode 3 : Boucle for

Vous pouvez itérer sur une chaîne en sens inverse et construire une nouvelle chaîne caractère par caractère. Cette approche est verbeuse mais rend l'algorithme visible — utile dans un contexte d'apprentissage.

Remarque sur la concaténation de chaînes dans une boucle

Chaque += crée un nouvel objet string car les chaînes sont immuables. Pour de très longues chaînes, c'est lent — temps O(n²). Si vous devez construire une chaîne inversée caractère par caractère, collectez les caractères dans une liste et joignez à la fin :

string = "hello world"
chars = []
for char in reversed(string):
    chars.append(char)
reversed_string = ''.join(chars)
print(reversed_string)  # dlrow olleh

En pratique, utilisez le slicing — mais comprendre la version avec boucle est utile lorsque vous devez appliquer un filtrage ou une transformation lors de l'inversion.

Méthode 4 : list.reverse()

Convertissez la chaîne en liste de caractères, appelez la méthode .reverse() en place, puis rejoignez :

string = "hello"
chars = list(string)
chars.reverse()          # mutates the list in place
reversed_string = ''.join(chars)
print(reversed_string)  # olleh
print(string)           # hello (original unchanged)

Cela consomme plus de mémoire que l'approche par slice car une copie complète de la liste est créée, mais c'est explicite et facile à lire. La méthode .reverse() est documentée dans Python string methods.

Méthode 5 : Récursion

Une fonction récursive s'appelle elle-même avec une version plus courte de la chaîne jusqu'à atteindre le cas de base (chaîne vide) :

Attention : limite de profondeur de récursion

La limite de récursion par défaut de Python est 1000 (sys.getrecursionlimit()). Une chaîne de plus de ~990 caractères lèvera une RecursionError. N'utilisez cette approche qu'à des fins de démonstration ; préférez le slicing ou reversed() dans le code de production.

Cas d'usage pratiques

Vérification des palindromes

Un palindrome se lit de la même façon de gauche à droite et de droite à gauche. Inverser et comparer est la vérification la plus simple :

def is_palindrome(text):
    cleaned = text.lower().replace(" ", "")
    return cleaned == cleaned[::-1]

print(is_palindrome("racecar"))                    # True
print(is_palindrome("hello"))                      # False
print(is_palindrome("A man a plan a canal Panama")) # True

Inverser l'ordre des mots dans une phrase

Inverser toute la chaîne est différent d'inverser l'ordre des mots. Pour retourner l'ordre des mots, divisez en liste et inversez-la :

sentence = "Hello World Python"
reversed_words = " ".join(sentence.split()[::-1])
print(reversed_words)  # Python World Hello

Consultez Modify Strings pour davantage de techniques de transformation de chaînes.

Quelle méthode utiliser ?

Pour presque tout code en production, string[::-1] est le bon choix : c'est concis, rapide et immédiatement reconnaissable par tout développeur Python.

Pratique