Metodi delle Stringhe in Python

Le stringhe in Python dispongono di un ricco set di metodi integrati che coprono quasi ogni manipolazione di cui avrai mai bisogno — rimozione degli spazi, ricerca, divisione, unione, verifica del contenuto e formattazione. Poiché le stringhe sono immutabili, ogni metodo restituisce una nuova string (o un altro valore) invece di modificare quella originale.

Questo capitolo tratta i metodi più importanti per le stringhe raggruppati per scopo, con esempi e insidie comuni. Per informazioni di base su come vengono create e indicizzate le stringhe, vedi il capitolo Python Strings. Per la sintassi dello slicing, vedi Slicing Strings.

Conversione del Case

upper() e lower()

upper() restituisce una copia della string con tutte le lettere convertite in maiuscolo; lower() fa il contrario.

Questi metodi non sono consapevoli del locale per le lettere ASCII. Per la gestione corretta del case in base al locale (ad es. la I con punto del turco), usa il modulo locale o librerie di terze parti.

title() e capitalize()

title() capitalizza la prima lettera di ogni parola. capitalize() capitalizza solo il primo carattere dell'intera string e rende minuscolo tutto il resto.

s = "hello world"
print(s.title())       # Hello World
print(s.capitalize())  # Hello world

Attenzione: title() tratta qualsiasi carattere non lettera come separatore di parole, quindi "it's" diventa "It'S". Usa la funzione string.capwords() dalla libreria standard quando hai bisogno di un rilevamento delle parole più intelligente.

swapcase()

Inverte il case di ogni carattere — le maiuscole diventano minuscole e viceversa.

print("Hello World".swapcase())  # hELLO wORLD

Spazi Bianchi e Padding

strip(), lstrip() e rstrip()

Questi rimuovono i caratteri iniziali e/o finali (spazi bianchi per impostazione predefinita).

s = "  Hello World  "
print(s.strip())   # "Hello World"
print(s.lstrip())  # "Hello World  "
print(s.rstrip())  # "  Hello World"

Puoi passare una string di caratteri da rimuovere — non un prefisso/suffisso, ma qualsiasi combinazione di quei caratteri:

print("***hello***".strip("*"))   # hello
print("xyzhelloyz".strip("xyz"))  # hello

center(), ljust() e rjust()

Aggiungono padding a una string per raggiungere una larghezza specificata. Un carattere di riempimento opzionale (predefinito: spazio) riempie lo spazio extra.

print("hi".center(10))       # "    hi    "
print("hi".ljust(10, "-"))   # "hi--------"
print("hi".rjust(10, "-"))   # "--------hi"

Questi sono utili per creare tabelle di testo a larghezza fissa.

zfill()

Aggiunge zeri iniziali a una string numerica per raggiungere una larghezza specificata. Rispetta un segno + o - iniziale.

print("42".zfill(5))    # 00042
print("-7".zfill(5))    # -0007

Ricerca e Conteggio

find() e rfind()

find(sub) restituisce l'indice più basso in cui viene trovato sub, oppure -1 se non trovato. rfind(sub) trova l'indice più alto (più a destra).

s = "Hello World"
print(s.find("World"))    # 6
print(s.find("xyz"))      # -1
print(s.rfind("l"))       # 9

Entrambi accettano argomenti opzionali start e end per limitare l'intervallo di ricerca.

index() e rindex()

Funzionano esattamente come find() e rfind(), ma sollevano ValueError invece di restituire -1 quando la sottostringa non viene trovata. Usa find() quando l'assenza è un caso normale; usa index() quando l'assenza indica che qualcosa è andato storto.

s = "Hello World"
print(s.index("World"))   # 6
# s.index("xyz")          # raises ValueError

count()

Restituisce il numero di occorrenze non sovrapposte di una sottostringa.

print("banana".count("a"))     # 3
print("banana".count("an"))    # 2
print("aaaa".count("aa"))      # 2  (non-overlapping)

