Regex in Python: modulo re, pattern, gruppi e sostituzioni

Quando usare le regex

Le espressioni regolari sono un piccolo linguaggio per descrivere schemi nel testo. Sono potenti ed è facile abusarne.

Prima di ricorrere a re, chiediti se bastano i normali metodi delle stringhe. .split(), .replace(), .startswith(), "target" in text: sono più veloci, più leggibili e meno soggetti a errori della regex equivalente. Tieni le regex per quando lo schema che ti interessa è davvero strutturato ma troppo flessibile per operazioni su stringhe fisse: indirizzi email, numeri di telefono, righe di log con una forma nota, frammenti di HTML o Markdown, qualsiasi ricerca del tipo "trova questo genere di cosa".

Il vocabolario di base

Un pattern regex è una stringa che descrive cosa stai cercando. Qualche mattoncino:

• .: un qualsiasi carattere singolo
• \d: una qualsiasi cifra (0-9)
• \w: un qualsiasi carattere di "parola" (lettera, cifra, trattino basso)
• \s: un qualsiasi carattere di spaziatura
• ^: inizio della stringa
• $: fine della stringa
• [abc]: uno qualsiasi tra a, b o c
• [^abc]: qualsiasi carattere tranne a, b, c
• a|b: a oppure b
• *: zero o più occorrenze dell'elemento precedente
• +: una o più
• ?: zero o una
• {3}: esattamente 3
• {2,5}: tra 2 e 5
• ( ... ): gruppo (cattura la corrispondenza al suo interno)

Basta questo per la maggior parte delle regex del mondo reale.

Le funzioni principali

re.search(pattern, text) trova la prima corrispondenza in qualsiasi punto della stringa. Restituisce un oggetto match oppure None:

import re

text = "Order 12345 shipped on 2026-04-20"
match = re.search(r"\d{5}", text)

if match:
    print("Found:", match.group())
    print("Position:", match.start(), "-", match.end())
else:
    print("No match")

Usa sempre una raw string (r"...") per i pattern regex. Altrimenti Python cerca di interpretare le barre rovesciate come escape di stringa e ottieni un pattern diverso da quello che hai scritto.

re.match(pattern, text) è come search, ma trova corrispondenze solo all'inizio:

import re

print(re.search(r"hello", "say hello"))   # match
print(re.match(r"hello", "say hello"))    # None: non iniziava con hello

Il più delle volte ti serve search.

re.findall(pattern, text) restituisce tutte le corrispondenze non sovrapposte sotto forma di lista:

import re

text = "Apples 3, oranges 12, pears 7"
numbers = re.findall(r"\d+", text)
print(numbers)   # ['3', '12', '7']

Nota che findall restituisce stringhe, non oggetti match. Se il pattern ha un solo gruppo, ottieni il contenuto del gruppo. Con più gruppi, ottieni una lista di tuple.

Gruppi di cattura

Le parentesi in un pattern catturano ciò che corrisponde al loro interno:

import re

line = "2026-04-20: server started"
match = re.search(r"(\d{4})-(\d{2})-(\d{2}): (.+)", line)

if match:
    print(match.group(0))  # l'intera corrispondenza
    print(match.group(1))  # '2026': primo gruppo
    print(match.group(2))  # '04'
    print(match.group(3))  # '20'
    print(match.group(4))  # 'server started'
    print(match.groups())  # tupla di tutti i gruppi

I gruppi con nome di solito sono più chiari:

import re

line = "2026-04-20: server started"
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}): (?P<msg>.+)"
match = re.search(pattern, line)

if match:
    print(match["year"], match["month"], match["day"])
    print(match.groupdict())

Quando la regex ha più di un gruppo, dargli un nome rende il codice di estrazione molto più facile da seguire.

Sostituire con re.sub

re.sub(pattern, replacement, text) sostituisce ogni corrispondenza:

import re

text = "Call me at (415) 555-1234 or 212.555.5678"
cleaned = re.sub(r"[^\d]", "", text)
print(cleaned)

Questo elimina tutto ciò che non è una cifra. La sostituzione può fare riferimento ai gruppi catturati con \1, \2, ecc.; nelle raw string, \g<1> è più chiaro:

import re

