Python Standard Library. Espressioni Regolari

Transcript

1 Python Standard Library Espressioni Regolari

2 Espressioni Regolari Un'espressione regolare (regular expression o regex) è una sequenza di caratteri che identifica un insieme di stringhe. Sono un potente strumento che consente di trovare, estrarre e sostituire parti di testo all'interno di un documento. Benché siano state formalizzate dal punto di vista puramente matematico fin dagli anni quaranta, è con l'avvento dei sistemi UNIX che comparirono i primi tool basati sulle espressioni regolari (tra cui un precursore dell'attuale grep).

3 Esempi di regex [-+]?[0-9]+ Trova tutti i numeri interi con segno. ^.*\.txt$ Trova tutti i file che hanno estensione txt. \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} Trova gli indirizzi IPv4. ^4[0-9]{12}(?:[0-9]{3})?$ Trova numeri di carte di credito.

4 Le regex più semplici Nella loro forma più semplice, una regex è una sequenza di caratteri alfanumerici. abc ad esempio, trova la stringa 'abc'. Le espressioni regolari, di norma, sono case sensitive. La regex di prima infatti troverà la stringa 'abc', ma non la stringa 'Abc' o 'abc'. Le regex possono, tramite regole opportune, trovare qualsiasi carattere, compresi gli altri caratteri ASCII ('~', ' ') e persino quelli Unicode ('è', '1', ' '). Bisogna tuttavia porre attenzione al fatto che alcuni caratteri hanno una funzione particolare nel linguaggio delle regex.

5 Notazione Le espressioni regolari saranno sempre indicate in carattere monospaced. Per indicare che una regex trova un determinato insieme di stringhe verrà utilizzato il simbolo. L'insieme di stringhe trovate da una regex seguono la consueta notazione insiemistica. Un insieme illimitato è delimitato dai puntini di sospensione. abc {'abc'}

6 Quantificatore * * Detto anche stella di Kleene, serve per trovare famiglie di stringhe che hanno da 0 a N ripetizioni di uno stesso carattere. ab*c {'ac', 'abc', 'abbc', 'abbbc', } I quantificatori si riferiscono sempre al carattere immediatamente precedente.

7 Quantificatori + e? + Identico a *, ma le ripetizioni ammesse sono da 1 a N, e non da 0 a N.? ab+c {'abc', 'abbc', 'abbbc', } Ammette l'opzionalità del carattere precedente (può essere presente 0 o 1 volta). ab?c {'ac', 'abc'}

8 Operatore \ \ Effettua l'escaping del carattere precedente, se esso è un carattere particolare. a** Non valida a\** {'a', 'a*', 'a**', 'a***', } a*\* {'*', 'a*', 'aa*', 'aaa*', } a\*\* {'a**'} a\c Non valida a\\c {'a\c'}

9 Gruppi In realtà non è vero che gli operatori si applicano al carattere precedente: è più corretto dire che si applicano al token precedente. Un token, nel caso più semplice, è un carattere, ma può essere anche un gruppo o una classe di caratteri. In particolare, un gruppo di caratteri è una stringa delimitata dalle parentesi tonde. a(bc)*d {'ad', 'abcd', 'abcbcd', } Nell'esempio precedente, il token su cui è applicata la stella di Kleene è (bc). L'ordine dei caratteri all'interno del gruppo è importante! a(cb)*d {'ad', 'acbd', 'acbcbd', }

10 Operatore Specifica alternative all'interno di un gruppo. gr(a e)y {'gray', 'grey'} In un gruppo possono essere presenti più alternative in qualsiasi ordine, e le alternative sono stringhe di qualsiasi lunghezza. (cla repl gu)y {'clay', 'reply', 'guy'} È inoltre possibile specificare la stringa vuota come alternativa: (na )y {'y', 'nay'}

11 Classi Esiste un modo più pratico per trovare alternative di singoli caratteri, ossia definire una classe di caratteri. Una classe di caratteri è un insieme non ordinato di caratteri in alternativa tra di loro delimitato da parentesi quadre. La regular expression gr(a e)y può essere dunque riscritta come: gr[ae]y {'gray', 'grey'}

12 Classi I quantificatori visti finora perdono di significato se sono inseriti all'interno di una classe, eccetto l'operatore \. a[-+*\\]b {'a+b', 'a-b', 'a*b', 'a\b'} Una classe di caratteri è anche essa un token su cui è possibile applicare un quantificatore. a[cd]?b {'ab', 'acb', 'adb'} Lo spazio è un carattere ammesso. a[ _]b {'a_b', 'a b'}