startswith() e endswith()

Restituiscono True se la string inizia o termina con il prefisso/suffisso specificato. Entrambi accettano una tupla di stringhe per verificare più opzioni contemporaneamente.

filename = "report.pdf"
print(filename.startswith("report"))         # True
print(filename.endswith(".pdf"))             # True
print(filename.endswith((".pdf", ".docx")))  # True

Questo è spesso più leggibile dello slicing: filename[-4:] == ".pdf".

Sostituzione e Divisione

replace(old, new, count=-1)

Restituisce una copia con ogni occorrenza di old sostituita da new. Passa un intero come terzo argomento per limitare il numero di sostituzioni.

replace() esegue una corrispondenza letterale esatta; per la sostituzione basata su pattern usa la funzione re.sub() del capitolo Python Regex.

split(sep=None, maxsplit=-1)

Divide la string su sep e restituisce un array. Quando sep è omesso (o None), divide su qualsiasi spazio bianco e scarta le stringhe vuote — ideale per tokenizzare l'input dell'utente.

split() restituisce sempre un array, anche quando il delimitatore è assente (l'array contiene solo la string originale).

rsplit(sep=None, maxsplit=-1)

Come split(), ma parte da destra. Utile quando vuoi solo le ultime parti di una string.

path = "/home/user/documents/file.txt"
print(path.rsplit("/", 1))  # ['/home/user/documents', 'file.txt']

splitlines()

Divide ai confini di riga (\n, \r\n, \r e altri) e facoltativamente mantiene le terminazioni.

text = "line one\nline two\r\nline three"
print(text.splitlines())  # ['line one', 'line two', 'line three']

join(iterable)

L'opposto di split(). Concatena ogni elemento in un iterabile, inserendo la string su cui viene chiamato tra ogni elemento. Questo è il modo preferito per costruire una string da un array perché Python la costruisce in un unico passaggio.

print(", ".join(["apples", "bananas", "cherries"]))
# apples, bananas, cherries

print("".join(["P", "y", "t", "h", "o", "n"]))
# Python

Per ulteriori dettagli, vedi il capitolo Concatenate Strings.

Verifica del Contenuto

Questi metodi restituiscono True o False e sono utili per la validazione dell'input.

print("Python".isalpha())   # True
print("12345".isdigit())    # True
print("abc123".isalnum())   # True
print("   ".isspace())      # True
print("Hello World".istitle())  # True

Nota: Una string vuota restituisce False per tutti questi metodi.

Lunghezza

len() è una funzione integrata, non un metodo delle stringhe, ma è fondamentale per il lavoro con le stringhe.

Le stringhe hanno indice zero, quindi gli indici validi vanno da 0 a len(s) - 1.

Concatenazione

L'operatore + unisce due stringhe. L'operatore * ripete una string un numero specificato di volte.

Per unire molte stringhe o costruire stringhe in un ciclo, "".join(list) è significativamente più veloce di + in un ciclo. Vedi Concatenate Strings per un confronto delle prestazioni.

Formattazione

format() e f-string

str.format() inserisce valori nei segnaposto {}. Le f-string (Python 3.6+) fanno la stessa cosa in modo più conciso e sono ora lo stile preferito.

name = "Alice"
score = 95

# str.format()
print("Hello, {}! Your score is {}.".format(name, score))

# f-string (preferred)
print(f"Hello, {name}! Your score is {score}.")
# Hello, Alice! Your score is 95.

Entrambi supportano gli specificatori di formato. Per la sintassi completa, vedi Python String Formatting.

encode()

Converte la string in un oggetto bytes usando la codifica specificata (predefinita utf-8).

s = "café"
print(s.encode("utf-8"))   # b'caf\xc3\xa9'
print(s.encode("ascii", errors="replace"))  # b'caf?'

Riferimento Rapido

Pratica