A Regulární výraz nebo RegEx je speciální sekvence znaků, která používá vyhledávací vzor k nalezení řetězce nebo sady řetězců.
Dokáže detekovat přítomnost nebo nepřítomnost textu jeho porovnáváním s konkrétním vzorem a také může rozdělit vzor na jeden nebo více dílčích vzorů.
Modul Regex v Pythonu
Python má vestavěný modul s názvem re který se používá pro regulární výrazy v Pythonu. Tento modul můžeme importovat pomocí příkazu import .
Příklad: Import modulu re v Pythonu
Python3
# importing re module> import> re> |
>
>
Jak používat RegEx v Pythonu?
Po importu modulu re můžete použít RegEx v Pythonu.
Příklad:
Tento kód Pythonu používá k hledání slova regulární výrazy portál v daném řetězci a poté vytiskne počáteční a koncové indexy shodného slova v řetězci.
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())> |
>
>Výstup
Start Index: 34 End Index: 40>
Poznámka: Zde znak r (r’portal’) znamená raw, nikoli regex. Nezpracovaný řetězec se mírně liší od běžného řetězce, nebude interpretovat znak jako znak escape. Je to proto, že modul regulárních výrazů používá znak pro svůj vlastní účel escapování.
Než začneme s modulem regulárního výrazu v Pythonu, podívejme se, jak skutečně napsat regulární výraz pomocí metaznaků nebo speciálních sekvencí.
Metaznaky
Metaznaky jsou znaky se zvláštním významem.
Pro pochopení analogie RE jsou metaznaky užitečné a důležité. Budou použity ve funkcích modulu re. Níže je uveden seznam metaznaků.
Metaznaky | Popis |
---|---|
Používá se k odstranění speciálního významu znaku, který za ním následuje hashmap | |
[] | Představuje třídu postavy |
^ | Odpovídá začátku |
$ | Odpovídá konci |
. | Odpovídá libovolnému znaku kromě nového řádku |
| | Znamená NEBO (Shoduje se s kterýmkoli ze znaků, které jsou jím odděleny. |
? | Odpovídá nule nebo jednomu výskytu |
* | Libovolný počet výskytů (včetně 0 výskytů) |
+ | Jeden nebo více výskytů |
{} | Uveďte počet výskytů předchozího regulárního výrazu, který se má shodovat. |
() | Uzavřete skupinu Regex |
Proberme si každý z těchto metaznaků podrobně:
1. – Zpětné lomítko
Zpětné lomítko () zajišťuje, že se znakem nezachází zvláštním způsobem. To lze považovat za způsob, jak uniknout metaznakům.
Například, pokud chcete hledat tečku(.) v řetězci, zjistíte, že tečka(.) bude považována za speciální znak, stejně jako jeden z metaznaků (jak je uvedeno v tabulce výše). Pro tento případ tedy použijeme zpětné lomítko() těsně před tečkou(.), aby to ztratilo svou specialitu. Pro lepší pochopení se podívejte na níže uvedený příklad.
Příklad:
První hledání ( re.search(r'.', s)>
) při druhém hledání odpovídá libovolnému znaku, nejen tečce ( re.search(r'.', s)>
) konkrétně vyhledává a odpovídá dobovému charakteru.
Python3
import> re> > s> => 'geeks.forgeeks'> > # without using> match> => re.search(r> '.'> , s)> print> (match)> > # using> match> => re.search(r> '.'> , s)> print> (match)> |
>
>Výstup
>
2. [] – Hranaté závorky
Hranaté závorky ([]) představují třídu znaků sestávající ze sady znaků, které chceme porovnat. Například třída znaků [abc] bude odpovídat libovolnému jednotlivému a, b nebo c.
Rozsah znaků můžeme určit také pomocí – uvnitř hranatých závorek. Například,
- [0, 3] je příklad jako [0123]
- [a-c] je stejné jako [abc]
Třídu znaků můžeme také invertovat pomocí symbolu caret(^). Například,
- [^0-3] znamená jakékoli číslo kromě 0, 1, 2 nebo 3
- [^a-c] znamená jakýkoli znak kromě a, b nebo c
Příklad:
V tomto kódu používáte regulární výrazy k nalezení všech znaků v řetězci, které spadají do rozsahu „a“ až „m“. The re.findall()>
funkce vrací seznam všech takových znaků. V daném řetězci jsou znaky, které odpovídají tomuto vzoru: '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)> |
>
>Výstup
['h', 'e', 'i', 'c', 'k', 'b', 'f', 'j', 'm', 'e', 'h', 'e', 'l', 'a', 'd', 'g']>
3. ^ – Stříška
Symbol stříšky (^) odpovídá začátku řetězce, tj. kontroluje, zda řetězec začíná daným znakem (znaky) nebo ne. Například -
- ^g zkontroluje, zda řetězec začíná g, například geeks, globe, girl, g atd.
- ^ge zkontroluje, zda řetězec začíná na ge, jako jsou geeks, geeksforgeeks atd.
Příklad:
Tento kód používá regulární výrazy ke kontrole, zda seznam řetězců začíná The . Pokud řetězec začíná na Je to označeno jako Odpovídající jinak je označen jako Nesouhlasí.
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}'> )> |
>
>Výstup
Matched: The quick brown fox Matched: The lazy dog Not matched: A quick brown fox>
4. $ – dolar
Symbol dolaru ($) odpovídá konci řetězce, tj. kontroluje, zda řetězec končí daným znakem (znaky) nebo ne. Například-
- s$ zkontroluje řetězec, který končí na, jako jsou geeks, ends, s atd.
- ks$ zkontroluje řetězec, který končí na ks, jako jsou geeks, geeksforgeeks, ks atd.
Příklad:
Tento kód používá regulární výraz ke kontrole, zda řetězec končí na Svět!. Pokud je nalezena shoda, vytiskne se Shoda nalezena! jinak se vytiskne Shoda nenalezena .
Python3
import> re> > string> => 'Hello World!'> pattern> => r> 'World!$'> > match> => re.search(pattern, string)> if> match:> > print> (> 'Match found!'> )> else> :> > print> (> 'Match not found.'> )> |
>
java otevřený soubor
>Výstup
Match found!>
5. – Tečka
Symbol tečky (.) odpovídá pouze jednomu znaku kromě znaku nového řádku ( ). Například -
- a.b zkontroluje řetězec, který obsahuje jakýkoli znak na místě tečky, jako je acb, acbd, abbb atd.
- .. zkontroluje, zda řetězec obsahuje alespoň 2 znaky
Příklad:
Tento kód používá k vyhledání vzoru regulární výraz hnědá.liška uvnitř řetězce. tečka (.>
) ve vzoru představuje libovolný znak. Pokud je nalezena shoda, vytiskne se Shoda nalezena! jinak se vytiskne Shoda nenalezena .
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.'> )> |
>
>Výstup
Match found!>
6. | – Or
Nebo symbol funguje jako operátor nebo, což znamená, že kontroluje, zda je vzor před nebo za symbolem nebo v řetězci přítomen či nikoli. Například -
- a|b bude odpovídat jakémukoli řetězci, který obsahuje a nebo b, jako je acd, bcd, abcd atd.
7. ? - Otazník
Otazník (?) je kvantifikátor v regulárních výrazech, který označuje, že předchozí prvek by se měl shodovat nula nebo jednou. Umožňuje určit, že prvek je volitelný, což znamená, že se může vyskytnout jednou nebo vůbec. Například,
- ab?c bude odpovídat řetězci ac, acb, dabc, ale nebude přiřazeno abbc, protože existují dvě b. Podobně se nebude shodovat s abdc, protože za b nenásleduje c.
8.* – Hvězda
Symbol hvězdičky (*) odpovídá nule nebo více výskytům regulárního výrazu před symbolem *. Například -
- ab*c bude odpovídat řetězci ac, abc, abbbc, dabc atd., ale nebude přiřazeno abdc, protože za b nenásleduje c.
9. + – Plus
Symbol plus (+) odpovídá jednomu nebo více výskytům regulárního výrazu před symbolem +. Například -
- ab+c se bude shodovat pro řetězec abc, abbc, dabc, ale nebude se shodovat pro ac, abdc, protože v ac není b, a po b v abdc nenásleduje c.
10. {m, n} – Složené závorky
Složené závorky odpovídají všem opakováním předcházejícím regulárnímu výrazu od m do n včetně. Například -
- a{2, 4} bude odpovídat řetězci aaab, baaaac, gaad, ale nebude odpovídat řetězcům jako abc, bc, protože v obou případech existuje pouze jedno a nebo žádné a.
11. () – Skupina
Symbol skupiny se používá k seskupování dílčích vzorů. Například -
- (a|b)cd bude odpovídat řetězcům jako acd, abcd, gacd atd.
Speciální sekvence
Speciální sekvence se neshodují se skutečným znakem v řetězci, místo toho sdělují konkrétní místo ve vyhledávacím řetězci, kde musí nastat shoda. Usnadňuje psaní běžně používaných vzorů.
Seznam speciálních sekvencí
Speciální sekvence | Popis | Příklady | |
---|---|---|---|
A | Odpovídá, pokud řetězec začíná daným znakem | Aphor | pro geeky |
pro svět | |||
Shoduje se, zda slovo začíná nebo končí daným znakem. (řetězec) zkontroluje začátek slova a (řetězec) zkontroluje konec slova. | ge | geeky | |
dostat | |||
B | Je opakem , tj. řetězec by neměl začínat ani končit daným regulárním výrazem. | Bge | spolu |
kovárna | |||
d | Odpovídá libovolné desetinné číslici, toto je ekvivalentní nastavené třídě [0-9] | d | 123 |
bože 1 | |||
D | Odpovídá libovolnému nečíslicovému znaku, toto je ekvivalentní nastavené třídě [^0-9] | D | geekové |
geek1 | |||
s | Odpovídá libovolnému znaku mezery. | s | gee ks |
a bc | |||
S | Odpovídá libovolnému znaku, který není prázdný | S | a bd |
abeceda | |||
V | Odpovídá jakémukoli alfanumerickému znaku, toto je ekvivalentní třídě [a-zA-Z0-9_]. | V | 123 |
geeKs4 | |||
V | Shoduje se s jakýmkoli nealfanumerickým znakem. | V | > $ |
dát | |||
S | Odpovídá, pokud řetězec končí daným regulárním výrazem | ab | abcdab runas v powershell |
bababa |
Funkce RegEx
re modul obsahuje mnoho funkcí které nám pomáhají hledat v řetězci shodu.
Podívejme se na různé funkce poskytované tímto modulem pro práci s regulárním výrazem v Pythonu.
Funkce | Popis |
---|---|
re.findall() | vyhledá a vrátí všechny odpovídající výskyty v seznamu |
re.compile() | Regulární výrazy jsou kompilovány do vzorových objektů |
re.split() | Rozdělit řetězec podle výskytů znaku nebo vzoru. |
re.sub() | Nahradí všechny výskyty znaku nebo vzoru náhradním řetězcem. |
re.escape() | Uniká speciální postavě |
výzkum() | Hledá první výskyt znaku nebo vzoru |
Podívejme se na fungování těchto funkcí RegEx s definicí a příklady:
1. re.findall()
Vrátí všechny nepřekrývající se shody vzoru v řetězci jako seznam řetězců. Řetězec je skenován zleva doprava a shody jsou vráceny v nalezeném pořadí.
Nalezení všech výskytů vzoru
Tento kód používá regulární výraz ( d+>
) najít všechny sekvence jedné nebo více číslic v daném řetězci. Vyhledává číselné hodnoty a ukládá je do seznamu. V tomto příkladu vyhledá a vytiskne čísla 123456789 a 987654321 ze vstupního řetězce.
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)> |
>
>Výstup
['123456789', '987654321']>
2. re.compile()
Regulární výrazy jsou kompilovány do objektů vzorů, které mají metody pro různé operace, jako je vyhledávání shod se vzorem nebo provádění substitucí řetězců.
Příklad 1:
Kód používá vzor regulárního výrazu [a-e]>
najít a vypsat všechna malá písmena od „a“ do „e“ ve vstupním řetězci Ano, řekl pan Gibenson Stark. Výstup bude ['e', 'a', 'd', 'b', 'e']>
, což jsou odpovídající znaky.
Krajta
import> re> p> => re.> compile> (> '[a-e]'> )> > print> (p.findall(> 'Aye, said Mr. Gibenson Stark'> ))> |
>
>Výstup
['e', 'a', 'd', 'b', 'e', 'a']>
Pochopení výstupu:
- První výskyt je „e“ v Aye a ne „A“, protože se rozlišují malá a velká písmena.
- Další výskyt je „a“ v řečeném, potom „d“ v řečeném, následuje „b“ a „e“ v Gibensonu, poslední „a“ se shoduje se Starkem.
- Metaznakové zpětné lomítko „“ má velmi důležitou roli, protože signalizuje různé sekvence. Pokud má být zpětné lomítko použito bez zvláštního významu jako metaznak, použijte „“
Příklad 2: Nastavit třídu [s,.] bude odpovídat libovolnému znaku mezery „,“ nebo „.“.
Kód používá regulární výrazy k nalezení a výpisu všech jednotlivých číslic a posloupností číslic v daných vstupních řetězcích. Najde jednotlivé číslice s d>
a sekvence číslic s d+>
.
Krajta
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'> ))> |
>
>Výstup
['1', '1', '4', '1', '8', '8', '6'] ['11', '4', '1886']>
Příklad 3:
Kód používá regulární výrazy k nalezení a výpisu slovních znaků, sekvencí slovních znaků a neslovních znaků ve vstupních řetězcích. Poskytuje seznamy odpovídajících znaků nebo sekvencí.
Krajta
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.'> ))> |
>
>Výstup
['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'] [' ', ' ', '*', '*', '*', ' ...>
Příklad 4:
Kód používá vzor regulárního výrazu ‚ab*‘ k nalezení a vypsání všech výskytů ‚ab‘ následovaných nulou nebo více znaky ‚b‘ ve vstupním řetězci ababbaabbb. Vrátí následující seznam shod: [‘ab‘, ‚abb‘, ‚abbb‘].
Krajta
import> re> p> => re.> compile> (> 'ab*'> )> print> (p.findall(> 'ababbaabbb'> ))> |
>
myflixr
>Výstup
['ab', 'abb', 'a', 'abbb']>
Pochopení výstupu:
- Naše RE je ab*, což je ‚a‘ doprovázené libovolným ne. z „b“, počínaje 0.
- Výstup „ab“ je platný, protože jediné „a“ je doprovázeno jedním „b“.
- Výstup „abb“ je platný kvůli jedinému „a“ doprovázenému 2 „b“.
- Výstup „a“ je platný, protože jediné „a“ je doprovázeno 0 „b“.
- Výstup „abbb“ je platný kvůli jedinému „a“ doprovázenému 3 „b“.
3. re.split()
Rozdělit řetězec podle výskytů znaku nebo vzoru a po nalezení tohoto vzoru jsou zbývající znaky z řetězce vráceny jako součást výsledného seznamu.
Syntaxe:
re.split(pattern, string, maxsplit=0, flags=0)>
První parametr, vzor označuje regulární výraz, řetězec je daný řetězec, ve kterém bude vzor hledán a ve kterém dojde k rozdělení, maxsplit, pokud není zadán, je považován za nulu '0', a pokud je zadána jakákoli nenulová hodnota, pak nastane nanejvýš tolik rozkolů. Pokud maxsplit = 1, pak se řetězec rozdělí pouze jednou, výsledkem je seznam délky 2. Příznaky jsou velmi užitečné a mohou pomoci zkrátit kód, nejsou to nutné parametry, např.: flags = re.IGNORECASE, v tomto rozdělení , malá nebo velká písmena budou ignorována.
Příklad 1:
Rozdělí řetězec pomocí neslovních znaků a mezer jako oddělovačů a vrátí slova: ['Words', 'words', 'Words']>
. Považuje apostrofy za neslovní znaky: ['Word', 's', 'words', 'Words']>
. Rozdělení pomocí jiných než slovních znaků a číslic: ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']>
. Rozdělení pomocí číslic jako oddělovače: ['On ', 'th Jan ', ', at ', ':', ' AM']>
.
Krajta
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'> ))> |
>
>Výstup
['Words', 'words', 'Words'] ['Word', 's', 'words', 'Words'] ['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM'] ['On ', 'th Jan ', ', at ', ':', ' AM']>
Příklad 2:
První příkaz rozdělí řetězec při prvním výskytu jedné nebo více číslic: ['On ', 'th Jan 2016, at 11:02 AM']>
. second rozděluje řetězec pomocí malých písmen a až f jako oddělovačů, bez ohledu na velikost písmen: ['', 'y, ', 'oy oh ', 'oy, ', 'ome here'>
]>
. Třetí rozděluje řetězec pomocí malých písmen a až f jako oddělovačů, přičemž se rozlišují velká a malá písmena: ['', 'ey, Boy oh ', 'oy, ', 'ome here']>
.
Krajta
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'> ))> |
>
>Výstup
['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()
'sub' ve funkci znamená SubString, určitý vzor regulárního výrazu je prohledán v daném řetězci (3. parametr) a po nalezení vzoru podřetězce je nahrazen repl (2. parametr), počet zkontroluje a zachová, kolikrát k tomu dochází.
Syntax:
re.sub(pattern, repl, string, count=0, flags=0)>
Příklad 1:
- První příkaz nahradí všechny výskyty „ub“ za „~*“ (nerozlišují se malá a velká písmena):
'S~*ject has ~*er booked already'>
. - Druhý příkaz nahrazuje všechny výskyty „ub“ za „~*“ (rozlišují se malá a velká písmena):
'S~*ject has Uber booked already'>
. - Třetí příkaz nahrazuje první výskyt „ub“ za „~*“ (nerozlišují se malá a velká písmena):
'S~*ject has Uber booked already'>
. - Čtvrtý nahrazuje „AND“ za „&“ (nerozlišují se malá a velká písmena):
'Baked Beans & Spam'>
.
Krajta
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))> |
>
>Výstup
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() je podobný sub() ve všech ohledech, kromě způsobu poskytování výstupu. Vrací n-tici s celkovým počtem nahrazení a nového řetězce, nikoli pouze řetězec.
Syntax:
re.subn(pattern, repl, string, count=0, flags=0)>
Příklad:
re.subn()>
nahradí všechny výskyty vzoru v řetězci a vrátí n-tici s upraveným řetězcem a počtem provedených náhrad. Je to užitečné pro substituce rozlišující malá a velká písmena.
Krajta
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> ])> |
>
>Výstup
teorie stromů a grafů
('S~*ject has Uber booked already', 1) ('S~*ject has ~*er booked already', 2) 2 S~*ject has ~*er booked already>
6. re.escape()
Vrací řetězec se všemi nealfanumerickými zpětnými lomítky, což je užitečné, pokud chcete porovnat libovolný doslovný řetězec, který může obsahovat metaznaky regulárního výrazu.
Syntax:
re.escape(string)>
Příklad:
re.escape()>
se používá k escapování speciálních znaků v řetězci, takže jej lze bezpečně použít jako vzor v regulárních výrazech. Zajišťuje, že všechny znaky se speciálním významem v regulárních výrazech budou považovány za doslovné znaky.
Krajta
import> re> print> (re.escape(> 'This is Awesome even 1 AM'> ))> print> (re.escape(> 'I Asked what is this [a-9], he said ^WoW'> ))> |
>
>Výstup
This is Awesome even 1 AM I Asked what is this [a-9], he said ^WoW>
7. re.search()
Tato metoda buď vrátí None (pokud se vzor neshoduje), nebo re.MatchObject obsahuje informace o odpovídající části řetězce. Tato metoda se zastaví po první shodě, takže je nejvhodnější pro testování regulárního výrazu více než pro extrakci dat.
Příklad: Hledání výskytu vzoru
Tento kód používá regulární výraz k vyhledání vzoru v daném řetězci. Pokud je nalezena shoda, extrahuje a vytiskne odpovídající části řetězce.
V tomto konkrétním příkladu hledá vzor, který se skládá z měsíce (písmena) následovaného dnem (číslicemi) ve vstupním řetězci Narodil jsem se 24. června. Pokud je nalezena shoda, vytiskne úplnou shodu, měsíc a den.
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.'> )> |
>
>Výstup
Match at index 14, 21 Full match: June 24 Month: June Day: 24>
SOUPRAVY
A Soubor je sada znaků uzavřených v závorkách „[]“. Sady se používají ke shodě jednoho znaku v sadě znaků specifikovaných v závorkách. Níže je seznam sad:
Soubor | Popis |
---|---|
{n,} | Kvantifikuje předchozí znak nebo skupinu a odpovídá alespoň n výskytům. |
* | Kvantifikuje předchozí znak nebo skupinu a odpovídá žádnému nebo více výskytům. |
[0123] | Odpovídá zadaným číslicím (0, 1, 2 nebo 3) |
[^arn] | odpovídá libovolnému znaku KROMĚ a, r a n |
d | Odpovídá libovolné číslici (0-9). |
[0-5][0-9] | shoduje se s libovolnými dvoucifernými čísly od 00 do 59 |
V | Odpovídá jakémukoli alfanumerickému znaku (a-z, A-Z, 0-9 nebo _). |
[a-n] | Shoduje se s jakoukoli malou abecedou mezi a a n. |
D | Odpovídá libovolnému nečíslicovému znaku. |
[arn] | odpovídá, kde je přítomen jeden ze zadaných znaků (a, r nebo n). |
[a-zA-Z] | odpovídá libovolnému znaku mezi a a z, malým písmenem NEBO velkým písmenem |
[0-9] | odpovídá libovolné číslici mezi 0 a 9 |
Shoda objektu
Objekt Match obsahuje všechny informace o hledání a výsledku a pokud není nalezena žádná shoda, bude vrácena žádná. Podívejme se na některé z běžně používaných metod a atributů objektu shody.
1. Získání řetězce a regulárního výrazu
match.re atribut vrací regulární výraz předaný a zápas.provázek atribut vrací předaný řetězec.
Příklad: Získání řetězce a regulárního výrazu shodného objektu
Kód hledá písmeno G na hranici slova v řetězci Vítejte v GeeksForGeeks a vytiskne vzor regulárního výrazu ( res.re>
) a původní řetězec ( res.string>
) .
Python3
import> re> s> => 'Welcome to GeeksForGeeks'> res> => re.search(r> 'G'> , s)> > print> (res.re)> print> (res.string)> |
>
>Výstup
re.compile('G') Welcome to GeeksForGeeks>
2. Získání indexu shodného objektu
- metoda start() vrací počáteční index shodného podřetězce
- metoda end() vrací koncový index shodného podřetězce
- Metoda span() vrací n-tici obsahující počáteční a koncový index shodného podřetězce
Příklad: Získání indexu shodného objektu
Kód hledá podřetězec Gee na hranici slova v řetězci Welcome to GeeksForGeeks a vytiskne počáteční index shody (res.start()>
), index konce shody (res.end()>
), a rozpětí zápasu (res.span()>
).
Python3
import> re> > s> => 'Welcome to GeeksForGeeks'> > res> => re.search(r> 'Gee'> , s)> > print> (res.start())> print> (res.end())> print> (res.span())> |
>
>Výstup
11 14 (11, 14)>
3. Získání spárovaného podřetězce
metoda group() vrací část řetězce, pro kterou se vzory shodují. Pro lepší pochopení se podívejte na níže uvedený příklad.
Příklad: Získávání shody podřetězce
Kód hledá sekvenci dvou nečíslicových znaků následovaných mezerou a písmenem „t“ v řetězci Welcome to GeeksForGeeks a vytiskne odpovídající text pomocí res.group()>
.
Python3
import> re> s> => 'Welcome to GeeksForGeeks'> res> => re.search(r> 'D{2} t'> , s)> print> (res.group())> |
>
>Výstup
me t>
Ve výše uvedeném příkladu náš vzor určuje řetězec, který obsahuje alespoň 2 znaky, za kterými následuje mezera, a za mezerou následuje t.
Související článek:
Odkaz:
https://docs.python.org/2/library/re.html
Probrali jsme RegEx v Pythonu, prošli jsme metaznaky, funkce a speciální sekvence v RegEx Pythonu.
Regulární výraz je v Pythonu velmi důležitý pojem, pokusili jsme se jej vysvětlit jednoduchým způsobem. Doufám, že vám to pomůže při vaší cestě Python!!