Guida Completa alle Espressioni Regolari (Regex) in Python

Python
potente
None

Caratteri speciali e classi di caratteri:

• Classi di caratteri:
  • \d: Corrisponde a qualsiasi cifra (0-9).
  • \w: Corrisponde a qualsiasi carattere alfanumerico (lettere, cifre e underscore).
  • \s: Corrisponde a qualsiasi spazio bianco (spazi, tabulazioni, newline).
  • \D, \W, \S: Le versioni maiuscole di queste classi corrispondono ai caratteri non inclusi nelle classi minuscole.

Esempi:

import re

testo = "Il prezzo è 123.45 €"
cifre = re.findall(r"\d+", testo) # Trova tutte le sequenze di cifre
print(cifre) # Output: ['123', '45']

testo2 = "Parola_123"
alfanumerici = re.findall(r"\w+", testo2) # Trova tutte le sequenze alfanumeriche
print(alfanumerici) # Output: ['Parola_123']

testo3 = "Testo con spazi\ttabulazioni\nnewline"
spazi = re.findall(r"\s+", testo3) # Trova tutti gli spazi bianchi
print(spazi) # Output: [' ', '\t', '\n']

cifre = re.findall(r"\d+", testo):

• re.findall(): Questa funzione cerca tutte le occorrenze di un pattern in una stringa e restituisce una lista di corrispondenze.

• r"\d+": Questa è un’espressione regolare “raw string”.

  • \d: Questo carattere speciale corrisponde a qualsiasi cifra (0-9).
  • +: Questo quantificatore significa “uno o più” delle occorrenze del carattere precedente. Quindi, \d+ corrisponde a una o più cifre consecutive.

• In sintesi, questa riga cerca tutte le sequenze di una o più cifre nel testo.

Quantificatori avanzati:

• {n}: Corrisponde esattamente a n ripetizioni.
• {n,}: Corrisponde a n o più ripetizioni.
• {n,m}: Corrisponde a un minimo di n e un massimo di m ripetizioni.
• *?, +?, ??: Le versioni “lazy” (non avide) dei quantificatori *, +, ?. Corrispondono al minor numero possibile di caratteri.

Esempi:

import re

testo = "aaaaabbbccc"
tre_a = re.search(r"a{3}", testo) # Trova esattamente tre 'a'
print(tre_a.group()) # Output: aaa

da_due_a_quattro_b = re.search(r"b{2,4}", testo) # Trova da due a quattro 'b'
print(da_due_a_quattro_b.group()) # Output: bbb

testo2 = "TestoAltro testoAncora testo"
tag_avidi = re.findall(r".*", testo2) # Corrispondenza avida
tag_non_avidi = re.findall(r".*?", testo2) # Corrispondenza non avida
print(tag_avidi) # Output: ['TestoAltro testoAncora testo']
print(tag_non_avidi) # Output: ['Testo', 'Ancora testo']

Flag di compilazione:

• re.IGNORECASE (o re.I): Ignora la differenza tra maiuscole e minuscole.
• re.MULTILINE (o re.M): Permette a ^ e $ di corrispondere all’inizio e alla fine di ogni riga (non solo dell’intera stringa).
• re.DOTALL (o re.S): Permette a . di corrispondere anche al carattere newline.
• re.VERBOSE (o re.X): Permette di scrivere regex più leggibili con spazi e commenti.

Esempi:

import re

testo = "Python python PYTHON"
trova_python_maiuscolo_minuscolo = re.findall(r"python", testo, re.IGNORECASE)
print(trova_python_maiuscolo_minuscolo) # Output: ['Python', 'python', 'PYTHON']

testo2 = "Riga 1\nRiga 2\nRiga 3"
righe_che_iniziano_per_r = re.findall(r"^Riga", testo2, re.MULTILINE)
print(righe_che_iniziano_per_r) # Output: ['Riga', 'Riga', 'Riga']

testo3 = "Testo\ncon\nnewline"
tutto = re.findall(r".+", testo3, re.DOTALL)
print(tutto) # Output: ['Testo\ncon\nnewline']

pattern = re.compile(r"""
    \d{3} # Tre cifre
    -     # Un trattino
    \d{4} # Quattro cifre
""", re.VERBOSE)
numero_di_telefono = pattern.search("123-4567")
print(numero_di_telefono.group()) #output 123-4567

Cos’è .group()?

Il metodo .group() è una funzione fondamentale degli oggetti “match” che vengono restituiti dalle funzioni del modulo re come:

• re.search()
• re.match()
• e dagli iteratori restituiti da re.finditer()

In parole semplici, quando una funzione regex trova una corrispondenza (un “match”) in una stringa, essa restituisce un oggetto “match”. Questo oggetto contiene informazioni sul match trovato, e .group() è il metodo che ti permette di accedere alle parti di quel match.

Utilizzo di base di .group(): L’intero match

Nella sua forma più semplice, quando chiami .group() senza argomenti (o con group(0)), ti restituisce l’intera stringa che ha corrisposto al pattern.

Ecco un esempio

import re

testo = "Sto imparando Python per l'analisi dei dati"
risultato = re.search("Python", testo)

if risultato:
parola_trovata = risultato.group() # Equivalente a risultato.group(0)
print(f"Testo trovato: {parola_trovata}")
else:
print("Pattern non trovato")

Output:

Testo trovato: Python

import re

testo = "Data di nascita: 23/05/1990"
data_pattern = r"(\d{2})/(\d{2})/(\d{4})" # Tre gruppi di cattura per GG, MM, AAAA
risultato = re.search(data_pattern, testo)

if risultato:
giorno = risultato.group(1) # Gruppo 1: (\d{2}) - il giorno
mese = risultato.group(2) # Gruppo 2: (\d{2}) - il mese
anno = risultato.group(3) # Gruppo 3: (\d{4}) - l'anno
data_completa = risultato.group(0) # Gruppo 0: l'intero match

print(f"Data completa trovata: {data_completa}")
print(f"Giorno: {giorno}")
print(f"Mese: {mese}")
print(f"Anno: {anno}")
else:
print("Data non trovata")

Data completa trovata: 23/05/1990
Giorno: 23
Mese: 05
Anno: 1990

iimport re

email = "[email protected]"
pattern = r"(?P[a-zA-Z0-9.]+)@(?P[a-zA-Z0-9.]+\.[a-zA-Z]{2,})"
match = re.search(pattern, email)

if match:
    username = match.group('username') # Accedi al gruppo nominato 'username'
    dominio = match.group('dominio')   # Accedi al gruppo nominato 'dominio'

    print(f"Username: {username}")
    print(f"Dominio: {dominio}")

Username: utente.esempio
Dominio: dominio.com

import re

testo = "Data di nascita: 23/05/1990"
data_pattern = r"(\d{2})/(\d{2})/(\d{4})"
risultato = re.search(data_pattern, testo)

if risultato:
    gruppi = risultato.groups() # Restituisce una tupla con ('23', '05', '1990')
    print(f"Tupla dei gruppi: {gruppi}")
    giorno, mese, anno = risultato.groups() # Unpacking della tupla
    print(f"Giorno: {giorno}, Mese: {mese}, Anno: {anno}")

Tupla dei gruppi: ('23', '05', '1990')
Giorno: 23, Mese: 05, Anno: 1990