HOWTO · Python

Controlla se una stringa è un palindromo in Python

Scopri sei modi per verificare se una stringa è palindroma in Python: slicing, reversed(), cicli, ricorsione, deque e normalizzazione del testo.

In questa pagina

Un palindromo si legge allo stesso modo da sinistra a destra e da destra a sinistra, come level. Il controllo di base confronta ogni carattere così com’è. Normalizza prima il testo se vuoi ignorare maiuscole, spazi o punteggiatura.

I controlli sulle stringhe come questo sono trattati nel nostro tutorial Python, nella sezione dedicata a stringhe e testo.

Verificare se una stringa Python è palindroma con lo slicing

Lo slicing di una stringa crea una copia invertita. La sezione [::-1] scorre la stringa dall’ultimo carattere al primo: confrontarla con l’originale è quindi un modo conciso per eseguire un controllo diretto. Sostituisci level con il valore che vuoi verificare.

word = "level"
print("Palindrome" if word == word[::-1] else "Not Palindrome")

Lo slicing si applica direttamente alle stringhe: non è un metodo delle liste. Questo confronto distingue tra maiuscole e minuscole e considera spazi e punteggiatura come caratteri ordinari. Richiede tempo lineare e crea una stringa invertita.

Verificare se una stringa Python è palindroma con reversed()

La funzione integrata reversed() restituisce un iteratore sui caratteri in ordine inverso. Usa join() per trasformare l’iteratore in una stringa da confrontare con l’originale.

word = "level"
reverse = "".join(reversed(word))
print(word == reverse)

reversed() non restituisce direttamente una stringa. L’unione dei caratteri e il confronto li percorrono, quindi questo approccio richiede tempo lineare; a differenza dello slicing, non crea prima una copia invertita tramite una sezione.

Verificare se una stringa Python è palindroma con un ciclo

Un ciclo può confrontare ogni carattere con quello corrispondente all’estremità opposta. L’indice a destra è len(word) - index - 1; controllare solo metà delle posizioni basta per esaminare tutte le coppie.

word = "radar"
result = True
for index in range(len(word) // 2):
    if word[index] != word[len(word) - index - 1]:
        result = False
        break
print(result)

Il ciclo si interrompe appena trova una coppia diversa. Il lavoro cresce in modo lineare con la lunghezza della stringa e non richiede di creare una copia invertita.

Verificare se una stringa Python è palindroma con la ricorsione

La ricorsione confronta i caratteri alle estremità, poi richiama la stessa funzione sulla sottostringa compresa tra loro. Una stringa con meno di due caratteri costituisce il caso base: non ci sono caratteri esterni diversi da individuare.

def is_palindrome(text):
    if len(text) < 2:
        return True
    return text[0] == text[-1] and is_palindrome(text[1:-1])

print(is_palindrome("level"))

Questa versione è utile per imparare a scomporre un problema in controlli più piccoli. Ogni chiamata crea una sottostringa tramite slicing, aggiungendo il costo delle copie; inoltre, con input lunghi si può superare il limite di ricorsione di Python. Nel normale codice applicativo, è preferibile usare lo slicing o un ciclo.

Verificare se una stringa Python è palindroma con una deque

Una collections.deque è una coda a doppia estremità. Permette al controllo di rimuovere un carattere da ciascuna estremità e confrontare la coppia. Nel complesso, creare la deque e controllare tutte le coppie richiede tempo lineare.

from collections import deque

def is_palindrome(text):
    chars = deque(text)
    while len(chars) > 1:
        if chars.popleft() != chars.pop():
            return False
    return True

print(is_palindrome("radar"))

Le singole rimozioni dalle estremità hanno costo costante, ma il controllo completo non ha costo costante: può esaminare tutti i caratteri. Questo metodo confronta i caratteri così come sono, comprese maiuscole, spazi e punteggiatura.

Ignorare maiuscole e caratteri non alfanumerici nel controllo di un palindromo

Per controllare frasi, converti prima il testo in minuscolo e conserva solo i caratteri alfanumerici. Questa scelta cambia ciò che viene considerato un palindromo: maiuscole e minuscole, spazi e punteggiatura non influiscono più sul confronto, mentre lettere e cifre restano significative.

def is_palindrome(text):
    normalized = "".join(char.lower() for char in text if char.isalnum())
    return normalized == normalized[::-1]

phrase = "A man, a plan, a canal, Panama!"
print(is_palindrome(phrase))

isalnum() conserva lettere e cifre. I metodi per le stringhe di Python supportano i caratteri Unicode; se un’applicazione deve accettare solo un alfabeto specifico, definisci esplicitamente la relativa regola sui caratteri.

Scegliere un approccio per verificare i palindromi in Python

Per il controllo diretto più breve, usa word == word[::-1]. Scegli reversed() con join() se ti è utile un’alternativa basata su un iteratore, oppure un ciclo se il confronto esplicito delle coppie e l’interruzione anticipata rendono la logica più chiara. Anche una deque permette di confrontare le due estremità. La ricorsione è soprattutto didattica, perché ogni chiamata esegue slicing del testo e gli input lunghi possono raggiungere il limite di ricorsione.

Decidi se confrontare l’input alla lettera o normalizzarlo prima: da questa scelta dipende se maiuscole, spazi e punteggiatura influiranno sul risultato. Per tecniche correlate di elaborazione del testo, consulta le espressioni regolari di Python (regex).