13 Intervalli Il carattere - definisce un intervallo di caratteri all'interno di una classe. Esso è utilizzabile solamente per definire intervalli di caratteri alfanumerici, sia uppercase che lowercase: se usato singolarmente si comporta come un normale carattere. 1[0-4] {'10', '11', '12', '13', '14'} [A-Za-z]* una qualsiasi sequenza di lettere [+-]?17 {'17', '+17', '-17'}

14 Negazione Il carattere ^, se posto all'inizio di una classe, specifica che la classe rappresenta i caratteri che NON devono essere presenti. Perde questo significato se è non è il primo carattere di una classe. 1[^0-4] {'15', '16', '1a', '1T', } a[&^ ]b {'a&b', 'a^b', 'a b'}

15 Classi speciali. Trova qualsiasi carattere eccetto il newline '\n'. \d. {'a', 'b', '4', '&', } Trova caratteri numerici. Include [0-9] ma anche tutti i caratteri non-ascii riconducibili a numeri. \d {'0', '1', '2', '3', '0', }

16 Classi speciali \s Trova whitespace. Include [ \t\n\r\f\v] e tutti i caratteri whitespace speciali Unicode. \w Trova caratteri alfanumerici. Include [A-Za-z0-9_] ma anche tutti i caratteri non-ascii riconducibili a numeri o lettere. \w {'a', 'T', '9', 'è', '1', '_', }

17 Classi speciali Esistono anche le classi duali di \d, \w, e \s, e sono rispettivamente \D, \W, \S. Esse trovano esattamente i caratteri complementari alle classi base: \D trova tutti i caratteri che non sono numeri. \W trova tutti i caratteri che non sono numeri né lettere. \S trova tutti i caratteri non whitespace. \W {'#', '[', '+', '.', ' ', }

18 Classi speciali Le classi speciali \d, \w, e \s, e le loro duali possono essere utilizzate all'interno di altre classi. [\dab] {'0', '1', '2',, 'a', 'B'} Il punto all'interno di una classe invece vale sempre e solo come carattere, non come classe. [^.] tutti i caratteri tranne '.'

19 Quantificatori greedy e lazy Di norma, i quantificatori sono sempre greedy, ossia cercano di trovare quanti più caratteri possibili. A volte questo comportamento non è quello desiderato. Immaginiamo di volere estrarre il nome del tag dal seguente frammento di HTML: <div>some paragraph</div>

20 Quantificatori greedy e lazy <div>some paragraph</div> Regex pattern: <.*> Sappiamo che il punto trova qualsiasi carattere eccetto il newline. Il problema è che anche '>' è un carattere! È quindi perfettamente logico che venga incluso nella stringa trovata.

21 Quantificatori greedy e lazy La soluzione al problema è rendere il quantificatore lazy, facendogli catturare la minor quantità di caratteri possibili che soddisfano l'espressione regolare. Per specificare che un quantificatore è lazy si usa il punto interrogativo. <div>some paragraph</div> Regex pattern: <.*?>

22 Ancore Quando si ricerca una pattern all'interno di una stringa, a volte è utile specificare esplicitamente dove questa pattern deve essere collocata all'interno del testo. hear ya, hear ya Regex pattern: hear Esistono degli operatori, chiamati ancore (anchors), che vincolano la posizione delle sequenze di caratteri trovate.

23 Ancore ^ Vincola la posizione della sequenza di caratteri trovata all'inizio della stringa. $ hear ya, hear ya Regex pattern: ^hear Vincola la posizione della sequenza di caratteri trovata alla fine della stringa. hear ya, hear ya Regex pattern: ya$

24 Modulo re Python permette, tramite il suo modulo re, di utilizzare il motore delle espressioni regolari.

25 re.search re.search(pattern, string, flags=0) Cerca in string la pattern regex specificata. flags è un intero che modifica il comportamento della funzione. Il suo valore di ritorno è un Match object. >>> html = '<div>another paragraph</div>' >>> re.search('<.*?>', html) <_sre.sre_match object at 0x1ab06a0>

26 Match object Contengono varie informazioni sulle stringhe trovate. Sono convertibili automaticamente al booleano True: match = re.search(pattern, string) if match: process(match) I match object possono essere usati per accedere alle stringhe trovate corrispondenti ai vari gruppi.

