Espressioni Regolari in Python

Questo articolo spiega le espressioni regolari in Python.

Copriremo una vasta gamma di argomenti, dall'uso base del modulo re fino alla corrispondenza complessa di pattern con espressioni regolari.

YouTube Video

Espressioni Regolari in Python

Il modulo re viene utilizzato per cercare e manipolare stringhe utilizzando espressioni regolari.

Cos'è il modulo re?

Il modulo re è incluso nella libreria standard di Python e offre funzionalità per la manipolazione delle stringhe utilizzando espressioni regolari. Le espressioni regolari vengono utilizzate per trovare, estrarre o sostituire in modo efficiente pattern specifici di stringhe.

Pattern Base delle Espressioni Regolari

Le espressioni regolari definiscono pattern utilizzando simboli speciali. Di seguito sono riportati alcuni pattern di base.

• .: Qualsiasi singolo carattere
• ^: Inizio di una stringa
• $: Fine di una stringa
• \d: Qualsiasi numero (0-9)
• \w: Qualsiasi carattere alfanumerico (a-z, A-Z, 0-9, _)
• \s: Qualsiasi carattere di spazio
• *: Zero o più ripetizioni
• +: Una o più ripetizioni
• []: Classe di caratteri (es. [a-z] corrisponde alle lettere minuscole)

 1import re
 2
 3pattern = r"\d{3}-\d{4}"
 4text = "My postal code is 123-4567."
 5result = re.search(pattern, text)
 6if result:
 7    print(result.group())  # Output: 123-4567
 8
 9# Define a pattern using basic regular expression symbols
10pattern = r"^\w+\s\d+\s[a-zA-Z]+$"
11
12# Example text to test the pattern
13text = "Room 23 Tokyo"
14
15# Check if the pattern matches the text
16result = re.match(pattern, text)
17if result:
18    print("Matched:", result.group())
19else:
20    print("No match")

• Questo codice verifica innanzitutto se la stringa corrisponde a un pattern di codice postale. Successivamente, verifica se l'intera stringa (dall'inizio alla fine) corrisponde a un pattern composto da una parola, uno spazio bianco, cifre, uno spazio bianco e una parola inglese. Questo ti aiuta a capire come si possano combinare gli elementi di base delle espressioni regolari.

Come Utilizzare le Funzioni di Corrispondenza

re.match()

re.match() verifica se l'inizio della stringa corrisponde al pattern specificato.

1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7    print(match.group())  # Output: Python

• Questo codice verifica se la stringa inizia con un carattere di parola (alfanumerico o trattino basso). La prima parola 'Python' corrisponde al pattern e viene restituita in output.

re.search()

re.search() scansiona l'intera stringa e restituisce la prima corrispondenza.

1import re
2
3pattern = r"powerful"
4text = "Python is powerful and versatile"
5search = re.search(pattern, text)
6if search:
7    print(search.group())  # Output: powerful

• Questo codice cerca nell'intera stringa la parola 'powerful' e restituisce la prima corrispondenza. Di conseguenza, re.search() produce in output la stringa corrispondente 'powerful'.

re.findall()

re.findall() restituisce tutte le corrispondenze del modello come una lista.

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.findall(pattern, text)
6print(matches)  # Output: ['Python', 'strong']

• Questo codice trova tutte le parole lunghe esattamente sei caratteri e le restituisce come lista. 'Python' nella stringa soddisfa la condizione e viene prodotta la lista ['Python'].

re.finditer()

re.finditer() restituisce tutte le corrispondenze come un iteratore, consentendo di recuperare informazioni dettagliate per ogni corrispondenza.

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.finditer(pattern, text)
6for match in matches:
7    print(match.group())  # Output: Python

• Questo codice cerca in sequenza tutte le parole di sei lettere ed elabora ogni corrispondenza tramite un iteratore. 'Python' qui corrisponde al pattern e viene restituito in output.

Sostituzione e Divisione

re.sub()

re.sub() sostituisce le parti della stringa che corrispondono all'espressione regolare con un'altra stringa.

1import re
2
3pattern = r"\d+"
4text = "There are 100 apples"
5new_text = re.sub(pattern, "many", text)
6print(new_text)  # Output: There are many apples

