Le espressioni regolari sono spesso viste come questa serie davvero oscura di geroglifici che in genere si copiano da Internet e in paste nel suo codice. Questo misterioso incantesimo mostra quindi le magiche capacità di trovare motivi all'interno delle stringhe del testo e se lo chiediamo bene ci farà anche il favore di sostituire un determinato modello all'interno di una stringa con qualcosa di più bello.

Ad esempio, quando scrivi gestori per l'URL (e Dio ti aiuta se ne stai scrivendo uno da zero), allora spesso vuoi mostrare lo stesso risultato indipendentemente dal trailing '/' nell'URL. E.g https: // esempio.com/utente/impostazioni/e https: // esempio.com/utente/impostazioni dovrebbero entrambi indicare la stessa pagina nonostante il trailing '/'.

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

1. La barra in avanti tra "utente" e "impostazioni", e "utente/impostazioni".
2. 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 da spazio vuoto."E se vuoi puoi codificare quella regola con una serie di istruzioni IF-Else. Ma questo diventa ingombrante abbastanza rapidamente. Puoi scrivere una funzione che dice Cleanurl () che può incapsulare questo per te. Ma l'universo inizierà presto a lanciarti più curve. Ti ritroverai presto a scrivere funzioni per CleanHeaders (), Processlog (), ecc. Oppure puoi usare un'espressione regolare ogni volta che è richiesto qualsiasi tipo di corrispondenza.

IO 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 flussi di testo. Ecco un breve riassunto (incompleto) di esso:

1. Il testo viene elaborato come un flusso (singolo) di caratteri.
2. 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, diciamo da uno script regex, l'output va a un file o in un flusso di rete o all'output standard (E.g, console)
3. Il flusso consiste in una o più linee. Ogni riga ha zero o più caratteri seguiti da una nuova linea.