27 match.group match.group([group1, ]) Restituisce una o più stringhe trovate corrispondenti a uno o più gruppi. Chiamata senza argomenti è equivalente a chiamare match.group(0). Se uno dei groupn è 0, il valore corrispondente sarà l'intera stringa trovata. Se vengono passati più gruppi come parametri, restituisce una tupla contenente tutte le stringhe relative a quei gruppi.

28 Esempio >>> import re >>> text = "Isaac Newton, physicist" >>> m = re.match(r"(\w+) (\w+)", text) >>> m.group() 'Isaac Newton' >>> m.group(1) 'Isaac' >>> m.group(0, 2) ('Isaac Newton', 'Newton')

29 Raw strings Per evitare di inserire troppi caratteri di escape, in python è possibile dichiarare una stringa come raw string. Le raw string si dichiarano mettendo la lettera r prima della stringa. >>> r'hello!\n' 'Hello!\\n'

30 match.groups match.groups(default=none) Restituisce una tupla contenente tutte le stringhe trovate dai vari gruppi. default è usato quando un gruppo opzionale non è presente nella stringa d'origine. >>> import re >>> m = re.match(r"(\d+)\.?(\d+)?", "24") >>> m.groups() ('24', None) >>> m.groups('0') ('24', '0')

31 re.sub re.sub(pattern, repl, string, count=0, flags=0) Sostituisce in string la pattern regex specificata con la stringa repl fino ad un massimo di count volte. Se count è 0 sostituisce tutte le occorrenze di pattern con repl. flags è un intero che modifica il comportamento della funzione. >>> html = '<div>another paragraph</div>' >>> re.sub('(</ <).*?>', r'\1span>', html) ' <span>another paragraph</span>'

32 Backreference La \1 nell'esempio è chiamata backreference. Viene sostituita durante l'elaborazione con la stringa trovata dalla pattern specificata nel primo gruppo. \1 assumerà il valore corrispondente alla stringa che viene trovata dalla pattern del primo gruppo. <div>another paragraph</div> Regex pattern: (</ <).*?> Match: <div> \1 = '<' Match: </div> \1 = '</' Se sono definiti più gruppi, è possibile usare la backreference \i (ove i è un numero) per ricavare il valore dell'i-esimo gruppo.

33 re.split re.split(pattern, string, maxsplit=0, flags=0) Divide string in frammenti usando come divisore pattern, creando al massimo maxsplit frammenti. Se maxsplit è 0 invece divide la stringa il più possibile. flags è un intero che modifica il comportamento della funzione. Restituisce una lista di stringhe corrispondenti ai frammenti.

34 Esempio >>> import re >>> text = 'Words, words, words.' >>> re.split('\w+', text) ['Words', 'words', 'words', ''] >>> re.split('\w+', text, 1) ['Words', 'words, words.']

35 Alcune flag re.dotall (re.s) Il. trova anche i caratteri newline '\n'. re.multiline (re.m) La ricerca viene effettuata su ogni linea della stringa, non una volta sola. re.ignorecase (re.i) Ignora il case delle lettere presenti in pattern.

36 Alcune flag re.unicode (re.u) Le classi \w, \d, \s e duali trovano, oltre ai caratteri ASCII corrispondenti, anche eventuali caratteri Unicode equivalenti.! In python 3 è il comportamento di default, quindi non è necessario specificarlo. re.ascii (re.a) Le classi \w, \d, \s e duali trovano solamente caratteri ASCII.! In python 2 è il comportamento di default, e questa flag non esiste.

37 re.compile re.compile(pattern, flags=0) È possibile compilare una pattern in un oggetto regex. Questo è utile se si pensa di riutilizzare la stessa regex pattern più di una volta. flags ha lo stesso significato dei metodi Sull'oggetto regex è possibile chiamare i metodi search, sub e split. >>> import re >>> regex = re.compile(pattern) >>> regex.search(text)

38 Esercizio: iwget iwget è un'utilità a riga di comando che scarica tutte le immagini di una pagina web. Per farlo dobbiamo compiere i seguenti passi: 1. Accettare l'url della pagina web da riga di comando. 2. Scaricare la pagina (X)HTML corrispondente all'url. 3. Leggere il contenuto di tutti gli attributi src delle tag img, tenendo presente che l'(x)html non sempre è ben formato. 4. Per ogni match, scaricare l'immagine in una qualsiasi cartella locale.

39 Esercizio: iwget Per svolgere questo esercizio abbiamo bisogno di una libreria che consente di scaricare pagine web. Non è tuttavia parte del corso spiegare come utilizzarla. La soluzione? Documentazione ufficiale!