Py a5 python-text

Text Processing in Python
Python è un linguaggio molto potente per la
manipolazione e la gestione di informazioni
testuali
In questa lezione:
Ripassi / approfondimenti sulle stringhe:
semplici operazioni sul testo
Espressioni regolari: un potente strumento di
text processing, anche in Python

Linguaggi dinamici – A.A. 2009/2010
2

Rappresentazione di stringhe
Ogni stringa è memorizzata nella memoria del
calcolatore come una lista di caratteri.

myString = “GATTACA”

myString

3

Accesso ai singoli caratteri
E’ possibile accedere ai singoli caratteri
utilizzando gli indici tra parenteisi quadre.
myString[0]
‘G’
myString[1]
‘A’
myString[-1] Gli indici negativi iniziano
‘A’ dalla fine della stringa e
myString[-2] crescono verso sinistra
‘C’
myString[7]
Traceback (most recent call last):
File stdin, line 1, in ?
IndexError: string index out of range
4

Accesso alle sottostringhe
myString[1:3]
‘AT’
myString[:3]
‘GAT’
myString[4:]
‘ACA’
myString[3:5]
‘TA’
myString[:]
‘GATTACA’

5

Alcuni operatori utili

len(“GATTACA”) Lunghezza
7
“GAT” + “TACA”
Concatenazione
‘GATTACA’
“A” * 10
‘AAAAAAAAAA Ripetizione
“GAT” in “GATTACA”
True Test di sottostringa
“AGT” in “GATTACA”
False

7

ESEMPI:
string.py
Alcuni esempi di metodi stringa
GATTACA.find(ATT)
1
GATTACA.count(T)
2
GATTACA.lower()
'gattaca'
gattaca.upper()
'GATTACA'
GATTACA.replace(G, U)
'UATTACA‘
GATTACA.replace(C, U)
'GATTAUA'
GATTACA.replace(AT, **)
'G**TACA'
GATTACA.startswith(G)
True
GATTACA.startswith(g)
False
8

ESEMPI:
splitjoin.py
Split e join
split è utilizzato per suddividere una stringa
in una sequenza di elementi
'1+2+3+4+5'.split('+’)
['1', '2', '3', '4', '5']
'Using the default'.split()
['Using', 'the', 'default']
join è utilizzato per unire una sequenza di
stringhe
seq = ['1', '2', '3', '4', '5']
sep = '+'
sep.join(seq)
'1+2+3+4+5'

9

strip
strip (s[, chars]) restituisce una copia della
stringa con i caratteri iniziali e finali rimossi
se chars non è specificato, vengono rimossi i
caratteri di whitespace
utile per “ripulire” le stringhe
' spacious '.strip()
'spacious’
'www.example.com'.strip('cmowz.')
'example'

10

Le stringhe sono immutabili
Attenzione: le stringhe non possono essere
modificate
Per la modifica è necessario crearne di nuove
s = GATTACA
s[3] = C
Traceback (most recent call last):
File stdin, line 1, in ?
TypeError: object doesn't support item assignment
s = s[:3] + C + s[4:]
s
'GATCACA'
s = s.replace(G,U)
s
'UATCACA'
11

Le stringhe sono immutabili

Attenzione: i metodi stringa non modificano
la stringa, ma ne restituiscono una nuova
sequence = “ACGT”
sequence.replace(“A”, “G”)
‘GCGT’
print sequence
ACGT

sequence = “ACGT”
new_sequence = sequence.replace(“A”, “G”)
print new_sequence
GCGT

12

ESEMPI:
generators.py
Generatori
I generatori sono uno strumento molto utile,
anche per la lettura ed elaborazione di testo
da file
Modo semplice e potente per creare degli
iteratori
Scritti come normali funzioni, ma utilizzano
yield per restituire i dati
Ogni volta che è chiamato next, il generatore
continua da dove era rimasto
Ad esempio:
def lines(file): # restituisce il contenuto di file seguito da n
for line in file: yield line
yield 'n’
13

Espressioni regolari

Some people, when confronted with a
problem, think “I know, I’ll use regular
expressions.” Now they have two problems.

—Jamie Zawinski

14

Espressioni regolari
Come sappiamo, ben oltre i metodi stringa,
le espressioni regolari sono un potente
mezzo di elaborazione del testo
Python include un ricco pacchetto per la
gestione di espressioni regolari: re
Si utilizzano espressioni regolari per:
Eseguire ricerche (search e match)

Sostituire parti di una stringa(sub)
Spezzare una stringa in più parti(split)
...

15

Sintassi delle espressioni regolari
La maggior parte dei caratteri fa match con
se stessa
Ad esempio, l’espressione regolare “test”
fa match con la stringa ‘test’, e solo con
quella
[x] fa match con un qualunque carattere
della lista x
“[abc]” fa match con ‘a’,‘b’ o ‘c’
[^x] fa match con un qualunque carattere
non incluso in x
“[^abc]” fa match con qualunque carattere
eccetto ‘a’,’b’,o ‘c’
16


“.” fa match con ogni carattere singolo
Le parentesi sono utilizzate per i gruppi
“(abc)+” fa match con ’abc’, ‘abcabc’,

‘abcabcabc’, etc.
x|y fa match con x o y
“this|that” fa match con ‘this’ e ‘that’, ma

non ‘thisthat’.

17


x* fa match con zero o più x
“a*” fa match con ’’, ’a’, ’aa’, etc.

x+ fa match con una o più x
“a+” fa match con ’a’,’aa’,’aaa’, etc.

x? fa match con zero o una x
“a?” fa match con ’’ o ’a’

x{m, n} fa match con i x, dove m i n
“a{2,3}” fa match con ’aa’ o ’aaa’

18

“d” fa match con una cifra
“D” fa match con una non-cifra

“s” fa match con un carattere whitespace
“S” fa match con un carattere non-whitespace

“w” fa match con un carattere alfanumerico
“W” fa match con un carattere non alfanumerico

“^” fa match con l’inizio della stringa
“$” fa match con la fine della stringa

“b” fa match con un word boundary
“B” fa match con una posizione che non è un

word boundary
19

Escaping di caratteri speciali
Attenzione ai caratteri speciali!
'python.org’ fa match con 'python.org’ ma anche
con ‘pythonzorg’, ecc.
Per fare in modo che un carattere speciale si
comporti da carattere normale, occorre farne
l’escaping (carattere di backslash anteposto):
'python.org’ fa match con 'python.org’.

20

Escaping di caratteri speciali
Per quanto rigaurda gli insiemi di caratteri,
l’escaping è possibile ma non necessario.
Attenzione però ai seguenti casi:
E’ necessario l’escaping di (^) se compare
all’inizio del set e non si vuole intenderlo come
operatore di negazione.
Altrettanto, (]) e (-) devono essere posti all’inizio
del set oppure deve esserne fatto l’escaping

