Tutorial sulle espressioni regolari in Python

Le espressioni regolari, spesso abbreviate in regex, sono una sequenza di caratteri usata per verificare se un modello (pattern) esiste o meno in un determinato testo (stringa). Se hai mai usato motori di ricerca, gli strumenti Trova e Sostituisci dei word processor o degli editor di testo, hai già visto le espressioni regolari in azione. Vengono usate lato server per validare il formato di indirizzi email o password durante la registrazione, per analizzare file di dati testuali allo scopo di trovare, sostituire o eliminare determinate stringhe, ecc. Aiutano a manipolare dati testuali, spesso un prerequisito per progetti di data science che coinvolgono text mining.

Questo tutorial ti guiderà attraverso i concetti fondamentali delle espressioni regolari con Python. Inizierai con l'importazione di re - la libreria Python che supporta le espressioni regolari. Poi vedrai come i caratteri di base/ordinari vengono usati per effettuare i match, seguiti dai caratteri jolly o speciali. Successivamente imparerai a usare le ripetizioni nelle tue espressioni regolari. Imparerai anche a creare gruppi e gruppi nominati all'interno della tua ricerca per accedere più facilmente ai match. Poi ti familiarizzerai con il concetto di matching greedy vs non greedy.

Sembra già tanto, perciò trovi anche una comoda tabella riepilogativa con brevi definizioni per aiutarti a ricordare quanto visto finora. Dagli un'occhiata!

Questo tutorial copre anche alcune funzioni molto utili fornite dalla libreria re, come: compile(), search(), findall(), sub() per cerca e sostituisci, split() e altre ancora. Imparerai anche a conoscere i flag di compilazione che puoi usare per migliorare le tue regex.

Alla fine, c'è un case study - dove potrai mettere in pratica ciò che hai imparato! Quindi, iniziamo a fare regex...

Espressioni regolari in Python

In Python, le espressioni regolari sono supportate dal modulo re. Ciò significa che, se vuoi iniziare a usarle nei tuoi script Python, devi importare questo modulo con l'aiuto di import:

import re

La libreria re in Python fornisce diverse funzioni che la rendono una competenza che vale la pena padroneggiare. In questo tutorial ne vedrai da vicino alcune.

Pattern di base: caratteri ordinari

Puoi gestire facilmente molti pattern di base in Python usando caratteri ordinari. I caratteri ordinari sono le espressioni regolari più semplici. Corrispondono esattamente a se stessi e non hanno un significato speciale nella sintassi delle espressioni regolari.

Esempi: 'A', 'a', 'X', '5'.

I caratteri ordinari possono essere usati per eseguire match esatti semplici:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

La maggior parte degli alfabeti e dei caratteri farà match con se stessi, come hai visto nell'esempio.

La funzione match() restituisce un oggetto match se il testo corrisponde al pattern. Altrimenti, restituisce None. Il modulo re contiene anche diverse altre funzioni, e ne imparerai alcune più avanti nel tutorial.

Per ora, concentriamoci sui caratteri ordinari!

Noti la r all'inizio del pattern Cookie?
Si chiama stringa letterale raw. Cambia il modo in cui la stringa letterale viene interpretata. Queste stringhe vengono memorizzate così come appaiono.

Per esempio, \ è solo una barra rovesciata quando è preceduta da una r invece di essere interpretata come sequenza di escape. Vedrai cosa significa con i caratteri speciali. A volte la sintassi prevede caratteri con backslash di escape e, per impedire che vengano interpretati come sequenze di escape, si usa il prefisso raw r.

CONSIGLIO: In realtà non ti serve in questo esempio; tuttavia, è una buona pratica usarla per coerenza.

Caratteri jolly: caratteri speciali

I caratteri speciali non fanno match con se stessi come appaiono, ma hanno un significato speciale quando usati in un'espressione regolare. Per semplificare, si possono considerare come metacaratteri riservati che indicano qualcos'altro e non ciò che sembrano.

Vediamo alcuni esempi per osservare i caratteri speciali in azione...

Ma prima, gli esempi seguenti fanno uso di due funzioni, ovvero: search() e group().
Con la funzione search scorri la stringa/sequenza fornita cercando la prima posizione in cui l'espressione regolare produce un match.
La funzione group restituisce la stringa trovata dalla re. Vedrai entrambe le funzioni più in dettaglio più avanti.

Torniamo ora ai caratteri speciali.

. - Un punto. Fa match con un singolo carattere qualsiasi tranne il carattere di newline.

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ - Un accento circonflesso. Fa match con l'inizio della stringa.