• Questo codice sostituisce tutte le cifre nella stringa con 'many'.

re.split()

re.split() divide la stringa nei punti che corrispondono all'espressione regolare.

1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts)  # Output: ['Python', 'is', 'powerful']

• Questo codice divide la stringa in corrispondenza di uno o più caratteri di spazio bianco. Di conseguenza, la stringa viene suddivisa in parole, ottenendo ['Python', 'is', 'powerful'].

Gruppi e Catture

Utilizzare i raggruppamenti delle espressioni regolari semplifica l'estrazione delle sottostringhe corrispondenti. Racchiudendolo tra parentesi () lo si cattura come un gruppo.

1import re
2
3pattern = r"(\d{3})-(\d{4})"
4text = "My postal code is 123-4567."
5match = re.search(pattern, text)
6if match:
7    print(match.group(1))  # Output: 123
8    print(match.group(2))  # Output: 4567

• Questo codice estrae i numeri a 3 cifre e a 4 cifre come gruppi separati da un codice postale nella forma '123-4567'. group(1) restituisce le prime tre cifre '123' e group(2) restituisce le ultime quattro cifre '4567'.

Gruppi denominati

Usare gruppi denominati consente di recuperare i valori tramite nomi significativi invece di fare affidamento sugli indici. Di seguito un esempio concreto che estrae la data e il livello da un log.

1import re
2
3log = "2025-10-25 14:00:01 [ERROR] Something failed"
4
5pattern = r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) \[(?P<level>[A-Z]+)\] (?P<msg>.*)"
6m = re.search(pattern, log)
7if m:
8    print(m.group("date"), m.group("time"), m.group("level"))
9    print("message:", m.group("msg"))

• Questo codice usa gruppi denominati per estrarre data, ora, livello e messaggio da una stringa di log. Recupera i valori usando nomi significativi invece che indici.

Utilizzo delle Opzioni di Flag

Il modulo re ha diverse opzioni di flag per controllare il comportamento della ricerca.

• re.IGNORECASE (re.I): Un'opzione di flag che rende la corrispondenza non sensibile alle maiuscole e minuscole.
• re.MULTILINE (re.M): Un'opzione di flag che consente la corrispondenza su più righe.
• re.DOTALL (re.S): Un'opzione di flag in cui il punto . corrisponde anche ai caratteri di nuova linea.

1import re
2
3pattern = r"python"
4text = "Python is powerful"
5match = re.search(pattern, text, re.IGNORECASE)
6if match:
7    print(match.group())  # Output: Python

• Questo codice cerca la parola 'python' senza distinzione tra maiuscole e minuscole. Usando il flag re.IGNORECASE, corrisponde anche a 'Python'.

Vantaggi degli oggetti di espressione regolare (re.compile)

Compilare un pattern con re.compile ne rende il riutilizzo più efficiente e migliora la leggibilità. Qui puoi anche impostare dei flag.

Il seguente esempio cerca ripetutamente corrispondenze su più righe usando un pattern compilato. Se usi spesso lo stesso pattern, compilarlo con re.compile migliora le prestazioni.

1import re
2
3pattern = re.compile(r"User: (\w+), ID: (\d+)")
4text = "User: alice, ID: 1\nUser: bob, ID: 2"
5
6for m in pattern.finditer(text):
7    print(m.groups())

• Questo codice usa un'espressione regolare compilata per estrarre nomi utente e ID da più righe. re.compile migliora l'efficienza quando si riutilizza lo stesso pattern e rende anche il codice più leggibile.

Applicazioni

Ad esempio, considera uno script che estrae tutti gli indirizzi email da un file di testo.

1import re
2
3pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
4text = "Contact us at info@example.com or support@service.com."
5emails = re.findall(pattern, text)
6print(emails)  # Output: ['info@example.com', 'support@service.com']

• Questo codice trova tutti gli indirizzi email nella stringa e li estrae come lista.

Conclusione

Il modulo re è uno strumento potente per la manipolazione delle stringhe in Python. Qui abbiamo trattato una vasta gamma di argomenti, dall'uso di base fino alle espressioni regolari avanzate utilizzando raggruppamenti e opzioni di flag. Le espressioni regolari in Python sono molto potenti e uno strumento indispensabile per l'elaborazione del testo.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video