21

Stringhe “raw”
Una pratica alternativa all’escaping all’interno di
stringhe è di utilizzare le cosiddette raw string:
‘Questa è una stringa’
r‘Questa è una stringa raw’
Una stringa raw ha sempre una r anteposta
Ad esempio, senza una stringa raw:
print 'C:nowhere’
C:nowhere
Con una stringa raw:
print r'C:nowhere’
C:nowhere
Ovviamente, rimane necessario l’escaping delle virgolette!
22

Esempi di utilizzo di stringhe “raw”
Supponiamo di voler scrivere una RE che
indichi le corrispondenze della stringa
section, tipico comando LATEX
Quindi, senza utilizzare stringhe raw, dovremmo
seguire i seguenti passi:
section Stringa di testo di cui cercare la
corrispondenza
section Protezione del backslash per
re.compile
section Protezione del backslash per una
stringa costante

23

Esempi di utilizzo di stringhe “raw”
Invece, utilizzando stringhe “raw”, i backslash
non sono gestiti in nessun modo speciale se si
trovano in una stringa costante che ha il
prefisso r”
Quindi:
Stringa stringa “raw”
section rsection
ab* rab*”
w+s+1 rw+s+1

24

modulo re: alcune funzioni importanti
search(pattern, string[, flags])
Effettua la ricerca di pattern in string
match(pattern, string[, flags])
fa match con pattern all’inizio di string

split(pattern, string[, maxsplit=0])
Suddivide string in base alle occorrenze di

pattern
findall(pattern, string)
Restituisce una lista di tutte le occorrenze di

pattern in string

25

modulo re: alcune funzioni importanti
sub(pat, repl, string[, count=0])
Sostituisce con repl tutte le occorrenze di pat in
string
compile(pattern[, flags])
Crea un oggetto pattern da una stringa con una
regexp
escape(string)
Effettua l’escaping di tutti i caratteri speciali di
string

26

Search e Match
Le due funzioni principali sono re.search e
re.match
search ricerca un pattern ovunque nella stringa
match effettua la ricerca solo a partire dall’inizio della
stringa
Restituiscono None se il pattern non è trovato e
un “match object” se lo è
pat = a*b
import re
re.search(pat,fooaaabcde)
_sre.SRE_Match object at 0x809c0
re.match(pat,fooaaabcde)

27

Gruppi
Questo è un pattern che fa match con alcuni
comuni indirizzi email:
w+@(w+.)+(com|org|net|edu)

pat1 = w+@(w+.)+(com|org|net|edu)
r1 = re.match(pat,finin@cs.umbc.edu)
r1.group()
'finin@cs.umbc.edu’

Potremmo voler fare match con sotto-parti del
pattern, come il nome email e l’host

28

ESEMPI:
match.py
Gruppi
E’ sufficiente racchiudere tra parentesi i
“gruppi” che vogliamo identificare