Per motivi di semplicità, voglio che tu immagini che un file sia composto da linee che terminano con un carattere di nuova linea. Rompi questo file in singole righe (o stringhe) che terminano con una nuova linea o un carattere normale (per l'ultima riga).

Regexs e string

Un regex non ha nulla, particolare, a che fare con i file. Immagina 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ò anche:

1. Accetta la stringa. In altre parole, la stringa corrispondenze L'espressione regolare (regex).
2. Rifiutare la stringa, i.E, la stringa no incontro L'espressione regolare (regex).

Nonostante la sua natura in scatola nera, aggiungerò alcuni più vincoli a questo macchinario. Un regex legge una stringa sequenzialmente, da sinistra a destra e legge solo un personaggio alla volta. Quindi una stringa "Linuxhint" con essere letto come:

'L "i" n "u" x "h" i "n" t' [da sinistra a destra]

Cominciamo semplice

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

>>> Importa re

Quindi usiamo la funzione re.ricerca(pattern, stringa) Dove modello è la nostra espressione regolare e corda Nella stringa di input all'interno della quale cerchiamo il modello.

>>> re.Search ('C', 'questa frase ha una C deliberata in essa')

La funzione assume il modello 'C', lo cerca nella stringa di input e stampa la posizione (span) Dove si trova il suddetto schema. Questa parte della stringa, questa sottostringa è ciò che corrisponde alla nostra espressione regolare. Se non vi fosse tale corrispondenza, l'output sarebbe stato un Nessuno oggetto.

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

>>> re.Cerca ("espressione regolare", "Possiamo usare espressioni regolari per la ricerca di schemi.")

Rif.Search (), re.match () e re.partita intera()

Tre funzioni utili dal modulo RE includono:

Rif.ricerca(pattern, stringa)

Questo restituisce la sottostringa che corrisponde al modello, come abbiamo visto sopra. Se non viene trovata alcuna corrispondenza Nessuno è restituito. Se viene riportato sottostringi multipli a un determinato modello, viene riportato solo il primo occhiale.

Rif.incontro(pattern, stringa)

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

Per esempio,

>>> re.Match ("Joh", "John Doe")

Dove come la stringa "il mio nome è John Doe" non è una corrispondenza, e quindi Nessuno è restituito.

>>> stampa (re.Match ("Joh", "Il mio nome è John Doe")
Nessuno

Rif.partita intera(pattern, stringa)

Questo è più severo di entrambi i precedenti, e cerca di trovare una corrispondenza esatta del modello nella stringa, altrimenti è default Nessuno.

>>> stampa (re.fullmatch ("joh", "joh"))

# Qualsiasi altra cosa non sarà una partita

Userò solo il Rif.ricerca() funzione nel resto di questo articolo. Ogni volta che dico che il regex accetta questa stringa, significa che Athe Rif.ricerca() La funzione ha trovato una sottostringa corrispondente nella stringa di input e lo ha restituito, anziché Nessunooggetto.

Personaggi speciali

Le espressioni regolari come "John" e "C" non sono di grande uso. Abbiamo bisogno di caratteri speciali che una media specifica nel contesto delle espressioni regolari. Ecco alcuni esempi:

1. 1. ^ - Questo 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 linea.
   3. . - Il punto deve indicare uno o più caratteri, tranne la nuova linea.
   4. * - Questo è a zero o più carattere di ciò che lo ha preceduto. Quindi B* corrisponde a 0 o più occorrenze di B. AB* corrisponde solo a, ab e a
   5. + - Questo è per uno o più carattere di ciò che lo ha preceduto. Quindi B+ corrisponde a 1 o più occorrenze di B. AB* corrisponde solo a, ab e a
   6. \ - La backslash viene utilizzata come sequenza di fuga nei regexes. Quindi vuoi un'espressione regolare per cercare la presenza letterale del simbolo del dollaro '$' invece della fine della linea. Puoi scrivere \ $ in espressione regolare.
   7. Le parentesi graffe ricci possono essere utilizzate per specificare il numero di ripetizioni che si desidera vedere. Ad esempio, uno schema come AB 10 indica la stringa A seguita da 10 b corrisponderà a questo modello. È possibile specificare anche un intervallo di numeri, come b 4,6 corrisponde a stringhe contenenti b ripetute da 4 a 6 volte consecutivamente. Il modello per 4 o più ripetizioni richiederebbe solo una virgola finale, come così b 4,
   8. Parentesi quadrate e gamma di personaggi. Re come [0-9] può agire come un segnaposto per qualsiasi cifra tra 0 e 9. Allo stesso modo, è possibile avere cifre tra una e cinque [1-5] o per abbinare qualsiasi lettera maiuscola Uso [A-Z] o per qualsiasi lettera dell'alfabeto indipendentemente dal fatto che sia un uso superiore o minuscolo [A-Z].
      Ad esempio, qualsiasi stringa fatta di esattamente dieci cifre corrisponde all'espressione regolare [0-9] 10, abbastanza utile quando si cerca numeri di telefono in una determinata stringa.
   9. Puoi creare un'istruzione o simile, usando | carattere in cui un'espressione regolare è composta da due o più espressioni regolari, diciamo, a e b. Il regex a | b è una corrispondenza se la stringa di input è una corrispondenza per l'espressione regolare a o per b.
   10. Puoi raggruppare diversi regex insieme. Ad esempio, il regex (a | b) c corrisponderà a regex per AC e

C'è molto di più da coprire, ma consiglierei di imparare mentre vai invece di sovraccaricare il tuo cervello con molti simboli oscuri e casi di bordo. In caso di dubbi, i documenti di Python sono di grande aiuto e ora sai abbastanza per seguire facilmente i documenti.

Esperienza e riferimenti pratici

Se vuoi vedere un'interpretazione visiva del tuo regex, puoi visitare Debuggex. Questo sito genera una vista del tuo regex in tempo reale e ti consente di testarlo contro varie stringhe di input.

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