È utile se vuoi assicurarti che un documento/frase inizi con determinati caratteri.

re.search(r'^Eat', "Eat cake!").group()

## Tuttavia, il codice sotto non darà lo stesso risultato. Provalo tu stesso:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ - Fa match con la fine della stringa.

È utile se vuoi assicurarti che un documento/frase termini con determinati caratteri.

re.search(r'cake$', "Cake! Let's eat cake").group()

## La ricerca successiva restituirà il valore NONE, provala:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] - Fa match con a o b o c.
[a-zA-Z0-9] - Fa match con qualsiasi lettera da (a a z) o (A a Z) o (0 a 9).

CONSIGLIO: I caratteri che non sono all'interno di un intervallo possono essere intercettati complementando l'insieme. Se il primo carattere dell'insieme è ^, verranno intercettati tutti i caratteri che non sono nell'insieme.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## Fa match con qualsiasi carattere tranne 5
re.search(r'Number: [^5]', 'Number: 0').group()

## Questo non farà match e quindi verrà restituito un valore NONE
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ - Backslash.
Forse il metacarattere più versatile!

• Se il carattere che segue il backslash è un carattere di escape riconosciuto, allora viene preso il significato speciale del termine (Scenario 1)
• Altrimenti, se il carattere che segue \ non è un carattere di escape riconosciuto, allora \ è trattato come un qualsiasi altro carattere e passato così com'è (Scenario 2).
• \ può essere usato davanti a tutti i metacaratteri per rimuoverne il significato speciale (Scenario 3).

## (Scenario 1) Questo tratta '\s' come un carattere di escape, '\s' definisce uno spazio
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Scenario 2) '\' è trattato come un carattere ordinario, perché '\r' non è un carattere di escape riconosciuto
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Scenario 3) '\s' è eseguito l'escape usando una `\` extra così è interpretato come stringa letterale '\s'
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

Esiste un insieme predefinito di sequenze speciali che iniziano con '\' e sono molto utili durante la ricerca e il match. Vediamone alcune da vicino...

\w - w minuscola. Fa match con una singola lettera, cifra o underscore.
\W - W maiuscola. Fa match con qualsiasi carattere non appartenente a \w (w minuscola).

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Fa match con qualsiasi carattere tranne singola lettera, cifra o underscore
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## La W maiuscola non farà match con lettera singola o cifra
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - s minuscola. Fa match con un singolo carattere di spazio bianco come: spazio, newline, tab, return.
\S - S maiuscola. Fa match con qualsiasi carattere non appartenente a \s (s minuscola).

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d - d minuscola. Fa match con cifra decimale 0-9.
\D - D maiuscola. Fa match con qualsiasi carattere che non sia una cifra decimale.

# Esempio per \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

Il simbolo + usato dopo \d nell'esempio sopra è usato per le ripetizioni. Lo vedrai più nel dettaglio nella sezione ripetizioni più avanti...

\t - t minuscola. Fa match con tabulazione.
\n - n minuscola. Fa match con newline.
\r - r minuscola. Fa match con return.
\A - A maiuscola. Fa match solo all'inizio della stringa. Funziona anche su più righe.
\Z - Z maiuscola. Fa match solo alla fine della stringa.
CONSIGLIO: ^ e \A sono in pratica equivalenti, così come $ e \Z. Tranne quando si lavora in modalità MULTILINE. Scopri di più nella sezione flag.

\b - b minuscola. Fa match solo con l'inizio o la fine della parola.

# Esempio per \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Esempio per \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Ripetizioni

Diventa piuttosto noioso se stai cercando di trovare pattern lunghi in una sequenza. Per fortuna, il modulo re gestisce le ripetizioni usando i seguenti caratteri speciali:

+ - Verifica se il carattere precedente compare una o più volte a partire da quella posizione.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* - Verifica se il carattere precedente compare zero o più volte a partire da quella posizione.

# Verifica qualsiasi occorrenza di a o o o entrambe nella sequenza data
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? - Verifica se il carattere precedente compare esattamente zero o una volta a partire da quella posizione.

# Verifica esattamente zero o una occorrenza di a o o o entrambe nella sequenza data
re.search(r'Colou?r', 'Color').group()

'Color'

Ma se vuoi controllare un numero esatto di ripetizioni della sequenza?

Per esempio, verificare la validità di un numero di telefono in un'applicazione. Anche questo è gestito molto bene dal modulo re usando le seguenti espressioni regolari:

{x} - Ripeti esattamente x volte.
{x,} - Ripeti almeno x volte o più.
{x, y} - Ripeti almeno x volte ma non più di y volte.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