text = "Alice Johnson, Bob Smith, Carol Tran"
swapped = re.sub(r"(\w+) (\w+)", r"\2, \1", text)
print(swapped)

Puoi anche passare una funzione come sostituzione. È utile per trasformazioni che non sono un semplice scambio:

import re

text = "Prices: 10, 20, 30"
doubled = re.sub(r"\d+", lambda m: str(int(m.group()) * 2), text)
print(doubled)

Compilare i pattern per riutilizzarli

Se usi lo stesso pattern molte volte, soprattutto in un ciclo, compilalo una volta sola:

import re

DATE = re.compile(r"\d{4}-\d{2}-\d{2}")

lines = [
    "started at 2026-04-20",
    "no timestamp here",
    "finished 2026-04-21",
]

for line in lines:
    match = DATE.search(line)
    if match:
        print(match.group())

I pattern compilati espongono gli stessi metodi (search, match, findall, sub) senza il pattern come primo argomento. Un po' più efficienti, spesso più leggibili.

Flag

Modificatori comuni, passati come argomento flags= o combinati con l'OR:

• re.IGNORECASE (re.I): corrispondenza senza distinzione tra maiuscole e minuscole.
• re.MULTILINE (re.M): ^ e $ corrispondono all'inizio e alla fine di ogni riga, non solo ai confini della stringa.
• re.DOTALL (re.S): . corrisponde anche agli a capo (di default non lo fa).
• re.VERBOSE (re.X): consente spazi e commenti # nel pattern, per la leggibilità.

import re

text = "HELLO world"
print(re.search(r"hello", text))
print(re.search(r"hello", text, re.IGNORECASE))

re.VERBOSE è particolarmente utile per i pattern complessi:

import re

pattern = re.compile(r"""
    (?P<user>[\w.]+)    # parte del nome utente
    @                    # chiocciola letterale
    (?P<domain>[\w.-]+)  # dominio
""", re.VERBOSE)

match = pattern.search("Contact me at rosa@example.com")
if match:
    print(match.groupdict())

Le regex su più righe e commentate sono enormemente più facili da mantenere di righe singole indecifrabili.

Greedy contro lazy

I quantificatori (*, +, ?, {n,}) sono greedy (avidi) di default: prendono quanto più testo possibile. Aggiungi un ? per renderli lazy (pigri):

import re

html = "<b>bold</b> and <i>italic</i>"

# Greedy: corrisponde dal primo < all'ultimo >
print(re.findall(r"<.+>", html))

# Lazy: corrisponde a ogni tag separatamente
print(re.findall(r"<.+?>", html))

La versione greedy cattura l'intera sottostringa da <b> a </i>, probabilmente non quello che volevi. Il lazy .+? si ferma al primo >.

(Nota a margine: in produzione non analizzare davvero l'HTML con le regex. Usa html.parser o BeautifulSoup. L'esempio qui sopra serve solo a illustrare il comportamento greedy.)

Un esempio realistico

Analizzare le righe di un semplice formato di log:

import re

log = """
2026-04-20 09:00:12 INFO  Server started
2026-04-20 09:01:45 WARN  Slow query detected
2026-04-20 09:03:01 ERROR Database connection lost
"""

pattern = re.compile(r"""
    (?P<date>\d{4}-\d{2}-\d{2})\s+
    (?P<time>\d{2}:\d{2}:\d{2})\s+
    (?P<level>INFO|WARN|ERROR)\s+
    (?P<message>.+)
""", re.VERBOSE)

for line in log.strip().splitlines():
    match = pattern.match(line)
    if match:
        print(match.groupdict())

Tanta potenza in poche righe.

Qualche buona abitudine

• Usa sempre le raw string per i pattern.
• Parti dal pattern più semplice che funziona; restringilo dopo.
• Usa i gruppi con nome appena hai più di un gruppo.
• Compila i pattern che riutilizzerai.
• Le regex sono più lente dei normali metodi delle stringhe. Se basta .split(), usa .split().

Prossimo argomento: errori e debug

Qui si chiude il giro sui dati reali: file, JSON, CSV, HTTP, date e regex. Prima o poi, però, qualsiasi programma reale incontra un errore, e saper leggere bene i traceback di Python è la singola abilità di debug più importante che puoi acquisire. L'ultimo capitolo parla delle eccezioni e degli errori specifici che incontrerai più spesso.