UN Espressione regolare o RegEx è una sequenza speciale di caratteri che utilizza un modello di ricerca per trovare una stringa o un insieme di stringhe.
Può rilevare la presenza o l'assenza di un testo abbinandolo a un modello particolare e può anche dividere un modello in uno o più sottomodelli.
Modulo Regex in Python
Python ha un modulo integrato denominato Rif utilizzato per le espressioni regolari in Python. Possiamo importare questo modulo utilizzando l'istruzione import .
Esempio: Importazione del modulo re in Python
Python3
# importing re module> import> re> |
>
>
Come usare RegEx in Python?
Puoi utilizzare RegEx in Python dopo aver importato il modulo re.
Esempio:
Questo codice Python utilizza espressioni regolari per cercare la parola portale nella stringa data e quindi stampa gli indici iniziale e finale della parola corrispondente all'interno della stringa.
Python3
import> re> > s>=> 'techcodeview.com: A computer science portal for geeks'> > match>=> re.search(r>'portal'>, s)> > print>(>'Start Index:'>, match.start())> print>(>'End Index:'>, match.end())> |
>
>Produzione
Start Index: 34 End Index: 40>
Nota: Qui il carattere r (r’portal’) sta per raw, non regex. La stringa grezza è leggermente diversa da una stringa normale, non interpreterà il carattere come carattere di escape. Questo perché il motore delle espressioni regolari utilizza il carattere per i propri scopi di escape.
Prima di iniziare con il modulo regex di Python vediamo come scrivere effettivamente regex utilizzando metacaratteri o sequenze speciali.
Metacaratteri
I metacaratteri sono i caratteri con un significato speciale.
Per comprendere l'analogia con RE, i metacaratteri sono utili e importanti. Verranno utilizzati nelle funzioni del modulo re. Di seguito è riportato l'elenco dei metacaratteri.
| MetaPersonaggi | Descrizione |
|---|---|
| Utilizzato per eliminare il significato speciale del carattere che lo segue quanti film mission impossibili ci sono | |
| [] | Rappresenta una classe di caratteri |
| ^ | Corrisponde all'inizio |
| $ | Corrisponde alla fine |
| . | Corrisponde a qualsiasi carattere tranne il fine riga |
| | | Significa OR (corrisponde a qualsiasi carattere separato da esso. |
| ? | Corrisponde a zero o una occorrenza |
| * | Qualsiasi numero di occorrenze (incluse 0 occorrenze) |
| + | Una o più occorrenze |
| {} | Indica il numero di occorrenze di una regex precedente da abbinare. |
| () | Racchiudi un gruppo di Regex |
Discutiamo ciascuno di questi metacaratteri in dettaglio:
1. – Barra rovesciata
La barra rovesciata () assicura che il carattere non venga trattato in modo speciale. Questo può essere considerato un modo per sfuggire ai metacaratteri.
Ad esempio, se desideri cercare il punto (.) nella stringa, scoprirai che il punto (.) verrà trattato come un carattere speciale così come lo è uno dei metacaratteri (come mostrato nella tabella sopra). Quindi, in questo caso, useremo la barra rovesciata() appena prima del punto(.) in modo che perda la sua specialità. Vedere l'esempio seguente per una migliore comprensione.
Esempio:
La prima ricerca ( re.search(r'.', s)> ) corrisponde a qualsiasi carattere, non solo al punto, mentre la seconda ricerca ( re.search(r'.', s)> ) cerca e corrisponde specificamente al carattere punto.
Python3
import> re> > s>=> 'geeks.forgeeks'> > # without using> match>=> re.search(r>'.'>, s)> print>(match)> > # using> match>=> re.search(r>'.'>, s)> print>(match)> |
>
>Produzione
>
2. [] – Parentesi quadre
Le parentesi quadre ([]) rappresentano una classe di caratteri composta da un insieme di caratteri che desideriamo far corrispondere. Ad esempio, la classe di caratteri [abc] corrisponderà a qualsiasi singolo a, b o c.
Possiamo anche specificare un intervallo di caratteri utilizzando – all'interno delle parentesi quadre. Per esempio,
- [0, 3] è campione come [0123]
- [a-c] è uguale a [abc]
Possiamo anche invertire la classe dei caratteri utilizzando il simbolo caret(^). Per esempio,
- [^0-3] indica qualsiasi numero tranne 0, 1, 2 o 3
- [^a-c] indica qualsiasi carattere tranne a, b o c
Esempio:
In questo codice, utilizzi le espressioni regolari per trovare tutti i caratteri nella stringa che rientrano nell'intervallo da 'a' a 'm'. IL re.findall()> la funzione restituisce un elenco di tutti questi caratteri. Nella stringa data, i caratteri che corrispondono a questo modello sono: 'c', 'k', 'b', 'f', 'j', 'e', 'h', 'l', 'd', ' G'.
Python3
import> re> > string>=> 'The quick brown fox jumps over the lazy dog'> pattern>=> '[a-m]'> result>=> re.findall(pattern, string)> > print>(result)> |
>
>Produzione
['h', 'e', 'i', 'c', 'k', 'b', 'f', 'j', 'm', 'e', 'h', 'e', 'l', 'a', 'd', 'g']>
3. ^ – Cursore
Il simbolo di accento circonflesso (^) corrisponde all'inizio della stringa, ovvero controlla se la stringa inizia o meno con i caratteri specificati. Per esempio -
- ^g controllerà se la stringa inizia con g come geeks, Globe, Girl, G, ecc.
- ^ge controllerà se la stringa inizia con ge come geeks, geeksforgeeks, ecc.
Esempio:
Questo codice utilizza espressioni regolari per verificare se un elenco di stringhe inizia con IL . Se una stringa inizia con Il, è contrassegnato come Abbinato altrimenti, è etichettato come Non abbinato.
Python3
import> re> regex>=> r>'^The'> strings>=> [>'The quick brown fox'>,>'The lazy dog'>,>'A quick brown fox'>]> for> string>in> strings:> >if> re.match(regex, string):> >print>(f>'Matched: {string}'>)> >else>:> >print>(f>'Not matched: {string}'>)> |
>
>Produzione
Matched: The quick brown fox Matched: The lazy dog Not matched: A quick brown fox>
4. $ – Dollaro
Il simbolo del dollaro ($) corrisponde alla fine della stringa, ovvero controlla se la stringa termina con i caratteri specificati o meno. Per esempio-
- s$ controllerà la stringa che termina con a come geek, opens, s, ecc.
- ks$ controllerà la stringa che termina con ks come geeks, geeksforgeeks, ks, ecc.
Esempio:
Questo codice utilizza un'espressione regolare per verificare se la stringa termina con Mondo!. Se viene trovata una corrispondenza, viene stampata Corrispondenza trovata! in caso contrario, viene stampato Corrispondenza non trovata .
Python3
casella di riepilogo html
import> re> > string>=> 'Hello World!'> pattern>=> r>'World!$'> > match>=> re.search(pattern, string)> if> match:> >print>(>'Match found!'>)> else>:> >print>(>'Match not found.'>)> |
>
>Produzione
Match found!>
5. . – Punto
Il simbolo punto(.) corrisponde a un solo carattere ad eccezione del carattere di nuova riga ( ). Per esempio -
- a.b controllerà la stringa che contiene qualsiasi carattere al posto del punto come acb, acbd, abbb, ecc.
- .. controllerà se la stringa contiene almeno 2 caratteri
Esempio:
Questo codice utilizza un'espressione regolare per cercare il modello marrone.volpe all'interno della stringa. Il punto (.>) nel modello rappresenta qualsiasi carattere. Se viene trovata una corrispondenza, viene stampata Corrispondenza trovata! in caso contrario, viene stampato Corrispondenza non trovata .
Python3
import> re> > string>=> 'The quick brown fox jumps over the lazy dog.'> pattern>=> r>'brown.fox'> > match>=> re.search(pattern, string)> if> match:> >print>(>'Match found!'>)> else>:> >print>(>'Match not found.'>)> |
>
>Produzione
Match found!>
6. | - O
Il simbolo Or funziona come l'operatore o, il che significa che controlla se il modello prima o dopo il simbolo o è presente o meno nella stringa. Per esempio -
- a|b corrisponderà a qualsiasi stringa che contiene aob come acd, bcd, abcd, ecc.
7. ? - Punto interrogativo
Il punto interrogativo (?) è un quantificatore nelle espressioni regolari che indica che l'elemento precedente deve essere abbinato zero o una volta. Ti consente di specificare che l'elemento è facoltativo, il che significa che può verificarsi una volta o non verificarsi affatto. Per esempio,
- ab?c verrà trovato per la stringa ac, acb, dabc ma non verrà trovato per abbc perché ci sono due b. Allo stesso modo, non verrà trovato per abdc perché b non è seguito da c.
8.* – Stella
Il simbolo asterisco (*) corrisponde a zero o più occorrenze della regex che precede il simbolo *. Per esempio -
- ab*c verrà trovato per la stringa ac, abc, abbbc, dabc, ecc. ma non verrà trovato per abdc perché b non è seguito da c.
9. + – Più
Il simbolo più (+) corrisponde a una o più occorrenze della regex che precede il simbolo +. Per esempio -
- ab+c verrà trovato per la stringa abc, abbc, dabc, ma non sarà abbinato per ac, abdc, perché non c'è b in ac e b, non è seguito da c in abdc.
10. {m, n} – Bretelle
Le parentesi graffe corrispondono a qualsiasi ripetizione che precede l'espressione regolare da m a n entrambe comprese. Per esempio -
- a{2, 4} verrà trovato per la stringa aaab, baaaac, gaad, ma non verrà trovato per stringhe come abc, bc perché c'è solo una a o nessuna a in entrambi i casi.
11. () – Gruppo
Il simbolo di gruppo viene utilizzato per raggruppare i sottomodelli. Per esempio -
- (a|b)cd corrisponderà a stringhe come acd, abcd, gacd, ecc.
Sequenze speciali
Le sequenze speciali non corrispondono al carattere effettivo della stringa, ma indicano la posizione specifica nella stringa di ricerca in cui deve verificarsi la corrispondenza. Rende più semplice scrivere modelli di uso comune.
Elenco delle sequenze speciali
| Sequenza speciale | Descrizione | Esempi | |
|---|---|---|---|
| UN | Corrisponde se la stringa inizia con il carattere specificato | Afora | per i geek |
| Per il mondo | |||
| B | Corrisponde se la parola inizia o termina con il carattere specificato. (string) controllerà l'inizio della parola e (string) controllerà la fine della parola. | ge | geek |
| Ottenere | |||
| B | È l'opposto di cioè la stringa non dovrebbe iniziare o finire con la regex specificata. | Bge | insieme |
| fucina | |||
| D | Corrisponde a qualsiasi cifra decimale, equivale alla classe set [0-9] | D | 123 |
| cavolo1 | |||
| D | Corrisponde a qualsiasi carattere non numerico, equivale alla classe set [^0-9] | D | geek |
| geek1 | |||
| S | Corrisponde a qualsiasi carattere di spazio bianco. | S | cavolo, ks |
| abc a | |||
| S | Corrisponde a qualsiasi carattere diverso dagli spazi | S | un bd |
| abcd esempio di albero di ricerca binario | |||
| In | Corrisponde a qualsiasi carattere alfanumerico, equivale alla classe [a-zA-Z0-9_]. | In | 123 |
| geeKs4 | |||
| IN | Corrisponde a qualsiasi carattere non alfanumerico. | IN | >$ |
| Dare | |||
| CON | Corrisponde se la stringa termina con la regex specificata | ab | abcdab |
| bababà |
Funzioni RegEx
Rif il modulo ne contiene molti funzioni che ci aiutano a cercare una corrispondenza in una stringa.
Vediamo le varie funzioni fornite da questo modulo per lavorare con le regex in Python.
| Funzione | Descrizione |
|---|---|
| re.findall() | trova e restituisce tutte le occorrenze corrispondenti in un elenco |
| ri.compilare() | Le espressioni regolari vengono compilate in oggetti modello |
| re.dividi() | Dividi la stringa in base alle occorrenze di un carattere o di un modello. |
| re.sub() | Sostituisce tutte le occorrenze di un carattere o di uno schema con una stringa sostitutiva. |
| ri.fuga() | Sfugge al carattere speciale |
| ricerca() | Cerca la prima occorrenza del carattere o del modello |
Vediamo il funzionamento di queste funzioni RegEx con definizione ed esempi:
1. re.findall()
Restituisce tutte le corrispondenze non sovrapposte del modello in stringa, come elenco di stringhe. La stringa viene scansionata da sinistra a destra e le corrispondenze vengono restituite nell'ordine trovato.
Trovare tutte le occorrenze di un modello
Questo codice utilizza un'espressione regolare ( d+> ) per trovare tutte le sequenze di una o più cifre nella stringa data. Cerca valori numerici e li memorizza in un elenco. In questo esempio, trova e stampa i numeri 123456789 E 987654321 dalla stringa di input.
Python3
import> re> string>=> '''Hello my Number is 123456789 and> >my friend's number is 987654321'''> regex>=> 'd+'> > match>=> re.findall(regex, string)> print>(match)> |
>
>Produzione
['123456789', '987654321']>
2. ricompilare()
Le espressioni regolari vengono compilate in oggetti modello, che dispongono di metodi per varie operazioni come la ricerca di corrispondenze di modelli o l'esecuzione di sostituzioni di stringhe.
Esempio 1:
Il codice utilizza un modello di espressione regolare [a-e]> per trovare ed elencare tutte le lettere minuscole dalla 'a' alla 'e' nella stringa di input Sì, disse il signor Gibenson Stark. L'output sarà ['e', 'a', 'd', 'b', 'e']> , quali sono i caratteri corrispondenti.
Pitone
import> re> p>=> re.>compile>(>'[a-e]'>)> > print>(p.findall(>'Aye, said Mr. Gibenson Stark'>))> |
>
>Produzione
['e', 'a', 'd', 'b', 'e', 'a']>
Comprendere l'output:
- La prima occorrenza è 'e' in Aye e non 'A', poiché fa distinzione tra maiuscole e minuscole.
- L'occorrenza successiva è 'a' in detto, poi 'd' in detto, seguita da 'b' ed 'e' in Gibenson, l'ultima 'a' corrisponde a Stark.
- La barra rovesciata del metacarattere '' ha un ruolo molto importante poiché segnala varie sequenze. Se la barra rovesciata deve essere utilizzata senza il suo significato speciale come metacarattere, utilizzare ''
Esempio 2: La classe impostata [s,.] corrisponderà a qualsiasi carattere di spazio bianco, ',' o '.'.
Il codice utilizza espressioni regolari per trovare ed elencare tutte le singole cifre e le sequenze di cifre nelle stringhe di input specificate. Trova singole cifre con d> e sequenze di cifre con d+> .
Pitone
import> re> p>=> re.>compile>(>'d'>)> print>(p.findall(>'I went to him at 11 A.M. on 4th July 1886'>))> > p>=> re.>compile>(>'d+'>)> print>(p.findall(>'I went to him at 11 A.M. on 4th July 1886'>))> |
>
>Produzione
['1', '1', '4', '1', '8', '8', '6'] ['11', '4', '1886']>
Esempio 3:
Il codice utilizza espressioni regolari per trovare ed elencare caratteri verbali, sequenze di caratteri verbali e caratteri non verbali nelle stringhe di input. Fornisce elenchi dei caratteri o delle sequenze corrispondenti.
Pitone
import> re> > p>=> re.>compile>(>'w'>)> print>(p.findall(>'He said * in some_lang.'>))> > p>=> re.>compile>(>'w+'>)> print>(p.findall('I went to him at>11> A.M., he> said>*>*>*> in> some_language.'))> > p>=> re.>compile>(>'W'>)> print>(p.findall(>'he said *** in some_language.'>))> |
>
>Produzione
['H', 'e', 's', 'a', 'i', 'd', 'i', 'n', 's', 'o', 'm', 'e', '_', 'l', 'a', 'n', 'g'] ['I', 'went', 'to', 'him', 'at', '11', 'A', 'M', 'he', 'said', 'in', 'some_language'] [' ', ' ', '*', '*', '*', ' ...>
Esempio 4:
Il codice utilizza un modello di espressione regolare 'ab*' per trovare ed elencare tutte le occorrenze di 'ab' seguito da zero o più caratteri 'b' nella stringa di input ababbaabbb. Restituisce il seguente elenco di corrispondenze: ['ab', 'abb', 'abbb'].
Pitone
import> re> p>=> re.>compile>(>'ab*'>)> print>(p.findall(>'ababbaabbb'>))> |
>
installazione della torcia
>Produzione
['ab', 'abb', 'a', 'abbb']>
Comprendere l'output:
- La nostra RE è ab*, dove la 'a' accompagnata da qualsiasi no. di 'b', a partire da 0.
- L'output 'ab' è valido a causa della singola 'a' accompagnata dalla singola 'b'.
- L'output 'abb' è valido a causa della singola 'a' accompagnata da 2 'b'.
- L'uscita 'a' è valida a causa della singola 'a' accompagnata da 0 'b'.
- L'output 'abbb' è valido a causa della singola 'a' accompagnata da 3 'b'.
3. ri.dividi()
Dividi la stringa in base alle occorrenze di un carattere o di un modello, una volta trovato quel modello, i caratteri rimanenti della stringa vengono restituiti come parte dell'elenco risultante.
Sintassi:
re.split(pattern, string, maxsplit=0, flags=0)>
Il primo parametro, pattern denota l'espressione regolare, string è la stringa data in cui verrà cercato pattern e in cui avviene la suddivisione, maxsplit se non fornito è considerato zero '0' e se viene fornito un valore diverso da zero, allora al massimo si verificano così tante scissioni. Se maxsplit = 1, la stringa verrà divisa una sola volta, risultando in un elenco di lunghezza 2. I flag sono molto utili e possono aiutare ad abbreviare il codice, non sono parametri necessari, ad esempio: flags = re.IGNORECASE, in questa divisione , il caso, cioè la minuscola o la maiuscola verrà ignorato.
Esempio 1:
Divide una stringa utilizzando caratteri non verbali e spazi come delimitatori, restituendo parole: ['Words', 'words', 'Words']> . Considera gli apostrofi come caratteri non verbali: ['Word', 's', 'words', 'Words']> . Divide utilizzando caratteri e cifre non verbali: ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']> . Divide utilizzando le cifre come delimitatore: ['On ', 'th Jan ', ', at ', ':', ' AM']> .
Pitone
from> re>import> split> > print>(split(>'W+'>,>'Words, words , Words'>))> print>(split(>'W+'>,>'Word's words Words'>))> print>(split(>'W+'>,>'On 12th Jan 2016, at 11:02 AM'>))> print>(split(>'d+'>,>'On 12th Jan 2016, at 11:02 AM'>))> |
>
>Produzione
['Words', 'words', 'Words'] ['Word', 's', 'words', 'Words'] ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM'] ['On ', 'th Jan ', ', at ', ':', ' AM']>
Esempio 2:
La prima istruzione divide la stringa alla prima occorrenza di una o più cifre: ['On ', 'th Jan 2016, at 11:02 AM']> . il secondo divide la stringa utilizzando le lettere minuscole dalla a alla f come delimitatori, senza distinzione tra maiuscole e minuscole: ['', 'y, ', 'oy oh ', 'oy, ', 'ome here'> ]>. Il terzo divide la stringa utilizzando le lettere minuscole da a ad f come delimitatori, con distinzione tra maiuscole e minuscole: ['', 'ey, Boy oh ', 'oy, ', 'ome here']> .
Pitone
import> re> print>(re.split(>'d+'>,>'On 12th Jan 2016, at 11:02 AM'>,>1>))> print>(re.split(>'[a-f]+'>,>'Aey, Boy oh boy, come here'>, flags>=>re.IGNORECASE))> print>(re.split(>'[a-f]+'>,>'Aey, Boy oh boy, come here'>))> |
>
>Produzione
['On ', 'th Jan 2016, at 11:02 AM'] ['', 'y, ', 'oy oh ', 'oy, ', 'om', ' h', 'r', ''] ['A', 'y, Boy oh ', 'oy, ', 'om', ' h', 'r', '']>
4. re.sub()
Il 'sub' nella funzione sta per SubString, un certo modello di espressione regolare viene cercato nella stringa data (terzo parametro) e una volta trovato il modello della sottostringa viene sostituito da repl (secondo parametro), count controlla e mantiene il numero di volte questo accade.
Sintassi:
re.sub(pattern, repl, string, count=0, flags=0)>
Esempio 1:
- La prima istruzione sostituisce tutte le occorrenze di 'ub' con '~*' (senza distinzione tra maiuscole e minuscole):
'S~*ject has ~*er booked already'>. - La seconda istruzione sostituisce tutte le occorrenze di 'ub' con '~*' (con distinzione tra maiuscole e minuscole):
'S~*ject has Uber booked already'>. - La terza istruzione sostituisce la prima occorrenza di 'ub' con '~*' (senza distinzione tra maiuscole e minuscole):
'S~*ject has Uber booked already'>. - Il quarto sostituisce 'AND' con '&' (senza distinzione tra maiuscole e minuscole):
'Baked Beans & Spam'>.
Pitone
import> re> print>(re.sub(>'ub'>,>'~*'>,>'Subject has Uber booked already'>,> >flags>=>re.IGNORECASE))> print>(re.sub(>'ub'>,>'~*'>,>'Subject has Uber booked already'>))> print>(re.sub(>'ub'>,>'~*'>,>'Subject has Uber booked already'>,> >count>=>1>, flags>=>re.IGNORECASE))> print>(re.sub(r>'sANDs'>,>' & '>,>'Baked Beans And Spam'>,> >flags>=>re.IGNORECASE))> |
>
>Produzione
S~*ject has ~*er booked already S~*ject has Uber booked already S~*ject has Uber booked already Baked Beans & Spam>
5. re.subn()
subn() è simile a sub() in tutti i sensi, tranne che nel modo di fornire l'output. Restituisce una tupla con il conteggio del totale delle sostituzioni e della nuova stringa anziché solo della stringa.
Sintassi:
re.subn(pattern, repl, string, count=0, flags=0)>
Esempio:
re.subn()> sostituisce tutte le occorrenze di un modello in una stringa e restituisce una tupla con la stringa modificata e il conteggio delle sostituzioni effettuate. È utile sia per le sostituzioni con distinzione tra maiuscole e minuscole e senza distinzione tra maiuscole e minuscole.
Pitone
import> re> > print>(re.subn(>'ub'>,>'~*'>,>'Subject has Uber booked already'>))> > t>=> re.subn(>'ub'>,>'~*'>,>'Subject has Uber booked already'>,> >flags>=>re.IGNORECASE)> print>(t)> print>(>len>(t))> print>(t[>0>])> |
>
>Produzione
('S~*ject has Uber booked already', 1) ('S~*ject has ~*er booked already', 2) 2 S~*ject has ~*er booked already> 6. ri.fuga()
Restituisce una stringa con tutti i caratteri non alfanumerici barrati indietro, questo è utile se si desidera far corrispondere una stringa letterale arbitraria che potrebbe contenere metacaratteri di espressioni regolari.
Sintassi:
re.escape(string)>
Esempio:
re.escape()> viene utilizzato per eseguire l'escape dei caratteri speciali in una stringa, rendendone sicuro l'utilizzo come modello nelle espressioni regolari. Garantisce che tutti i caratteri con significati speciali nelle espressioni regolari vengano trattati come caratteri letterali.
Pitone
import> re> print>(re.escape(>'This is Awesome even 1 AM'>))> print>(re.escape(>'I Asked what is this [a-9], he said ^WoW'>))> |
>
>Produzione
This is Awesome even 1 AM I Asked what is this [a-9], he said ^WoW>
7. ricerca()
Questo metodo restituisce None (se il modello non corrisponde) oppure un re.MatchObject contiene informazioni sulla parte corrispondente della stringa. Questo metodo si interrompe dopo la prima corrispondenza, quindi è più adatto per testare un'espressione regolare più che per estrarre dati.
Esempio: Ricerca di un'occorrenza del modello
Questo codice utilizza un'espressione regolare per cercare un modello nella stringa data. Se viene trovata una corrispondenza, estrae e stampa le parti corrispondenti della stringa.
In questo esempio specifico, cerca uno schema composto da un mese (lettere) seguito da un giorno (cifre) nella stringa di input Sono nato il 24 giugno. Se viene trovata una corrispondenza, stampa la corrispondenza completa, il mese e il giorno.
Python3
import> re> regex>=> r>'([a-zA-Z]+) (d+)'> > match>=> re.search(regex,>'I was born on June 24'>)> if> match !>=> None>:> >print> (>'Match at index %s, %s'> %> (match.start(), match.end()))> >print> (>'Full match: %s'> %> (match.group(>0>)))> >print> (>'Month: %s'> %> (match.group(>1>)))> >print> (>'Day: %s'> %> (match.group(>2>)))> > else>:> >print> (>'The regex pattern does not match.'>)> |
>
>Produzione
Match at index 14, 21 Full match: June 24 Month: June Day: 24>
IMPOSTA
UN Impostato è un insieme di caratteri racchiusi tra parentesi quadre '[]'. I set vengono utilizzati per trovare la corrispondenza con un singolo carattere nel set di caratteri specificato tra parentesi. Di seguito l'elenco dei Set:
| Impostato | Descrizione |
|---|---|
| {N,} | Quantifica il carattere o il gruppo precedente e corrisponde ad almeno n occorrenze. |
| * | Quantifica il carattere o il gruppo precedente e corrisponde a zero o più occorrenze. |
| [0123] | Corrisponde alle cifre specificate (0, 1, 2 o 3) |
| [^arn] | corrisponde a qualsiasi carattere TRANNE a, r e n |
| D | Corrisponde a qualsiasi cifra (0-9). |
| [0-5] [0-9] | corrisponde a qualsiasi numero a due cifre compreso tra 00 e 59 |
| In | Corrisponde a qualsiasi carattere alfanumerico (a-z, A-Z, 0-9 o _). |
| [UN] | Corrisponde a qualsiasi alfabeto minuscolo compreso tra a e n. |
| D | Corrisponde a qualsiasi carattere non numerico. |
| [arn] | corrisponde alla presenza di uno dei caratteri specificati (a, r o n). |
| [a-zA-Z] | corrisponde a qualsiasi carattere compreso tra aez, minuscolo O maiuscolo |
| [0-9] | corrisponde a qualsiasi cifra compresa tra 0 e 9 |
Abbina oggetto
Un oggetto Match contiene tutte le informazioni sulla ricerca e sul risultato e se non viene trovata alcuna corrispondenza verrà restituito None. Vediamo alcuni dei metodi e degli attributi comunemente utilizzati dell'oggetto match.
1. Ottenere la stringa e la regex
match.re l'attributo restituisce l'espressione regolare passata e corrispondenza.stringa l'attributo restituisce la stringa passata.
Esempio: Ottenere la stringa e la regex dell'oggetto corrispondente
Il codice cerca la lettera G al confine di una parola nella stringa Benvenuto su GeeksForGeeks e stampa il modello di espressione regolare ( res.re> ) e la stringa originale ( res.string> ) .
Python3
import> re> s>=> 'Welcome to GeeksForGeeks'> res>=> re.search(r>'G'>, s)> > print>(res.re)> print>(res.string)> |
>
>Produzione
re.compile('G') Welcome to GeeksForGeeks> 2. Ottenere l'indice dell'oggetto corrispondente
- Il metodo start() restituisce l'indice iniziale della sottostringa corrispondente
- Il metodo end() restituisce l'indice finale della sottostringa corrispondente
- Il metodo span() restituisce una tupla contenente l'indice iniziale e finale della sottostringa corrispondente
Esempio: Ottenere l'indice dell'oggetto corrispondente
Il codice cerca la sottostringa Gee al confine di una parola nella stringa Welcome to GeeksForGeeks e stampa l'indice iniziale della corrispondenza (res.start()>), l'indice finale della corrispondenza (res.end()>) e la durata della partita (res.span()>).
Python3
import> re> > s>=> 'Welcome to GeeksForGeeks'> > res>=> re.search(r>'Gee'>, s)> > print>(res.start())> print>(res.end())> print>(res.span())> |
>
>Produzione
11 14 (11, 14)>
3. Ottenere la sottostringa corrispondente
Il metodo group() restituisce la parte della stringa per la quale corrispondono i modelli. Vedere l'esempio seguente per una migliore comprensione.
Esempio: Ottenere la sottostringa corrispondente
Il codice cerca una sequenza di due caratteri non numerici seguiti da uno spazio e dalla lettera 't' nella stringa Welcome to GeeksForGeeks e stampa il testo corrispondente utilizzando res.group()> .
Python3
barrato il ribasso
import> re> s>=> 'Welcome to GeeksForGeeks'> res>=> re.search(r>'D{2} t'>, s)> print>(res.group())> |
>
>Produzione
me t>
Nell'esempio precedente, il nostro pattern specifica la stringa che contiene almeno 2 caratteri seguiti da uno spazio e tale spazio è seguito da una t.
Articolo correlato:
Riferimento:
https://docs.python.org/2/library/re.html
Abbiamo discusso di RegEx in Python, abbiamo esaminato i metacaratteri, le funzioni e le sequenze speciali in RegEx Python.
L'espressione regolare è un concetto molto importante in Python, abbiamo cercato di spiegarlo in modo semplice. Spero che ti aiuti nel tuo viaggio in Python!!