I qualificatori + e * si dicono greedy. Vedrai cosa significa più avanti.

Raggruppamento nelle espressioni regolari

La funzionalità dei gruppi nelle espressioni regolari ti permette di estrarre parti del testo che fa match. Le parti di un pattern di espressione regolare racchiuse tra parentesi () sono chiamate gruppi. Le parentesi non cambiano ciò che l'espressione intercetta, ma formano gruppi all'interno della sequenza trovata. Hai usato la funzione group() per tutto il tutorial negli esempi. Il semplice match.group() senza argomenti è comunque l'intero testo corrispondente, come al solito.

Capiremo questo concetto con un esempio semplice. Immagina di dover validare indirizzi email e di voler verificare il nome utente e l'host. È qui che vorresti creare gruppi separati all'interno del testo trovato.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # L'intero testo trovato
  print("Username:", match.group(1)) # Lo username (gruppo 1)
  print("Host:", match.group(2)) # L'host (gruppo 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Un altro modo per fare lo stesso è usare invece le parentesi <>. Questo ti permetterà di creare gruppi nominati. I gruppi nominati rendono il tuo codice più leggibile. La sintassi per creare un gruppo nominato è: (?P<name>...). Sostituisci la parte name con il nome che vuoi dare al tuo gruppo. I ... rappresentano il resto della sintassi di match. Vedi questo in azione usando lo stesso esempio di prima...

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

CONSIGLIO: Puoi sempre accedere ai gruppi nominati usando i numeri invece del nome. Ma man mano che il numero di gruppi aumenta, diventa più difficile gestirli solo con i numeri. Quindi, fai sempre l'abitudine di usare i gruppi nominati.

Matching greedy vs non greedy

Quando un carattere speciale fa match con la quantità massima possibile della sequenza (stringa), si dice che è un "Greedy Match". È il comportamento normale di un'espressione regolare, ma a volte questo comportamento non è desiderato:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

Il pattern <.*> ha fatto match con l'intera stringa, fino alla seconda occorrenza di >.

Tuttavia, se volessi fare match solo con il primo tag <h1>, potresti usare il qualificatore non greedy *? che intercetta la minor quantità di testo possibile.

Aggiungere ? dopo il qualificatore fa eseguire il match in modalità non greedy o minimale; ovvero verranno intercettati il minor numero di caratteri possibile. Quando esegui <.*>, otterrai un match solo con <h1>.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Tabella riepilogativa

Hai già fatto molta strada con le espressioni regolari. Ci sono tante informazioni e concetti da assimilare! La tabella seguente riassume tutto ciò che hai visto finora in questo tutorial. Non preoccuparti se non riesci ancora ad afferrare tutti i metacaratteri. Con il tempo e la pratica, riuscirai a cogliere l'unicità di questi caratteri e a capire quando usare cosa...

Questo tutorial non tratta tutte le sequenze speciali fornite in Python. Consulta la documentazione della libreria standard per un elenco completo.

Hai affrontato le basi delle regex! Tuttavia, ci sono altri concetti che possono aiutarti a creare espressioni regolari efficaci per fare ricerca e match.

CONSIGLIO: Sebbene le espressioni regolari siano molto potenti e utili, fai attenzione a espressioni lunghe e confuse, difficili da capire e mantenere nel tempo per gli altri e anche per te.

Funzioni fornite da 're'

La libreria re in Python fornisce diverse funzioni per semplificarti i compiti. Ne hai già viste alcune, come re.search(), re.match(). Vediamone altre...

compile(pattern, flags=0)

Le espressioni regolari sono gestite come stringhe da Python. Tuttavia, con compile() puoi trasformare un pattern di espressione regolare in un oggetto espressione regolare. Quando devi usare un'espressione più volte in un singolo programma, usare compile() per salvare l'oggetto espressione regolare risultante per il riuso è più efficiente che salvarla come stringa. Questo perché le versioni compilate dei pattern più recenti passati a compile() e alle funzioni di matching a livello di modulo vengono messe in cache.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# Questo è equivalente a:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Con questa funzione scorri la stringa/sequenza data cercando la prima posizione in cui l'espressione regolare produce un match. Restituisce un oggetto match corrispondente se trovato, altrimenti restituisce None se nessuna posizione nella stringa corrisponde al pattern. Nota che None è diverso dal trovare un match di lunghezza zero in qualche punto della stringa.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Restituisce un oggetto match corrispondente se zero o più caratteri all'inizio della stringa corrispondono al pattern. Altrimenti restituisce None, se la stringa non corrisponde al pattern dato.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# Nessun match dato che "C" non è all'inizio di "IceCream"
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() versus match()

