Python versione Bignami - Espressioni regolari

from re import *

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)

Python versione Bignami - Espressioni regolari

Grammatica

Flag che cambiano il comportamento di un'espressione regolare

Match al volo

Creazione

Oggetti di tipo espressione regolare

Oggetti di tipo MatchObject

Trucchi utili

Esempi

Link