pat2 = (w+)@((w+.)+(com|org|net|edu))
r2 = re.match(pat2,finin@cs.umbc.edu)
r2.group(1)
'finin'
r2.group(2)
'cs.umbc.edu'
r2.groups()
r2.groups()
('finin', 'cs.umbc.edu', 'umbc.', 'edu’)

29

ESEMPI:
namedgroup.py
Gruppi
Notare che i gruppi sono numerati in pre-ordine
(cioè rispetto alla loro parentesi di apertura)
E’ anche possibile etichettare i gruppi e
referenziarli attraverso le etichette:
pat3 =(?Pnamew+)@(?Phost(w+.)+(com|org|net|edu))
r3 = re.match(pat3,finin@cs.umbc.edu)
r3.group('name')
'finin'
r3.group('host')
'cs.umbc.edu’

30

Cos’è un match object?
E’ un’istanza della classe match con i dettagli
del risultato del match
pat = a*b
r1 = re.search(pat,fooaaabcde)
r1.group() # restituisce la stringa che ha fatto match
'aaab'
r1.start() # indice dell’inizio del match
3
r1.end() # indice della fine del match
7
r1.span() # tupla (start, end)
(3, 7)
31

re match object: Alcuni metodi utili
group([group1, ...])
Restituisce le occorrenze dei sotto-pattern
(gruppi)
start([group])
Restituisce la posizione di inizio dell’occorrenza
di un dato gruppo
end([group])
Restituisce la posizione di fine dell’occorrenza di
un dato gruppo
span([group])
Restituisce le posizioni di inizio e fine
32

ESEMPI:
resplit.py
re.split()
re.split() è simile a split() ma può utilizzare dei
pattern:
some_text = 'alpha, beta,,,,gamma delta’
re.split('[, ]+', some_text)
['alpha', 'beta', 'gamma', 'delta']
Con il parametro maxsplit è anche possibile
indicare il massimo consentito numero di
suddivisioni:
re.split('[, ]+', some_text, maxsplit=2)
['alpha', 'beta', 'gamma delta’]
re.split('[, ]+', some_text, maxsplit=1)
['alpha', 'beta,,,,gamma delta']
33

Altre funzioni del modulo re
re.findall() trova tutti i match:
re.findall(d+”,12 dogs,11 cats, 1 egg)
['12', '11', ’1’]

re.sub() sostituisce un pattern con una stringa
specificata:
re.sub('(blue|white|red)', 'black', 'blue socks and red
shoes')
'black socks and black shoes’

34

sub e i gruppi
E’ possibile compiere sostituzioni avanzate
utilizzando sub insieme a riferimenti a gruppi
Ad esempio, immaginiamo di voler sostituire
'*something*' con 'emsomething/em’:
emphasis_pattern = r'*([^*]+)*’
re.sub(emphasis_pattern, r'em1/em', 'Hello,
*world*!')
'Hello, emworld/em!’

35

sub e le funzioni di sostituzione
E’ possibile compiere sostituzioni avanzate
utilizzando vere e proprie funzioni di
sostituzione invece che una semplice stringa
Ad esempio:
def dashrepl(matchobj):
if matchobj.group(0) == '-': return ' ’
else: return '-’
re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'

36

Pattern greedy e non greedy
ATTENZIONE: gli operatori di ripetizione sono
greedy (ingordi) di default, cioè tentano di
trovare i match più grandi possibili

Questo può a volte produrre risultati non
desiderati:
emphasis_pattern = r'*(.+)*’
re.sub(emphasis_pattern, r'em1/em', '*This* is
*it*!’)
'emThis* is *it/em!’

37

Pattern greedy e non greedy
Per risolvere il problema, è sufficiente utilizzare
le versioni non-greedy degli operatori di
ripetizione, ad es:
+ operatore greedy
+? operatore non-greedy

emphasis_pattern = r’*(.+?)*’
re.sub(emphasis_pattern, r'em1/em', ’*This* is
*it*!’)
'emThis/em is emit/em!'

38

Compilazione di espressioni regolari
Se si prevede di utilizzare un pattern re più di una
volta, è consigliabile compilarlo, ottenendo un
oggetto pattern
Python produce in questo caso una speciale
struttura dati che ne velocizza il matching
cpat = re.compile(pat)
cpat
_sre.SRE_Pattern object at 0x2d9c0
r = cpat.search(finin@cs.umbc.edu)
r
_sre.SRE_Match object at 0x895a0
r.group()
'finin@cs.umbc.edu'
39

Pattern object: metodi
Per un pattern object sono definiti metodi
analoghi a quelli visti nel modulo re:
match
search
split
findall
sub

40

ESEMPI:
porter.py
Esempio conclusivo
Un’applicazione completa di text processing:
implementazione dell’algoritmo di stemming di
Porter per la lingua inglese

41

Py a5 python-text

More Related Content

Viewers also liked (20)

Similar to Py a5 python-text (20)

More from Majong DevJfu (20)

Py a5 python-text