A Expressió regular o RegEx és una seqüència especial de caràcters que utilitza un patró de cerca per trobar una cadena o un conjunt de cadenes.
Pot detectar la presència o absència d'un text fent coincidir-lo amb un patró determinat i també pot dividir un patró en un o més sub-patrons.
Mòdul Regex en Python
Python té un mòdul integrat anomenat re que s'utilitza per a expressions regulars en Python. Podem importar aquest mòdul mitjançant la instrucció import .
Exemple: Importació del mòdul re a Python
Python 3
# importing re module> import> re> |
>
>
Com utilitzar RegEx a Python?
Podeu utilitzar RegEx a Python després d'importar el mòdul re.
Exemple:
Aquest codi de Python utilitza expressions regulars per cercar la paraula portal a la cadena donada i després imprimeix els índexs inicial i final de la paraula coincident dins de la cadena.
Python 3
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())> |
>
>Sortida
Start Index: 34 End Index: 40>
Nota: Aquí el caràcter r (r'portal') significa raw, no regex. La cadena en brut és lleugerament diferent d'una cadena normal, no interpretarà el caràcter com un caràcter d'escapada. Això es deu al fet que el motor d'expressions regulars utilitza el caràcter per al seu propi propòsit d'escapament.
Abans de començar amb el mòdul d'expressió regular de Python, vegem com escriure expressament utilitzant metacaracters o seqüències especials.
Metapersonatges
Els metacaràcters són els personatges amb un significat especial.
Per entendre l'analogia RE, els metacaracters són útils i importants. S'utilitzaran en funcions del mòdul re. A continuació es mostra la llista de metacaràcters.
| Metapersonatges | Descripció |
|---|---|
| S'utilitza per deixar anar el significat especial del caràcter que el segueix quantes ciutats hi ha als Estats Units | |
| [] | Representar una classe de personatges |
| ^ | Coincideix amb el principi |
| $ | Coincideix amb el final |
| . | Coincideix amb qualsevol caràcter excepte la nova línia |
| | | Significa OR (Coincideix amb qualsevol dels caràcters separats per aquest. |
| ? | Coincideix amb zero o una ocurrència |
| * | Qualsevol nombre d'ocurrències (incloent-ne 0) |
| + | Una o més ocurrències |
| {} | Indiqueu el nombre d'ocurrències d'una expressió regular anterior per coincidir. |
| () | Inclou un grup de Regex |
Parlem detalladament de cadascun d'aquests metacaràcters:
1. – Barra invertida
La barra invertida () assegura que el caràcter no sigui tractat d'una manera especial. Això es pot considerar una manera d'escapar dels metacaràcters.
Per exemple, si voleu cercar el punt (.) a la cadena, trobareu que el punt (.) es tractarà com un caràcter especial com un dels metacaràcters (com es mostra a la taula anterior). Per tant, per a aquest cas, utilitzarem la barra invertida() just abans del punt(.) perquè perdi la seva especialitat. Vegeu l'exemple següent per a una millor comprensió.
Exemple:
La primera recerca ( re.search(r'.', s)> ) coincideix amb qualsevol caràcter, no només amb el punt, mentre que la segona cerca ( re.search(r'.', s)> ) específicament cerca i coincideix amb el caràcter del període.
Python 3
import> re> > s>=> 'geeks.forgeeks'> > # without using> match>=> re.search(r>'.'>, s)> print>(match)> > # using> match>=> re.search(r>'.'>, s)> print>(match)> |
>
>Sortida
>
2. [] – claudàtors
Els claudàtors ([]) representen una classe de caràcters formada per un conjunt de caràcters que volem fer coincidir. Per exemple, la classe de caràcters [abc] coincidirà amb qualsevol a, b o c.
També podem especificar un rang de caràcters utilitzant - dins dels claudàtors. Per exemple,
- [0, 3] és una mostra com [0123]
- [a-c] és el mateix que [abc]
També podem invertir la classe de caràcters utilitzant el símbol de curs (^). Per exemple,
- [^0-3] significa qualsevol nombre excepte 0, 1, 2 o 3
- [^a-c] significa qualsevol caràcter excepte a, b o c
Exemple:
En aquest codi, utilitzeu expressions regulars per trobar tots els caràcters de la cadena que es troben dins de l'interval de 'a' a 'm'. El re.findall()> La funció retorna una llista de tots aquests caràcters. A la cadena donada, els caràcters que coincideixen amb aquest patró són: 'c', 'k', 'b', 'f', 'j', 'e', 'h', 'l', 'd', ' g'.
Python 3
import> re> > string>=> 'The quick brown fox jumps over the lazy dog'> pattern>=> '[a-m]'> result>=> re.findall(pattern, string)> > print>(result)> |
>
>Sortida
['h', 'e', 'i', 'c', 'k', 'b', 'f', 'j', 'm', 'e', 'h', 'e', 'l', 'a', 'd', 'g']>
3. ^ – Caret
El símbol de cursor (^) coincideix amb l'inici de la cadena, és a dir, comprova si la cadena comença amb els caràcters donats o no. Per exemple -
- ^g comprovarà si la cadena comença amb g, com ara geeks, globe, girl, g, etc.
- ^ge comprovarà si la cadena comença amb ge, com ara geeks, geeksforgeeks, etc.
Exemple:
Aquest codi utilitza expressions regulars per comprovar si comença una llista de cadenes El . Si una cadena comença per El, està marcat com a Coincidència en cas contrari, s'etiqueta com a No coincideix.
Python 3
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}'>)> |
>
>Sortida
Matched: The quick brown fox Matched: The lazy dog Not matched: A quick brown fox>
4. $ – Dòlar
El símbol del dòlar ($) coincideix amb el final de la cadena, és a dir, comprova si la cadena acaba amb els caràcters donats o no. Per exemple-
- s$ comprovarà la cadena que acaba amb a, com ara geeks, ends, s, etc.
- ks$ comprovarà la cadena que acaba amb ks com ara geeks, geeksforgeeks, ks, etc.
Exemple:
Aquest codi utilitza una expressió regular per comprovar si la cadena acaba amb Món!. Si es troba una coincidència, s'imprimeix Partit trobat! en cas contrari, imprimeix No s'ha trobat la coincidència .
Python 3
import> re> > string>=> 'Hello World!'> pattern>=> r>'World!$'> > match>=> re.search(pattern, string)> if> match:> >print>(>'Match found!'>)> else>:> >print>(>'Match not found.'>)> |
>
>Sortida
Match found!>
5. . – Punt
El símbol de punt (.) només coincideix amb un caràcter, excepte el caràcter de nova línia ( ). Per exemple -
- a.b comprovarà la cadena que contingui qualsevol caràcter al lloc del punt, com ara acb, acbd, abbb, etc.
- .. comprovarà si la cadena conté almenys 2 caràcters
Exemple:
Aquest codi utilitza una expressió regular per cercar el patró brown.fox dins de la cadena. El punt (.>) al patró representa qualsevol caràcter. Si es troba una coincidència, s'imprimeix Partit trobat! en cas contrari, imprimeix No s'ha trobat la coincidència .
Python 3
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.'>)> |
>
>Sortida
Match found!>
6. | – O
El símbol Or funciona com a operador or, el que significa que verifica si el patró abans o després del símbol or està present a la cadena o no. Per exemple -
- a|b coincidirà amb qualsevol cadena que contingui a o b com ara acd, bcd, abcd, etc.
7. ? - Signe d'interrogació
El signe d'interrogació (?) és un quantificador en expressions regulars que indica que l'element anterior hauria de coincidir amb zero o una vegada. Us permet especificar que l'element és opcional, és a dir, pot ocórrer una vegada o no. Per exemple,
- ab?c es farà coincidir per a la cadena ac, acb, dabc, però no coincidirà amb abbc perquè n'hi ha dos b. De la mateixa manera, no es farà coincidir per a abdc perquè b no va seguit de c.
8.* – Estrella
El símbol estrella (*) coincideix amb zero o més ocurrències de l'expressió regular que precedeixen el símbol *. Per exemple -
- ab*c es farà coincidir per a la cadena ac, abc, abbbc, dabc, etc. però no es farà coincidir amb abdc perquè b no va seguida de c.
9. + – A més
El símbol més (+) coincideix amb una o més ocurrències de l'expressió regular que precedeixen el símbol +. Per exemple -
- ab+c es farà coincidir per a la cadena abc, abbc, dabc, però no es coincidirà amb ac, abdc, perquè no hi ha b a ac i b, no va seguida de c a abdc.
10. {m, n} – Tirants
Les claus coincideixen amb qualsevol repetició que precedeixi l'expressió regular de m a n ambdós inclosos. Per exemple -
char i int java
- a{2, 4} es farà coincidir per a la cadena aaab, baaaac, gaad, però no es farà coincidir per a cadenes com abc, bc perquè només hi ha una a o cap a en tots dos casos.
11. () – Grup
El símbol de grup s'utilitza per agrupar subpatrons. Per exemple -
- (a|b)cd coincidirà amb cadenes com acd, abcd, gacd, etc.
Seqüències especials
Les seqüències especials no coincideixen amb el caràcter real de la cadena, sinó que indica la ubicació específica de la cadena de cerca on s'ha de produir la coincidència. Fa que sigui més fàcil escriure patrons d'ús habitual.
Llista de seqüències especials
| Seqüència especial | Descripció | Exemples | |
|---|---|---|---|
| A | Coincideix si la cadena comença amb el caràcter donat | Afora | per als frikis |
| per al món | |||
| Coincideix si la paraula comença o acaba amb el caràcter donat. (cadena) comprovarà l'inici de la paraula i (cadena) comprovarà el final de la paraula. | ge | frikis | |
| aconseguir | |||
| B | És el contrari del , és a dir, la cadena no hauria de començar ni acabar amb l'expressió regular donada. | Bge | junts |
| forjar | |||
| d | Coincideix amb qualsevol dígit decimal, això és equivalent a la classe establerta [0-9] | d | 123 |
| vaja1 | |||
| D | Coincideix amb qualsevol caràcter que no sigui dígit, és equivalent a la classe establerta [^0-9] | D | frikis |
| friki 1 | |||
| s | Coincideix amb qualsevol caràcter d'espai en blanc. | s | vaja ks |
| a bc a | |||
| S | Coincideix amb qualsevol caràcter que no sigui espai en blanc | S | un bd |
| abcd | |||
| En | Coincideix amb qualsevol caràcter alfanumèric, és equivalent a la classe [a-zA-Z0-9_]. | En | 123 |
| geeKs4 | |||
| IN | Coincideix amb qualsevol caràcter no alfanumèric. | IN | >$ |
| donar | |||
| AMB | Coincideix si la cadena acaba amb l'expressió regular donada | ab | abcdab |
| bababab |
Funcions RegEx
re el mòdul conté molts funcions que ens ajuden a buscar una cadena per trobar una coincidència.
Vegem diverses funcions proporcionades per aquest mòdul per treballar amb regex a Python.
| Funció | Descripció |
|---|---|
| re.findall() | cerca i retorna totes les ocurrències coincidents en una llista |
| re.compile() | Les expressions regulars es compilen en objectes de patró |
| re.dividir() | Dividiu la cadena per les ocurrències d'un caràcter o d'un patró. |
| re.sub() | Substitueix totes les ocurrències d'un caràcter o pattern per una cadena de substitució. |
| re.escape() | S'escapa de caràcter especial |
| re.search() | Cerca la primera aparició de caràcter o patró |
Vegem el funcionament d'aquestes funcions RegEx amb definició i exemples:
1. tornar a trobar()
Retorna totes les coincidències del patró que no es superposen a la cadena, com a llista de cadenes. La cadena s'escaneja d'esquerra a dreta i les coincidències es retornen en l'ordre trobat.
Trobar totes les ocurrències d'un patró
Aquest codi utilitza una expressió regular ( d+> ) per trobar totes les seqüències d'un o més dígits en la cadena donada. Cerca valors numèrics i els emmagatzema en una llista. En aquest exemple, cerca i imprimeix els números 123456789 i 987654321 de la cadena d'entrada.
Python 3
import> re> string>=> '''Hello my Number is 123456789 and> >my friend's number is 987654321'''> regex>=> 'd+'> > match>=> re.findall(regex, string)> print>(match)> |
>
>Sortida
['123456789', '987654321']>
2. tornar a compilar()
Les expressions regulars es compilen en objectes de patró, que tenen mètodes per a diverses operacions, com ara cercar coincidències de patrons o realitzar substitucions de cadenes.
Exemple 1:
El codi utilitza un patró d'expressió regular [a-e]> per trobar i llistar totes les lletres minúscules de la 'a' a la 'e' a la cadena d'entrada Sí, va dir el senyor Gibenson Stark. La sortida serà ['e', 'a', 'd', 'b', 'e']> , que són els caràcters coincidents.
Python
import> re> p>=> re.>compile>(>'[a-e]'>)> > print>(p.findall(>'Aye, said Mr. Gibenson Stark'>))> |
>
>Sortida
['e', 'a', 'd', 'b', 'e', 'a']>
Comprensió de la sortida:
- La primera aparició és 'e' a Sí i no 'A', ja que és sensible a majúscules i minúscules.
- La següent ocurrència és 'a' en dit, després 'd' en dit, seguit de 'b' i 'e' a Gibenson, l'última 'a' coincideix amb Stark.
- La barra invertida de metacaràcter '' té un paper molt important, ja que senyalitza diverses seqüències. Si la barra invertida s'ha d'utilitzar sense el seu significat especial com a metacaràcter, utilitzeu ''
Exemple 2: Estableix la classe [s,.] coincidirà amb qualsevol caràcter d'espai en blanc, ',' o, '.' .
El codi utilitza expressions regulars per trobar i llistar tots els dígits individuals i seqüències de dígits a les cadenes d'entrada donades. Troba un dígit amb d> i seqüències de dígits amb d+> .
Python
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'>))> |
és igual al mètode java
>
>Sortida
['1', '1', '4', '1', '8', '8', '6'] ['11', '4', '1886']>
Exemple 3:
El codi utilitza expressions regulars per trobar i llistar caràcters de paraula, seqüències de caràcters de paraula i caràcters que no són de paraula a les cadenes d'entrada. Proporciona llistes de caràcters o seqüències coincidents.
Python
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.'>))> |
>
>Sortida
['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'] [' ', ' ', '*', '*', '*', ' ...>
Exemple 4:
El codi utilitza un patró d'expressió regular 'ab*' per trobar i llistar totes les ocurrències de 'ab' seguit de zero o més caràcters 'b' a la cadena d'entrada abbaabbb. Retorna la següent llista de coincidències: ['ab', 'abb', 'abbb'].
Python
import> re> p>=> re.>compile>(>'ab*'>)> print>(p.findall(>'ababbaabbb'>))> |
>
interruptor mecanografiat
>Sortida
['ab', 'abb', 'a', 'abbb']>
Comprensió de la sortida:
- El nostre RE és ab*, que ‘a’ acompanyat de qualsevol no. de ‘b’s, a partir de 0.
- La sortida 'ab' és vàlida perquè la 'a' única acompanyada de la 'b' única.
- La sortida 'abb', és vàlida a causa de la única 'a' acompanyada de 2 'b'.
- La sortida 'a' és vàlida perquè la 'a' única acompanyada de 0 'b'.
- La sortida 'abbb', és vàlida a causa de la única 'a' acompanyada de 3 'b'.
3. re.dividir()
Dividiu la cadena per les ocurrències d'un caràcter o d'un patró, en trobar aquest patró, els caràcters restants de la cadena es retornen com a part de la llista resultant.
Sintaxi:
re.split(pattern, string, maxsplit=0, flags=0)>
El primer paràmetre, patró denota l'expressió regular, cadena és la cadena donada en la qual es buscarà el patró i en què es produeix la divisió, maxsplit si no es proporciona es considera zero '0', i si es proporciona un valor diferent de zero, aleshores com a molt que es produeixen moltes escissions. Si maxsplit = 1, la cadena només es dividirà una vegada, donant com a resultat una llista de longitud 2. Els senyaladors són molt útils i poden ajudar a escurçar el codi, no són paràmetres necessaris, per exemple: flags = re.IGNORECASE, en aquesta divisió , el cas, és a dir, s'ignorarà la minúscula o la majúscula.
Exemple 1:
Divideix una cadena utilitzant caràcters i espais que no són de paraula com a delimitadors, retornant paraules: ['Words', 'words', 'Words']> . Considera els apòstrofs com a caràcters no verbals: ['Word', 's', 'words', 'Words']> . Divideix utilitzant caràcters i dígits que no són paraules: ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']> . Divideix utilitzant els dígits com a delimitador: ['On ', 'th Jan ', ', at ', ':', ' AM']> .
Python
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'>))> |
>
>Sortida
['Words', 'words', 'Words'] ['Word', 's', 'words', 'Words'] ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM'] ['On ', 'th Jan ', ', at ', ':', ' AM']>
Exemple 2:
La primera instrucció divideix la cadena a la primera aparença d'un o més dígits: ['On ', 'th Jan 2016, at 11:02 AM']> . segon divideix la cadena utilitzant lletres minúscules de la a a la f com a delimitadors, sense distingir entre majúscules i minúscules: ['', 'y, ', 'oy oh ', 'oy, ', 'ome here'> ]>. Tercer divideix la cadena utilitzant lletres minúscules de la a a la f com a delimitadors, que distingeixen entre majúscules i minúscules: ['', 'ey, Boy oh ', 'oy, ', 'ome here']> .
Python
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'>))> |
>
>Sortida
['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()
El 'sub' de la funció significa SubString, un determinat patró d'expressió regular es cerca a la cadena donada (3r paràmetre) i en trobar el patró de subcadena es substitueix per repl (2n paràmetre), el recompte comprova i manté el nombre de vegades. això passa.
Sintaxi:
re.sub(pattern, repl, string, count=0, flags=0)>
Exemple 1:
- La primera instrucció substitueix totes les aparicions de 'ub' per '~*' (no distingeix entre majúscules i minúscules):
'S~*ject has ~*er booked already'>. - La segona declaració substitueix totes les ocurrències de 'ub' per '~*' (distingeix entre majúscules i minúscules):
'S~*ject has Uber booked already'>. - La tercera declaració substitueix la primera ocurrència de 'ub' per '~*' (insensible a majúscules i minúscules):
'S~*ject has Uber booked already'>. - Quart substitueix 'AND' per '&' (no distingeix entre majúscules i minúscules):
'Baked Beans & Spam'>.
Python
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))> |
>
>Sortida
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() és similar a sub() en tots els aspectes, excepte en la seva manera de proporcionar sortida. Retorna una tupla amb un recompte del total de substitució i la cadena nova en lloc de només la cadena.
Sintaxi:
re.subn(pattern, repl, string, count=0, flags=0)>
Exemple:
re.subn()> substitueix totes les ocurrències d'un patró en una cadena i retorna una tupla amb la cadena modificada i el recompte de substitucions fetes. És útil tant per a substitucions que distingeixen entre majúscules i minúscules com per a les substitucions que no distingeixen entre majúscules i minúscules.
Python
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>])> |
>
>Sortida
('S~*ject has Uber booked already', 1) ('S~*ject has ~*er booked already', 2) 2 S~*ject has ~*er booked already> 6. re.escape()
Retorna una cadena amb totes les barres invertides no alfanumèriques, això és útil si voleu fer coincidir una cadena literal arbitrària que pot tenir metacaràcters d'expressió regular.
Sintaxi:
re.escape(string)>
Exemple:
re.escape()> s'utilitza per escapar de caràcters especials d'una cadena, de manera que és segur utilitzar-lo com a patró en expressions regulars. Assegura que tots els caràcters amb significats especials en expressions regulars es tracten com a caràcters literals.
Python
import> re> print>(re.escape(>'This is Awesome even 1 AM'>))> print>(re.escape(>'I Asked what is this [a-9], he said ^WoW'>))> |
>
>Sortida
This is Awesome even 1 AM I Asked what is this [a-9], he said ^WoW>
7. re.search()
Aquest mètode o bé retorna Cap (si el patró no coincideix) o un re.MatchObject conté informació sobre la part coincident de la cadena. Aquest mètode s'atura després de la primera coincidència, de manera que és més adequat per provar una expressió regular més que per extreure dades.
Exemple: Cerca d'una ocurrència del patró
Aquest codi utilitza una expressió regular per cercar un patró a la cadena donada. Si es troba una coincidència, extreu i imprimeix les parts coincidents de la cadena.
En aquest exemple concret, cerca un patró que consta d'un mes (lletres) seguit d'un dia (dígits) a la cadena d'entrada Vaig néixer el 24 de juny. Si es troba una coincidència, imprimeix la coincidència completa, el mes , i el dia.
Python 3
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.'>)> |
>
>Sortida
Match at index 14, 21 Full match: June 24 Month: June Day: 24>
COL · LECCIONS
A Conjunt és un conjunt de caràcters entre claudàtors ‘[]’. Els conjunts s'utilitzen per fer coincidir un sol caràcter del conjunt de caràcters especificat entre claudàtors. A continuació es mostra la llista de conjunts:
| Conjunt | Descripció |
|---|---|
| {n,} | Quantifica el caràcter o grup anterior i coincideix com a mínim amb n aparicions. |
| * | Quantifica el caràcter o grup anterior i coincideix amb zero o més ocurrències. |
| [0123] | Coincideix amb els dígits especificats (0, 1, 2 o 3) |
| [^arn] | coincideix amb qualsevol caràcter EXCEPTE a, r i n |
| d | Coincideix amb qualsevol dígit (0-9). |
| [0-5][0-9] | coincidències per a qualsevol nombre de dues xifres del 00 i el 59 |
| En | Coincideix amb qualsevol caràcter alfanumèric (a-z, A-Z, 0-9 o _). |
| [a-n] | Coincideix amb qualsevol alfabet en minúscula entre a i n. |
| D | Coincideix amb qualsevol caràcter que no sigui dígit. |
| [arn] | coincideix amb un dels caràcters especificats (a, r o n). |
| [a-zA-Z] | coincideix amb qualsevol caràcter entre a i z, minúscules O majúscules |
| [0-9] | coincideix amb qualsevol dígit entre 0 i 9 |
Coincideix amb l'objecte
Un objecte Match conté tota la informació sobre la cerca i el resultat i si no es troba cap coincidència, es retornarà Cap. Vegem alguns dels mètodes i atributs més utilitzats de l'objecte de concordança.
1. Obtenció de la cadena i l'expressió regular
match.re l'atribut retorna l'expressió regular passat i coincideix.cadena attribute retorna la cadena passada.
Exemple: Obtenció de la cadena i l'expressió regular de l'objecte coincident
El codi cerca la lletra G en un límit de paraula de la cadena Benvingut a GeeksForGeeks i imprimeix el patró d'expressió regular ( res.re> ) i la cadena original ( res.string> ) .
Python 3
import> re> s>=> 'Welcome to GeeksForGeeks'> res>=> re.search(r>'G'>, s)> > print>(res.re)> print>(res.string)> |
cadena subcadena java
>
>Sortida
re.compile('G') Welcome to GeeksForGeeks> 2. Obtenció de l'índex de l'objecte coincident
- El mètode start() retorna l'índex inicial de la subcadena coincident
- El mètode end() retorna l'índex final de la subcadena coincident
- El mètode span() retorna una tupla que conté l'índex inicial i final de la subcadena coincident
Exemple: Obtenció de l'índex de l'objecte coincident
El codi cerca la subcadena Gee en un límit de paraula a la cadena Benvingut a GeeksForGeeks i imprimeix l'índex inicial de la coincidència (res.start()>), l'índex final del partit (res.end()>), i la durada del partit (res.span()>).
Python 3
import> re> > s>=> 'Welcome to GeeksForGeeks'> > res>=> re.search(r>'Gee'>, s)> > print>(res.start())> print>(res.end())> print>(res.span())> |
>
>Sortida
11 14 (11, 14)>
3. Obtenció de subcadenes coincidents
El mètode group() retorna la part de la cadena per a la qual coincideixen els patrons. Vegeu l'exemple següent per a una millor comprensió.
Exemple: S'està fent coincidir la subcadena
El codi cerca una seqüència de dos caràcters sense dígits seguits d'un espai i de la lletra 't' a la cadena Benvingut a GeeksForGeeks i imprimeix el text coincident amb res.group()> .
Python 3
import> re> s>=> 'Welcome to GeeksForGeeks'> res>=> re.search(r>'D{2} t'>, s)> print>(res.group())> |
>
>Sortida
me t>
A l'exemple anterior, el nostre patró especifica per a la cadena que conté almenys 2 caràcters que van seguits d'un espai i aquest espai va seguit d'una t.
Article relacionat:
Referència:
https://docs.python.org/2/library/re.html
Hem parlat de RegEx a Python, hem passat pels metacaracters, funcions i seqüències especials de RegEx Python.
L'expressió regular és un concepte molt important en Python, hem intentat explicar-ho d'una manera fàcil. Espero que us ajudi en el vostre viatge a Python!!