I Metodi disponibili per la Ricerca

Il modulo re fornisce anche le funzioni corrispettive dei metodi (in effetti tali funzioni non fanno altro che compilare la RE e chiamare i metodi corrispondenti). Vale la pena di usare direttamente le funzioni solo nel caso si tratti di RE isolate e non ripetute (tra l'altro le RE usate in tal modo vengono tenute in una cache in modo da non dover essere ricompilate al volo alla prossima invocazione). Di solito è molto più comodo e pulito costruire l'oggetto istanza tramite compile.

I metodi principali sono match e search. In cosa si differenziano?

match

restituisce un'istanza di MatchObject se zero o più caratteri all'inizio della stringa corrispondono al pattern. È comunque possibile specificare una posizione da cui iniziare la ricerca diversa dalla testa della stringa, e anche un limite superiore. Restituisce None se la stringa non corrisponde al pattern.

search

scandisce la stringa cercando una corrispondenza con il pattern e restituisce l'istanza MatchObject corrispondente. Restituisce None se in nessuna posizione la stringa corrisponde al pattern. Anche qui è possibile specificare un punto d'inizio e di termine per la ricerca come per match.

L'oggetto restituito MatchObject possiede i seguenti metodi

split

in breve divide la stringa secondo le occorrenze del pattern e restituisce le porzioni ottenute come lista.

escape

prende in ingresso una stringa e la restituisce con i caratteri alfanumerici protetti da barre oblique inverse.

sub

restituisce la stringa ottenuta sostituendo alle occorrenze non sovrapposte del pattern l'entità rimpiazzo, che può essere una stringa o una funzione, eventualmente per un numero di volte prefissato.

L'oggeto di ritorno di search, possiede i seguenti utili metodi

start

restituisce la prima posizione del match

end

restituisce la posizione finale del match

span

restituisce gli estremi del punto di partenza e fine dell match (= (p.start(),p.end()))

Tutto quanto sopra esposto può sembrare oscuro, ma in realtà l'utilizzo è di gran lunga più semplice della descrizione. Per esempio

>>> import re
>>> # un pattern che parte da 'atg' e finisce con taa  
>>> pat = re.compile('atg[acgt]*taa') # crea un pattern 
>>> s='atgtaa'       
>>> res=pat.search(s) # cerca il pattern
>>> res               # oggetto
<SRE_Match object at 0x81310b8>
>>> dir(res)  # metodi dell'oggetto
['end', 'expand', 'group', 'groupdict', 'groups', 'span', 'start']
>>> s[res.start():res.end()]  # indice partenza, fine
'atgtaa'
>>> s='tgttatggcgcgcacgtaaatg' # nuova sequenza
>>> res=pat.search(s)          # cerca
>>> s[res.start():res.end()]   # 
'atggcgcgcacgtaa'
>>> res.span(),res.start(),res.end() # res.span() == (res.start(),res.end())
((4, 19), 4, 19)
>>>
>>> s='atgccctaaatgaaaccctaa' # 3 possibili matches 
>>> res=pat.search(s)        # cerca il + lungo
>>> res.span()               # intervallo esterno
(0, 21)
>>> s[res.start():res.end()]
'atgccctaaatgaaaccctaa'
>>> pat = re.compile('atg[acgt]{0,}?taa') # il minimo match
>>> res=pat.search(s)      # cerca
>>> res.span()             # intervallo minimo
(0, 9)
>>> s[res.start():res.end()]
'atgccctaa'
>>> t='atgcccg' # stringa che non ha match
>>> pat.search(t)
>>> res=pat.search(t) # ritorna None
>>> res == None
1
>>> # prendiamo il caso di match alternativo taa tag tga
>>> pat=re.compile('atg[acgt]{0,}?(taa|tag|tga)') # il minore intervallo
>>> s='gcgcgcatggctttagcaggttaattt'
>>> res=pat.search(s)
>>> res.span()
(6, 16)
>>> s[res.start():res.end()]
'atggctttag'
>>> s='gcgcgcatggtaactttagcaggttaattt' # inseriamo taa prima di tag 
>>> res=pat.search(s)
>>> res.span()
(6, 13)
>>> s[res.start():res.end()]
'atggtaa'