La funzione match() controlla un match solo all'inizio della stringa (per impostazione predefinita), mentre la funzione search() controlla un match ovunque nella stringa.

findall(pattern, string, flags=0)

Trova tutti i possibili match nell'intera sequenza e li restituisce come lista di stringhe. Ogni stringa restituita rappresenta un match.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' è una lista che memorizza tutti i possibili match
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Simile a findall() - trova tutti i possibili match nell'intera sequenza ma restituisce oggetti match regex come iteratore.

CONSIGLIO: finditer() può essere un'ottima scelta quando vuoi ricevere più informazioni sulla tua ricerca. L'oggetto match regex restituito contiene non solo la sequenza che ha fatto match ma anche le loro posizioni nel testo originale.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' è una lista che memorizza tutti i possibili match
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() è la funzione di sostituzione. Restituisce la stringa ottenuta sostituendo le occorrenze più a sinistra e non sovrapposte del pattern nella stringa con la sostituzione repl. Se il pattern non viene trovato, la stringa viene restituita invariata.

subn() è simile a sub(). Tuttavia, restituisce una tupla contenente la nuova stringa e il numero di sostituzioni eseguite nell'istruzione.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Divide le stringhe ovunque il pattern faccia match e restituisce una lista. Se l'argomento opzionale maxsplit è diverso da zero, viene effettuato al massimo 'maxsplit' numero di divisioni.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Restituisce l'indice di inizio del match.
end() - Restituisce l'indice in cui termina il match.
span() - Restituisce una tupla contenente le posizioni (start, end) del match.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Flag di compilazione

Hai notato il termine re.IGNORECASE nell'ultimo esempio? Ne hai capito l'importanza?

Il comportamento di un'espressione può essere modificato specificando un valore di flag. Puoi aggiungere i flag come argomento extra alle diverse funzioni che hai visto in questo tutorial. Alcuni tra i più utili sono:

IGNORECASE (I) - Consente match case-insensitive.
DOTALL (S) - Consente a . di fare match con qualsiasi carattere, compreso il newline.
MULTILINE (M) - Consente agli ancoraggi di inizio stringa (^) e fine stringa ($) di fare match anche con le newline.
VERBOSE (X) - Consente di scrivere spazi bianchi e commenti all'interno di un'espressione regolare per renderla più leggibile.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Usare il flag VERBOSE aiuta a comprendere espressioni regolari complesse
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

CONSIGLIO: Puoi anche combinare più flag usando l'OR bit a bit |.

Case study: lavorare con le espressioni regolari

Ora che hai visto come funzionano le espressioni regolari in Python studiando alcuni esempi, è il momento di sporcarsi le mani! In questo case study metterai al lavoro tutte le tue conoscenze.

Lavorerai con la prima parte di un e-book gratuito intitolato "L'idiota", scritto da Fëdor Dostoevskij dal Project Gutenberg. Il romanzo parla del principe (Knjaz) Lev Nikolaevič Myškin, un uomo ingenuo la cui natura buona, gentile e semplice porta molti, erroneamente, a credere che gli manchino intelligenza e acume. Il titolo è un riferimento ironico a questo giovane.

Scriverai alcune espressioni regolari per analizzare il testo e completare alcuni esercizi.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Esercizio: Trova il numero del pronome "the" nel corpus. Suggerimento: usa la funzione len().

len(re.findall(r'the', processed_book))

302

• Esercizio: Prova a convertire ogni singola occorrenza isolata di 'i' in 'I' nel corpus. Assicurati di non modificare la 'i' all'interno di una parola:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Esercizio: Trova quante volte qualcuno è stato citato ("") nel corpus.

len(re.findall(r'\”', book))

0

• Esercizio: Quali sono le parole collegate da '--' nel corpus?
  Prova da solo! Sentiti libero di condividere la tua risposta nei commenti qui sotto.

Complimenti!

Sei arrivato alla fine di questo tutorial sulle espressioni regolari in Python! C'è molto altro da esplorare nel tuo percorso di data science con Python.

Le regex possono giocare un ruolo importante nella fase di pre-elaborazione dei dati. Dai un'occhiata al corso di DataCamp Cleaning Data in Python. Questo corso ti insegna modi per esplorare meglio i tuoi dati, riordinandoli e pulendoli per l'analisi. Include anche un case study finale in cui puoi mettere in pratica le nuove conoscenze acquisite.

Dai un'occhiata al nostro Tutorial sulla sostituzione di stringhe in Python.