Stringhe in Python: f-string, slicing e tutti i metodi che userai

Testo, ma con i metodi

Una stringa Python è una sequenza di caratteri, e userai le stringhe più di qualsiasi altro tipo. Ogni nome, etichetta, messaggio, URL, percorso di file e risposta di un'API prima o poi vive in una stringa.

Ne crei una con le virgolette: singole, doppie o triple:

a = "double"
b = 'single'
c = """triple for
multi-line content"""

print(a, b)
print(c)

Virgolette singole e doppie sono intercambiabili. Usa quelle che ti evitano di dover fare l'escape di un carattere. "don't" è pulito; 'don\'t' richiede una barra rovesciata.

Le stringhe sono immutabili. Una volta che una stringa esiste, non puoi cambiarne un carattere sul posto. Ogni operazione che sembra modificare una stringa in realtà ne restituisce una nuova. Per questo scriverai text = text.upper() e non semplicemente text.upper(): senza la riassegnazione, la nuova stringa in maiuscolo verrebbe buttata via.

Unire e ripetere

Due operatori fanno quasi tutto il lavoro di combinazione di stringhe che ti servirà:

greeting = "hello" + ", " + "world"
print(greeting)

separator = "-" * 20
print(separator)

+ concatena le stringhe. * ripete una stringa. Entrambi restituiscono una nuova stringa.

Concatenare molti pezzi con + diventa presto brutto. Quando mescoli valori di tipi diversi in un messaggio, usa invece le f-string: le vediamo nella prossima sezione.

f-string: il modo in cui formatterai di solito

Metti una f prima delle virgolette di apertura e la stringa diventa un modello. Tutto ciò che sta in {...} viene sostituito dal valore di quell'espressione:

name = "Rosa"
hour = 9
temp = 72.6

print(f"Good morning, {name}.")
print(f"It's {hour} o'clock and {temp} degrees outside.")
print(f"In two hours it'll be {hour + 2} o'clock.")

Dentro le graffe puoi mettere qualsiasi espressione: variabili, operazioni aritmetiche, chiamate di metodi, chiamate di funzioni. Tienile semplici, però; se hai la tentazione di infilare un calcolo di tre righe in {...}, calcolalo prima in una variabile con un nome.

Le f-string supportano anche degli specificatori di formato dopo i due punti, per controllare la formattazione dei numeri, il riempimento e l'allineamento:

total = 1234.5678

print(f"Total: {total:.2f}")       # 1234.57: due cifre decimali
print(f"Padded: {42:>5}")          # "   42": allineato a destra su 5 caratteri
print(f"As percent: {0.875:.1%}")  # 87.5%
print(f"With commas: {1_000_000:,}")  # 1,000,000

Questi specificatori sono gli stessi che usa str.format() e vale la pena darci un'occhiata quando ti senti a tuo agio con le basi. Per il codice dei primi giorni non ti servono.

Slicing: prendere un pezzo

Le stringhe si possono indicizzare come le sequenze. Ogni carattere ha una posizione che parte da zero, e puoi prendere un carattere o un intervallo:

word = "python"

print(word[0])      # 'p': primo carattere
print(word[-1])     # 'n': ultimo carattere
print(word[0:2])    # 'py': indici da 0 fino a 2 (escluso)
print(word[2:])     # 'thon': dall'indice 2 fino alla fine
print(word[:2])     # 'py': dall'inizio fino all'indice 2
print(word[::-1])   # 'nohtyp': invertita

Lo schema [start:stop:step] compare anche nelle liste e nelle altre sequenze, quindi investire qualche minuto per interiorizzarlo ripaga ovunque.

Due cose da sottolineare:

• L'indice di stop è escluso: word[0:2] include gli indici 0 e 1, non il 2.
• Gli indici negativi contano dalla fine: -1 è l'ultimo carattere, -2 quello prima, e così via.

Come invertire una stringa

Le stringhe non hanno un metodo .reverse(), perché sono immutabili, ma lo slicing con uno step di -1 fa il lavoro in una riga:

word = "python"
reversed_word = word[::-1]
print(reversed_word)

