Cercare una parola in un testo è semplice:
ma … come fare per ricerche più complesse?
- le parole che terminano in ‘ato’
- tutte e sole le sequenze di numeri che formano una data
- le frasi che incominciano con la parola ‘il’ e terminano con la parola ‘spesso’
- le linee di testo che non iniziano con una lettera maiuscola
- le parole di almeno 4 lettere e non più di 10, la cui seconda sia una ‘a’
Regex
Le espressioni regolari (chiamate RE, o regex o pattern regex) sono essenzialmente un piccolo linguaggio di programmazione altamente specializzato incorporato in Python e reso disponibile tramite il modulo re. Usando questo piccolo linguaggio, possiamo specificare le regole per l’insieme di possibili stringhe che vogliamo verificare;
Possiamo quindi rispondere a domande del tipo “Questa stringa corrisponde al modello?” o “C’è una corrispondenza per il modello in qualche punto di questa stringa?”. Possiamo anche usare le RE per modificare una stringa o per dividerla in vari modi.
E’ un linguaggio standard per caratterizzare stringhe di testo definito da Kleene nel 1956.
• Strumento ideale per
– ricercare testo
– sostituire testo
• Molti programmi supportano le RE:, per esempio “Trova e Sostituisci” in Word.
Cos’è un pattern (modello)
Un’espressione regolare può essere suddivisa in:
- caratteri ordinari: trovano una corrispondenza diretta nelle stringhe dell’insieme specificato.
- metacaratteri: caratteri speciali che assumono caratteristiche di controllo sui caratteri ordinari.
Lista dei metacaratteri:
[ ] \ { } | ( ) ^ ? + * .
| Metacarattere | Descrizione |
|---|---|
| . | indica qualsiasi carattere (escluso un accapo) |
| * | indica zero o più occorrenze (di un carattere o di un gruppo di caratteri) |
| ? | indica zero o una occorrenza (di un carattere o di un gruppo di caratteri) |
| {} | le parentesi graffe, che indicano il numero esatto, o minimo, o massimo, o l’intervallo di occorrenze (di un carattere o di un gruppo di caratteri) |
| + | indica una o più occorrenze (di un carattere o di un gruppo di caratteri) |
| ^ | indica l’inizio della stringa (o, se all’interno di una classe di caratteri, la negazione della stessa) |
| $ | indica la fine della stringa |
| | | indica l’operatore OR |
| \ | il carattere di escape dei caratteri speciali |
| () | le parentesi tonde, destinate a contenere una sottostringa |
| [] | le parentesi quadre, destinate a contenere una ‘classe’ di caratteri |
Caratteri e sequenze di caratteri
Un qualsiasi carattere o sequenza di caratteri (lettere, numeri, punteggiatura, spazi, ritorno‐a‐capo, caratteri speciali) è una RE
• le RE sono “case sensitive”
Classe di caratteri
Classi di negazione
Un segno di omissione (^) dopo la parentesi quadra di apertura funziona come una negazione dei caratteri che lo seguono. Questo corrisponderà a tutti i caratteri che non sono nella classe di caratteri.
Dentro una classe di caratteri è possibile specificare che un pattern non deve contenere un certo carattere usando il segno ‘^’:
– [^2] qualsiasi carattere diverso da 2
Esempio:
Supponiamo di avere una lista di squadre, chiamate così: Squadra A , Squadra B , …, Squadra Z
• Squadra [AB] : Questo corrisponderà alla Squadra A o alla Squadra B
• Squadra [^AB] : Questo corrisponderà a qualsiasi squadra eccetto la Squadra A o la Squadra B
Corrispondenza non-alfanumerici (classe di caratteri negata)
[^0-9a-zA-Z]
Corrispondenza senza cifre (classe di caratteri negata)
[^0-9]
ESEMPIO 1:
import re#Formiamo la queryquery=input("query>>")query=query.strip().split()query="+".join(query)def check(pattern,test_str): if re.search(pattern, test_str): print ( 'Valido : %r' % (test_str,)) else: print ( 'non Valido : %r' % (test_str,)) #il pattern fornitopattern = '[ztv]'check(pattern,query) #il pattern fornito
pattern = '[fav]'check(pattern,query)non Valido : ‘facile’
Valido : ‘facile
ESEMPIO 2:
import re#Formiamo la queryquery=input("query>>")query=query.strip().split()query="+".join(query)def check(pattern,test_str): #re.search ritorna None se non viene trovata nessuna posizione nella stringa che verifica #il pattern fornito if re.search(pattern, test_str): print ( 'Valido : %r' % (test_str,)) else: print ( 'Non Valido : %r' % (test_str,))#pattern per cercare tutti i caratteri diversi da: . a-z 0-9pattern = r'[^\.a-z0-9]'check(pattern,query)# verifichiamo se la stringa NON CONTIENE 'gl'pattern = '[^[gl]]'check(pattern,query)# verifichiamo se la stringa NON CONTIENE 'fa'pattern = '[ ^[fa]]'check(pattern,query)# verifichiamo se la stringa INIZIA PER 'fa'pattern = '[ ^ fa]'check(pattern,query)Non Valido : ‘famiglia’
Non Valido : ‘famiglia’
Non Valido : ‘famiglia’
Valido : ‘famiglia’
‘^’ ha valore negativo solo quando compare subito dopo la’[‘ :
La classe di caratteri negata è denotata da [^..] . Il segno di omissione ^ indica che deve corrispondere qualsiasi carattere tranne quello presente nella classe di caratteri. per esempio [^cat] significa che corrisponde a qualsiasi carattere tranne c o a o t .
l significato del segno di caret ^ esegue la mappatura alla negazione solo se si trova all’inizio della classe di caratteri. Se è altrove nella classe di caratteri, viene trattato come carattere letterale senza alcun significato speciale.
Leggi anche :
👉 Guida alle espressioni regolari: le funzioni re.search, re.findall e re.finditer
(448)