Invertire le stringhe in Python: una guida completa

Invertire una stringa significa cambiare l'ordine dei suoi caratteri in modo che l'ultimo carattere diventi il primo, e così via. Python offre diversi modi per farlo, ciascuno con diversi compromessi in termini di leggibilità, prestazioni e utilizzo della memoria.

Questo capitolo tratta:

• Il classico one-liner tramite notazione di slice ([::-1])
• reversed() combinato con join()
• Un'inversione in-place di una lista
• Un approccio ricorsivo (utile per l'apprendimento, non per la produzione)
• Casi d'uso pratici: rilevamento di palindromi e inversione dell'ordine delle parole

Le stringhe Python sono immutabili — nessuno di questi metodi modifica la stringa originale; tutti restituiscono una nuova stringa.

Metodo 1: Notazione di slice (consigliato)

Il modo più idiomatico in Python per invertire una stringa è lo slice esteso [::-1]. Lo slice in tre parti [start:stop:step] usa per impostazione predefinita l'intera stringa quando start e stop sono omessi, e un passo di -1 scorre all'indietro attraverso ogni carattere.

Questo funziona su qualsiasi sequenza — liste, tuple — non solo stringhe. Poiché lo slice è implementato in C all'interno di CPython, è in pratica l'opzione più veloce.

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

Per un approfondimento sulla sintassi start/stop/step, consulta il capitolo Slicing Strings.

Metodo 2: reversed() e join()

La funzione integrata reversed() restituisce un iteratore che produce i caratteri dalla fine all'inizio. ''.join() raccoglie quei caratteri in una nuova stringa.

Quando preferirlo allo slicing

reversed() è più esplicito riguardo all'intenzione — si legge come "unisci i caratteri invertiti di questa stringa." Alcuni team lo preferiscono nelle revisioni del codice perché non lascia ambiguità su cosa significhi lo slice vuoto [::-1]. Dal punto di vista delle prestazioni, lo slicing è circa 5 volte più veloce per lunghezze di stringa tipiche, poiché evita il sovraccarico dell'iteratore.

Metodo 3: Ciclo For

È possibile iterare su una stringa in ordine inverso e costruire una nuova stringa carattere per carattere. Questo approccio è verboso ma rende visibile l'algoritmo — utile nei contesti di apprendimento.

Una nota sulla concatenazione di stringhe in un ciclo

Ogni += crea un nuovo oggetto string perché le stringhe sono immutabili. Per stringhe molto lunghe questo è lento — tempo O(n²). Se è necessario costruire una stringa invertita un carattere alla volta, raccogliere i caratteri in una lista e unirli alla fine:

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

In pratica, usa lo slicing — ma capire la versione con il ciclo aiuta quando è necessario applicare filtri o trasformazioni durante l'inversione.

Metodo 4: list.reverse()

Converti la stringa in una lista di caratteri, chiama il metodo .reverse() in-place, poi riunisci:

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)

Questo occupa più memoria rispetto all'approccio con lo slice perché viene creata una copia completa della lista, ma è esplicito e facile da leggere. Il metodo .reverse() è documentato in Python string methods.

Metodo 5: Ricorsione

Una funzione ricorsiva chiama se stessa con una versione più corta della stringa fino al raggiungimento del caso base (stringa vuota):

Attenzione: limite di profondità della ricorsione

Il limite di ricorsione predefinito di Python è 1000 (sys.getrecursionlimit()). Una stringa più lunga di circa 990 caratteri genererà un RecursionError. Usa questo approccio solo a scopo dimostrativo; preferisci lo slicing o reversed() nel codice di produzione.

Casi d'uso pratici

Verifica dei palindromi

Un palindromo si legge allo stesso modo da sinistra a destra e da destra a sinistra. Invertire e confrontare è la verifica più semplice:

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

Inversione dell'ordine delle parole in una frase

Invertire l'intera stringa è diverso dall'invertire l'ordine delle parole. Per capovolgere l'ordine delle parole, dividere in una lista e invertirla:

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

Consulta Modify Strings per ulteriori tecniche di trasformazione delle stringhe.

Quale metodo scegliere?

Per quasi tutto il codice reale, string[::-1] è la scelta giusta: è conciso, veloce e immediatamente riconoscibile da qualsiasi sviluppatore Python.

Esercitazione