word[::-1] si legge come "dall'inizio alla fine, andando all'indietro di 1". Il risultato è una stringa nuova di zecca; l'originale resta intatto. Se devi scorrere i caratteri al contrario senza creare una nuova stringa, reversed(word) restituisce un iteratore pigro.

Come controllare la lunghezza di una stringa

len(text) restituisce il numero di caratteri:

name = "python"
print(len(name))
print(len(""))

Nota che len conta i code point Unicode, non i byte. len("café") fa 4, non 5, anche se la codifica UTF-8 occupa più byte: di solito è proprio quello che vuoi.

Come verificare se una stringa contiene una sottostringa

L'operatore in è il controllo idiomatico, e si legge quasi come una frase:

text = "Welcome to Python"

print("Python" in text)       # True
print("python" in text)       # False: distingue maiuscole e minuscole
print("Java" not in text)     # True

Per controlli che non distinguono maiuscole e minuscole, normalizza prima entrambi i lati:

text = "Welcome to Python"
needle = "PYTHON"

print(needle.lower() in text.lower())

Se ti serve la posizione, non solo un sì o un no, usa .find(): restituisce l'indice, oppure -1 quando la sottostringa non c'è.

Metodi comuni delle stringhe

Le stringhe hanno decine di metodi. Questa manciata la userai di continuo:

text = "  Hello, Python World  "

print(text.strip())            # rimuove gli spazi iniziali e finali
print(text.lower())            # "  hello, python world  "
print(text.upper())            # "  HELLO, PYTHON WORLD  "
print(text.replace("Python", "PY"))
print(text.startswith("  Hello"))
print(text.endswith("World  "))
print(text.find("Python"))     # indice in cui inizia "Python"; -1 se non c'è

Dividere e unire:

csv = "alpha,beta,gamma,delta"
parts = csv.split(",")
print(parts)

rejoined = " | ".join(parts)
print(rejoined)

.split(separator) trasforma una stringa in una lista. separator.join(list_of_strings) la rimette insieme. Questi due metodi fanno una parte sproporzionata del lavoro reale sulle stringhe.

Un'altra coppia utile:

line = "name = Rosa"
key, value = line.split("=")
print(key.strip(), "->", value.strip())

È un parser per una voce di configurazione su una riga, scritto in tre righe. Stringhe piccole, grande effetto.

Controllare cosa c'è dentro

Diversi metodi restituiscono booleani, utili nelle condizioni degli if:

print("42".isdigit())
print("abc".isalpha())
print("abc123".isalnum())
print("   ".isspace())
print("PYTHON".isupper())
print("hello".islower())

Usali con parsimonia: non gestiscono le stranezze di Unicode in tutti i modi che potresti aspettarti. Per qualsiasi cosa vada oltre l'ASCII, affidati al modulo delle regex o al modulo unicodedata.

Fare l'escape dei caratteri speciali

Alcuni caratteri hanno bisogno di una barra rovesciata per comparire dentro una stringa:

newline = "first line\nsecond line"
tab = "col1\tcol2"
quote = "She said \"hi\""
back = "C:\\path\\to\\file"

print(newline)
print(tab)
print(quote)
print(back)

Se scrivi percorsi Windows o regex, le raw string ti semplificano la vita. Metti una r prima delle virgolette e le barre rovesciate smettono di essere caratteri di escape:

path = r"C:\path\to\file"
print(path)

Le stringhe sono ovunque, quindi tienile leggibili

Tre abitudini che evitano al codice pieno di stringhe di diventare un pasticcio:

1. Usa le f-string per l'interpolazione. Non concatenare con + valori di tipi diversi.
2. Riassegna quando "modifichi". text = text.strip(), non text.strip() da solo.
3. Usa .split() e .join() prima di scrivere cicli manuali per analizzare o comporre testo. Sono più veloci, più chiari e più difficili da sbagliare.

Prossimo argomento: le f-string nel dettaglio, lo strumento di formattazione che hai già visto qualche volta, più gli specificatori per numeri e date che le rendono degne di essere padroneggiate.