Python Espressioni regolari | Stefano Bortolamasi

Grammatica

. Un carattere qualsiasi, escluso \n a meno ché re.S non sia attivo
^ L’inizio della stringa, o della riga se re.M è attivo
$ La fine della stringa, o della riga se rm.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 minuscole
re.L adatta \w, \W, \b e \B alla lingua corrente
re.M quando una stringa contiene piú righe, ‘^’ e ‘$’ fanno match anche di
inizio e fine riga
re.S ‘.’ matches ALL chars, including newline
re.U adatta \w, \W, \b e \B per lavorare usando le proprietà
Unicode dei caratteri
re.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 un MatchObject, o None se non fa match.
mo = search(pattern, string[, flags]) vero se il pattern fa match in un punto
qualsiasi della stringa. Restituisce un MatchObject, 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. Se pattern 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 con pattern. Se pattern 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 con pattern sono sostituite da repl

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 un MatchObject, o None se non fa match.
mo = r.search(string[, flags]) vero se r fa match in un punto qualsiasi
della stringa. Restituisce un MatchObject, 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.
Se pattern 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. Se pattern 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 da repl

Oggetti di tipo MatchObject

mo.group(0) restituisce tutta la stringa matchata
mo.group(1) restituisce la stringa matchata dal primo gruppo tra parentesi
mo.group(1, 3, 4) restituisce una tupla con le stringhe matchate dal
primo, terzo e quarto gruppo tra parentesi
mo.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

ESTRAPOLAZIONE GRAFICA

https://regexper.com/