Le espressioni regolari sono spesso viste come questa serie davvero oscura di geroglifici che in genere si copia da Internet e si incolla nel proprio codice. Questo misterioso incantesimo mostra quindi capacità magiche di trovare modelli all'interno di stringhe di testo e se lo chiediamo gentilmente ci farà anche il favore di sostituire un determinato modello all'interno di una stringa con qualcosa di più carino.

Ad esempio, quando scrivi gestori per URL (e Dio ti aiuti se ne stai scrivendo uno da zero), spesso vuoi visualizzare lo stesso risultato indipendentemente dal '/' finale nell'URL. E.g https://esempio.com/user/settings/ e https://example.com/user/settings dovrebbero puntare entrambi alla stessa pagina nonostante il '/' finale.

Tuttavia, non puoi ignorare tutte le barre in avanti, come:

La barra tra 'utente' e 'impostazioni', e, 'utente/impostazioni'.
Inoltre dovrai prendere in considerazione il '//' all'inizio del tuo FQDN seguito da 'https'.

Quindi, ti viene in mente una regola come "Ignora solo le barre in avanti seguite dallo spazio vuoto.” e se vuoi puoi codificare quella regola con una serie di istruzioni if-else. Ma questo diventerà ingombrante abbastanza rapidamente. Puoi scrivere una funzione che dice cleanUrl() che può incapsularlo per te. Ma l'universo comincerà presto a lanciarti altre palle curve. Presto ti ritroverai a scrivere funzioni per cleanHeaders(), processLog(), ecc. Oppure puoi usare un'espressione regolare ogni volta che è richiesto qualsiasi tipo di corrispondenza del modello.

I/O e file standard

Prima di entrare nei dettagli delle espressioni regolari vale la pena menzionare il modello che la maggior parte dei sistemi ha per i flussi di testo. Eccone un breve (incompleto) riassunto:

Il testo viene elaborato come un (singolo) flusso di caratteri.
Questo flusso può provenire da un file di testo Unicode o ASCII o da input standard (tastiera) o da una connessione di rete remota. Dopo l'elaborazione, ad esempio da uno script regex, l'output va a un file oa un flusso di rete o all'output standard (e.g, console)
Il flusso è costituito da una o più righe. Ogni riga ha zero o più caratteri seguiti da una nuova riga.

Per semplicità, voglio che immaginiate che un file è composto da righe che terminano con un carattere di nuova riga. Dividiamo questo file in singole righe (o stringhe) ciascuna che termina con una nuova riga o un carattere normale (per l'ultima riga).

Regex e stringhe

Una regex non ha nulla, in particolare, a che fare con i file. Immaginalo come una scatola nera che può prendere come input qualsiasi stringa arbitraria di qualsiasi lunghezza (finita) e una volta raggiunta la fine di questa stringa può:

Accetta la stringa. In altre parole, la stringa partite l'espressione regolare (regex).
Rifiuta la stringa, io.e, la stringa no incontro l'espressione regolare (regex).

Nonostante la sua natura da scatola nera, aggiungerò qualche altro vincolo a questo macchinario. Una regex legge una stringa in sequenza, da sinistra a destra e legge solo un carattere alla volta. Quindi una stringa "Suggerimento Linux" da leggere come:

'L"i"n"u"x"H"i"n"t' [Da sinistra a destra]

Iniziamo in modo semplice

Il tipo più semplicistico di regex sarebbe cercare e abbinare una stringa "C". L'espressione regolare per esso è solo 'C'. Abbastanza banale. Il modo per farlo in Python richiederebbe di importare prima il ri modulo per le espressioni regolari.

>>> importa re

Usiamo quindi la funzione re.ricerca(modello, stringa) dove modello è la nostra espressione regolare e corda nella stringa di input all'interno della quale cerchiamo il pattern.

>>> ri.search('C', 'Questa frase contiene una C intenzionale')

La funzione accetta il modello 'C', lo cerca nella stringa di input e stampa la posizione (span) dove si trova il suddetto modello. Questa parte della stringa, questa sottostringa è ciò che corrisponde alla nostra espressione regolare. Se non fosse stata trovata alcuna corrispondenza, l'output sarebbe stato a Nessuna oggetto.

Allo stesso modo, puoi cercare il modello "espressione regolare" come segue:

>>>ri.search(“espressione regolare”,“Possiamo usare espressioni regolari per cercare modelli.”)

ri.cerca() , re.match() e re.partita intera()

Tre utili funzioni del modulo re includono:

1. ri.ricerca(modello, stringa)

Questo restituisce la sottostringa che corrisponde al modello, come abbiamo visto sopra. Se non viene trovata alcuna corrispondenza, allora Nessuna viene restituito. Se più sottostringhe sono conformi a un determinato modello viene riportata solo la prima occorrenza.

2. ri.incontro(modello, stringa)

Questa funzione cerca di far corrispondere il modello fornito dall'inizio della stringa. Se incontra una pausa da qualche parte a metà strada, ritorna Nessuna.

Per esempio,

>>> ri.match("Joh", "John Doe")

Dove come la stringa "My name is John Doe" non è una corrispondenza, e quindi Nessuna viene restituito.

>>> stampa (ri).match(“Joh”, “Mi chiamo John Doe”))
Nessuna

