Grammatica
.
Un carattere qualsiasi, escluso\n
a meno chére.S
non sia attivo^
L’inizio della stringa, o della riga sere.M
è attivo$
La fine della stringa, o della riga serm.M
è attivo\A
L’inizio della stringa\Z
La fine della stringa\b
La stringa vuota all’inizio o alla fine di una parola\B
La stringa vuota eccetto all’inizio e alla fine di una parola\d
Una cifra tra 0 e 9\D
Tutto eccetto una cifra tra zero e 9\s
Uno spazio, andata a capo, tabulazione\S
Tutto eccetto spazi, andate a capo, tabulazioni\w
Una lettera maiuscola o minuscola, o un numero\W
Tutto eccetto lettere maiuscole o minuscole o numeri- regexp
*
regexp ripetuta 0 o piú volte, cercando di fare la stringa piú lunga possibile - regexp
+
regexp ripetuta 1 o piú volte, cercando di fare la stringa piú lunga possibile - regexp
?
regexp oppure nulla, cercando di fare la stringa piú lunga possibile - regexp
{m,n}
regexp ripetuta un minimo di m e un massimo di n volte, cercando di fare la stringa piú lunga possibile *?
,+?
,??
Come*
,+
,?
e{m,n}
, ma cercando di fare la
stringa piú corta possibile[abcd]
uno qualsiasi dei caratteri nell’elenco.[a-z]
tra a e z. Per mettere il trattino nell’elenco, metterlo come primo
o ultimo caratterei (per esempio:[abcd-]
)[^abcdA-Z]
tutti i caratteri eccetto quelli nell’elenco\
escape dei caratteri speciali- regexp1
|
regexp2 regexp1 oppure regexp2 (
regexp)
raggruppa regexp (a|b*
è diverso da(a|b)*
). Ricorda la
stringa matchata dall’espressione tra parentesi per potervi accedere dopo il
match- \numero matcha la stessa stringa precedentemente matchata dal gruppo
numero numero. La numerazione parte da 1. (?:
regexp)
come le parentesi, ma senza ricordare la stringa matchata(?P<
nome>
regexp)
come le parentesi, ma ricorda la stringa matchata
dandole il nome nome(?P=
nome)
ripetizione della stringa precedentemente matchata col nome
nome.(?=
regexp)
match di regexp, ma senza spostarsi avanti nella stringa
dopo il match(?!
regexp)
versione negata di(?=
regexp)
.(?<=
regexp)
fa match se esiste una stringa matchata da regexp che
termina esattamente alla posizione corrente(?<!
regexp)
versione negata di(?<=
regexp)
.(?(
nome)
regexp1|
regexp2)
se un gruppo(?P<
nome>)
è stato matchato
in precedenza, allora fa match di regexp1, altrimenti di regexp2*.(?#...)
Un commento dentro l’espressione, che viene ignorato.(?
flag)
dove flag è una o piú delle lettere ‘i’, ‘L’, ‘m’, ‘s’, ‘u’ o
‘x’, setta il corrispondente flag re.I, re.L, re.M, re.S, re.U o re.X per
l’intera espressione.
Flag che cambiano il comportamento di un’espressione regolare
re.I
non fa distinzione tra maiuscole e minuscolere.L
adatta\w
,\W
,\b
e\B
alla lingua correntere.M
quando una stringa contiene piú righe, ‘^’ e ‘$’ fanno match anche di
inizio e fine rigare.S
‘.’ matches ALL chars, including newlinere.U
adatta\w
,\W
,\b
e\B
per lavorare usando le proprietà
Unicode dei caratterire.X
ignora gli spazi e le andate a capo eccetto tra le parentesi quadre,
permettendo di formattare espressioni complesse in maniera piú leggibile
Match al volo
mo = match(pattern, string[, flags])
vero se il pattern fa match
all’inizio della stringa. Restituisce unMatchObject
, o None se non fa match.mo = search(pattern, string[, flags])
vero se il pattern fa match in un punto
qualsiasi della stringa. Restituisce unMatchObject
, o None se non fa match.lista = split(pattern, string[, maxsplit=0])
divide la stringa
considerando come separatori tutti i pezzetti di stringa su cui l’espressione
fa match. Sepattern
usa le parentesi, restituisce anche i pezzetti di
stringa corrispondenti al pattern tra parentesi.lista = findall(pattern, string)
restituisce una lista con tutte le parti
della stringa che fanno match conpattern
. Sepattern
usa le parentesi,
restituisce tuple con le stringhe corrispondenti ai pattern tra parentesi.s = sub(pattern, repl, string[, count=0])
restituisce una stringa dove
tutte le parti che fanno match conpattern
sono sostituite darepl
Creazione
- r = compile(pattern[, flags]) compila il pattern e restituisce un oggetto di
tipo espressione regolare
Oggetti di tipo espressione regolare
mo = r.match(string[, flags])
vero se r fa match all’inizio della stringa.
Restituisce unMatchObject
, o None se non fa match.mo = r.search(string[, flags])
vero se r fa match in un punto qualsiasi
della stringa. Restituisce unMatchObject
, o None se non fa match.lista = r.split(string[, maxsplit=0])
divide la stringa
considerando come separatori tutti i pezzetti di stringa su cui r fa match.
Sepattern
usa le parentesi, restituisce anche i pezzetti di stringa
corrispondenti al pattern tra parentesi.lista = r.findall(string)
restituisce una lista con tutte le parti
della stringa che fanno match con r. Sepattern
usa le parentesi,
restituisce tuple con le stringhe corrispondenti ai pattern tra parentesi.s = r.sub(repl, string[, count=0])
restituisce una stringa dove
tutte le parti che fanno match con r sono sostituite darepl
Oggetti di tipo MatchObject
mo.group(0)
restituisce tutta la stringa matchatamo.group(1)
restituisce la stringa matchata dal primo gruppo tra parentesimo.group(1, 3, 4)
restituisce una tupla con le stringhe matchate dal
primo, terzo e quarto gruppo tra parentesimo.gruop("nome")
restituisce la stringa matchata dal gruppo(P<nome>...)
groups()
restituisce una tupla con tutti i gruppi matchati
Trucchi utili
r"stringa"
definisce una stringa in cui non vengono espansi i backslash:
è molto utile per definire un’espressione regolare.- re.escape(stringa) restituisce una stringa in cui tutti i caratteri che
hanno un’interpretazione speciale nell’espressione regolare vengono protetti
da backslash: è utile per fare match esatto di stringhe arbitrarie
Esempi
import re # Divide una stringa usando virgole come separatori, ma tollerando spazi # attorno alle virgole lista = re.split(r'\s*,\s*', stringa) # Stampa tutte le righe di un file che iniziano con la stringa data r = re.compile('^'+re.escape(sys.argv[1])) for line in file: if r.match(line): print line[:-1] # Legge un file saltando commenti e linee vuote r = re.compile(r"^(?:\s*|#.+)$") for line in file: if r.match(line): continue # ... # Fa il parse di un file di configurazione r = re.compile(r"^\s*(\w+)\s*=\s*(.+?)\s*$") for line in file: mo = r.match(line) if mo: key, val = mo.group(1, 2) # Nasconde le password re.sub(r"^(Password:\s*).+$", r'\1(nascosto)', stringa) # Scambia pezzi di stringa re.sub(r"(\w+)\s*=\s*(\w+)", r'\2 = \1', stringa)
Qui invece una verifica sul javascript:
var dateRegex = /^(?=\d)(?:(?:31(?!.(?:0?[2469]|11))|(?:30|29)(?!.0?2)|29(?=.0?2.(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(?:\x20|$))|(?:2[0-8]|1\d|0?[1-9]))([-.\/])(?:1[012]|0?[1-9])\1(?:1[6-9]|[2-9]\d)?\d\d(?:(?=\x20\d)\x20|$))?(((0?[1-9]|1[012])(:[0-5]\d){0,2}(\x20[AP]M))|([01]\d|2[0-3])(:[0-5]\d){1,2})?$/;
console.log( dateRegex.test( $('your input').val() ) );
Link
- Espressioni regolari nella Python Quick Reference
- Python Regular Expression HOWTO
- Altra descrizione del modulo Python re
- Le espressioni regolari nella Python Library Reference
ESTRAPOLAZIONE GRAFICA