3. ri.partita intera(modello, stringa)

Questo è più rigoroso di entrambi i precedenti e cerca di trovare una corrispondenza esatta del modello nella stringa, altrimenti il valore predefinito è Nessuna.

>>> stampa (ri).fullmatch("Gio", "Giovanni"))

# Qualsiasi altra cosa non sarà una partita

Userò solo il ri.ricerca() funzione nel resto di questo articolo. Ogni volta che dico che l'espressione regolare accetta questa stringa, significa che athe ri.ricerca() la funzione ha trovato una sottostringa corrispondente nella stringa di input e ha restituito quella, invece di Nessunaoggetto.

Personaggi speciali

Le espressioni regolari come "John" e "C" non sono di grande utilità. Abbiamo bisogno di caratteri speciali che un significato specifico nel contesto delle espressioni regolari. Ecco alcuni esempi:

1. ^ - Corrisponde all'inizio di una stringa. Ad esempio, '^C' corrisponderà a tutte le stringhe che iniziano con la lettera C.
2. $ - Questo corrisponde alla fine della riga.
3. . - Il punto sta ad indicare uno o più caratteri, eccetto il newline.
4. * - Questo è a zero o più caratteri di ciò che lo ha preceduto. Quindi b* corrisponde a 0 o più occorrenze di b. ab* corrisponde solo a a, ab e a
5. + - Questo è per uno o più caratteri di ciò che lo ha preceduto. Quindi b+ corrisponde a 1 o più occorrenze di b. ab* corrisponde solo a a, ab e a
6. \ - La barra rovesciata viene utilizzata come sequenza di escape nelle espressioni regolari. Quindi vuoi un'espressione regolare per cercare la presenza letterale del simbolo del dollaro '$' invece della fine della riga. Puoi scrivere \$ nell'espressione regolare.
7. Le parentesi graffe possono essere utilizzate per specificare il numero di ripetizioni che si desidera vedere. Ad esempio, un modello come ab10 significa che la stringa a seguita da 10 b corrisponderà a questo modello. Puoi anche specificare un intervallo di numeri, come b4,6 corrisponde a stringhe contenenti b ripetute da 4 a 6 volte consecutive. Il modello per 4 o più ripetizioni richiederebbe solo una virgola finale, in questo modo b4,
8. Parentesi quadre e intervallo di caratteri. RE come [0-9] può fungere da segnaposto per qualsiasi cifra tra 0 e 9. Allo stesso modo, puoi avere cifre comprese tra uno e cinque [1-5] o per abbinare qualsiasi lettera maiuscola usa [A-Z] o per qualsiasi lettera dell'alfabeto indipendentemente dal fatto che sia maiuscola o minuscola usa [A-z].
  Ad esempio, qualsiasi stringa composta da esattamente dieci cifre corrisponde all'espressione regolare [0-9]10, molto utile quando si cercano numeri di telefono in una determinata stringa.
9. Puoi creare un'istruzione OR like, usando | carattere in cui un'espressione regolare è composta da due o più espressioni regolari, ad esempio A e B. L'espressione regolare A|B è una corrispondenza se la stringa di input è una corrispondenza per l'espressione regolare A o per B.
10. Puoi raggruppare diverse espressioni regolari insieme. Ad esempio, l'espressione regolare (A|B)C corrisponderà alle espressioni regolari per AC e

C'è molto altro da coprire, ma consiglierei di imparare mentre procedi invece di sovraccaricare il tuo cervello con un sacco di simboli oscuri e casi limite. In caso di dubbio, i documenti Python sono di grande aiuto e ora ne sai abbastanza per seguire facilmente i documenti.

Esperienza pratica e referenze

Se vuoi vedere un'interpretazione visiva della tua regex, puoi visitare Debuggex. Questo sito genera una visualizzazione della tua regex in tempo reale e ti consente di testarla su varie stringhe di input.

Per saperne di più sull'aspetto teorico delle espressioni regolari potresti voler dare un'occhiata ai primi due capitoli dell'Introduzione alla teoria del calcolo di Michael Sipser. È molto facile da seguire e mostra l'importanza delle espressioni regolari come concetto fondamentale del calcolo stesso!

Espressioni regolari usando Python 3