Upang magsagawa ng regular na pagpoproseso ng expression sa Python, ginagamit namin ang re module mula sa karaniwang library. Binibigyang-daan ka nitong i-extract, palitan, at hatiin ang mga string gamit ang mga pattern ng regular na expression.
- re — Regular expression operations — Python 3.10.0 Documentation
- Regular Expression HOWTO — Python 3.10.0 Documentation
Sa seksyong ito, ipapaliwanag muna natin ang mga function at pamamaraan ng muling module.
- Pag-compile ng mga pattern ng regular na expression:
compile() - bagay na tugma
- Suriin kung ang simula ng string ay tumutugma, i-extract ang:
match() - Suriin ang mga tugma na hindi limitado sa simula:
search() - Tingnan kung tumutugma ang buong string:
fullmatch() - Kumuha ng listahan ng lahat ng tumutugmang bahagi:
findall() - Kunin ang lahat ng tumutugmang bahagi bilang isang iterator:
finditer() - Palitan ang katugmang bahagi:
sub(),subn() - Paghahati ng mga string na may mga pattern ng regular na expression:
split()
Pagkatapos nito, ipapaliwanag ko ang mga meta character (mga espesyal na karakter) at mga espesyal na pagkakasunud-sunod ng mga regular na expression na maaaring magamit sa muling module. Karaniwan, ito ang karaniwang syntax ng regular na expression, ngunit mag-ingat sa pagtatakda ng mga flag (lalo na ang re.ASCII).
- Mga metacharacter ng regular na expression, mga espesyal na sequence, at mga caveat sa Python
- Pagtatakda ng bandila
- Limitado sa mga ASCII na character:
re.ASCII - Hindi case-sensitive:
re.IGNORECASE - Itugma ang simula at dulo ng bawat linya:
re.MULTILINE - Tukuyin ang maramihang mga flag
- Limitado sa mga ASCII na character:
- Mga tugmang sakim at hindi sakim
- I-compile ang pattern ng regular na expression: compile()
- bagay na tugma
- Suriin kung ang simula ng isang string ay tumutugma, extract: match()
- Suriin ang mga tugma na hindi limitado sa simula, extract: search()
- Suriin kung tumutugma ang buong string: fullmatch()
- Kumuha ng listahan ng lahat ng tumutugmang bahagi: findall()
- Kunin ang lahat ng tumutugmang bahagi bilang isang iterator: finditer()
- Palitan ang mga katugmang bahagi: sub(), subn()
- Paghahati ng mga string na may mga regular na pattern ng expression: split()
- Mga metacharacter ng regular na expression, mga espesyal na sequence, at mga caveat sa Python
- Pagtatakda ng bandila
- Mga tugmang sakim at hindi sakim
I-compile ang pattern ng regular na expression: compile()
Mayroong dalawang paraan upang magsagawa ng regular na pagpoproseso ng expression sa muling module.
Patakbuhin nang may function
Ang una ay isang function.re.match(),re.sub()Available ang mga function na tulad nito upang magsagawa ng pagkuha, pagpapalit, at iba pang mga proseso gamit ang mga pattern ng regular na expression.
Ang mga detalye ng mga function ay ilalarawan sa ibang pagkakataon, ngunit sa lahat ng mga ito, ang unang argumento ay ang string ng pattern ng regular na expression, na sinusundan ng string na ipoproseso at iba pa. Halimbawa, sa re.sub(), na nagsasagawa ng pagpapalit, ang pangalawang argumento ay ang substitution string, at ang ikatlong argumento ay ang string na ipoproseso.
import re
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
m = re.match(r'([a-z]+)@([a-z]+)\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
result = re.sub(r'([a-z]+)@([a-z]+)\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net
Tandaan na ang [a-z] sa pattern ng regular na expression sa halimbawang ito ay nangangahulugang anumang character mula a hanggang z (i.e. lowercase na alpabeto), at + ay nangangahulugang ulitin ang nakaraang pattern (sa kasong ito [a-z]) nang isa o higit pang beses. Ang [a-z]+ ay tumutugma sa anumang string na umuulit ng isa o higit pang maliliit na alphabetic na character.
. ay isang meta character (isang character na may espesyal na kahulugan) at dapat na takasan gamit ang backslash.
Dahil ang mga regular na expression pattern string ay kadalasang gumagamit ng maraming backslashes, ito ay maginhawang gumamit ng mga hilaw na string tulad ng sa halimbawa.
Tumatakbo sa isang paraan ng isang regular na expression pattern object
Ang pangalawang paraan upang iproseso ang mga regular na expression sa re module ay ang regular na expression pattern object method.
Gamit ang re.compile(), maaari kang mag-compile ng isang regular na expression pattern string upang lumikha ng isang regular na expression pattern object.
p = re.compile(r'([a-z]+)@([a-z]+)\.com')
print(p)
# re.compile('([a-z]+)@([a-z]+)\\.com')
print(type(p))
# <class 're.Pattern'>
re.match(),re.sub()Halimbawa, ang parehong proseso tulad ng mga function na ito ay maaaring isagawa bilang mga pamamaraan na tumutugma (), sub() ng mga regular na expression object.
m = p.match(s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
result = p.sub('new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net
Ang lahat ng re.xxx() function na inilarawan sa ibaba ay ibinibigay din bilang mga pamamaraan ng object ng regular na expression.
Kung inuulit mo ang isang proseso na gumagamit ng parehong pattern, mas mahusay na bumuo ng isang regular na expression object na may re.compile() at gamitin ito sa paligid.
Sa sumusunod na sample code, ang function ay ginagamit nang walang pag-compile para sa kaginhawahan, ngunit kung gusto mong gamitin ang parehong pattern nang paulit-ulit, inirerekomenda na i-compile ito nang maaga at isagawa ito bilang isang paraan ng isang regular na expression object.
bagay na tugma
match(), search(), atbp. magbalik ng match object.
s = 'aaa@xxx.com'
m = re.match(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
print(type(m))
# <class 're.Match'>
Ang katugmang string at posisyon ay nakuha gamit ang mga sumusunod na pamamaraan ng bagay na tugma.
- Kunin ang lokasyon ng laban:
start(),end(),span() - Kunin ang katugmang string:
group() - Kunin ang string para sa bawat pangkat:
groups()
print(m.start())
# 0
print(m.end())
# 11
print(m.span())
# (0, 11)
print(m.group())
# aaa@xxx.com
Kung isasama mo ang isang bahagi ng isang regular na pattern ng expression sa isang string na may mga panaklong(), ang bahagi ay ipoproseso bilang isang pangkat. Sa kasong ito, ang string ng bahagi na tumutugma sa bawat pangkat sa mga pangkat () ay maaaring makuha bilang isang tuple.
m = re.match(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
print(m.groups())
# ('aaa', 'xxx', 'com')
Suriin kung ang simula ng isang string ay tumutugma, extract: match()
match() ay nagbabalik ng match object kung ang simula ng string ay tumutugma sa pattern.
Gaya ng nabanggit sa itaas, maaaring gamitin ang match object para kunin ang katugmang substring, o para lang tingnan kung may ginawang tugma.
match() ay susuriin lamang ang simula. Kung walang tumutugmang string sa simula, ibabalik nito ang Wala.
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
m = re.match(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
m = re.match(r'[a-z]+@[a-z]+\.net', s)
print(m)
# None
Suriin ang mga tugma na hindi limitado sa simula, extract: search()
Tulad ng match(), ito ay nagbabalik ng isang bagay na tugma kung ito ay tumutugma.
Kung maraming magkakatugmang bahagi, ang unang tumutugmang bahagi lamang ang ibabalik.
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
m = re.search(r'[a-z]+@[a-z]+\.net', s)
print(m)
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>
m = re.search(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
Kung gusto mong makuha ang lahat ng tumutugmang bahagi, gamitin ang findall() o finditer() gaya ng inilarawan sa ibaba.
Suriin kung tumutugma ang buong string: fullmatch()
Upang tingnan kung tumutugma ang buong string sa pattern ng regular na expression, gumamit ng fullmatch(). Ito ay kapaki-pakinabang, halimbawa, upang suriin kung ang isang string ay wasto bilang isang email address o hindi.
Kung tumugma ang buong string, ibabalik ang isang bagay na tugma.
s = 'aaa@xxx.com'
m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
Kung may mga hindi tugmang bahagi (mga bahagyang tugma lamang o walang tugma sa lahat), Wala ang ibinalik.
s = '!!!aaa@xxx.com!!!'
m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# None
Ang fullmatch() ay idinagdag sa Python 3.4. Kung gusto mong gawin ang parehong sa mga naunang bersyon, gumamit ng match() at isang katugmang meta character na $ sa dulo. Kung ang buong string mula simula hanggang katapusan ay hindi tumugma, ibabalik nito ang Wala.
s = '!!!aaa@xxx.com!!!'
m = re.match(r'[a-z]+@[a-z]+\.com$', s)
print(m)
# None
Kumuha ng listahan ng lahat ng tumutugmang bahagi: findall()
Ang findall() ay nagbabalik ng isang listahan ng lahat ng tumutugmang mga substring. Tandaan na ang mga elemento ng listahan ay hindi mga bagay na tumutugma ngunit mga string.
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
result = re.findall(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# ['aaa@xxx.com', 'bbb@yyy.com', 'ccc@zzz.net']
Maaaring suriin ang bilang ng mga katugmang bahagi gamit ang built-in na function na len(), na nagbabalik ng bilang ng mga elemento sa listahan.
print(len(result))
# 3
Ang pagpapangkat na may mga panaklong() sa isang regular na pattern ng expression ay nagbabalik ng isang listahan ng mga tuple na ang mga elemento ay ang mga string ng bawat pangkat. Katumbas ito ng mga grupo() sa bagay na tugma.
result = re.findall(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(result)
# [('aaa', 'xxx', 'com'), ('bbb', 'yyy', 'com'), ('ccc', 'zzz', 'net')]
Ang pangkat na panaklong () ay maaaring ma-nest, kaya kung gusto mo ring makuha ang buong tugma, ilagay lamang ang buong tugma sa panaklong ().
result = re.findall(r'(([a-z]+)@([a-z]+)\.([a-z]+))', s)
print(result)
# [('aaa@xxx.com', 'aaa', 'xxx', 'com'), ('bbb@yyy.com', 'bbb', 'yyy', 'com'), ('ccc@zzz.net', 'ccc', 'zzz', 'net')]
Kung walang nakitang tugma, ibabalik ang isang walang laman na tuple.
result = re.findall('[0-9]+', s)
print(result)
# []
Kunin ang lahat ng tumutugmang bahagi bilang isang iterator: finditer()
Ibinabalik ng finditer() ang lahat ng tumutugmang bahagi bilang isang iterator. Ang mga elemento ay hindi mga string tulad ng findall(), ngunit tumutugma sa mga bagay, upang makuha mo ang posisyon (index) ng mga katugmang bahagi.
Ang iterator mismo ay hindi maaaring i-print out gamit ang print() upang makuha ang mga nilalaman nito. Kung gagamitin mo ang built-in na function next() o ang for statement, maaari mong makuha ang mga nilalaman nang paisa-isa.
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# <callable_iterator object at 0x10b0efa90>
print(type(result))
# <class 'callable_iterator'>
for m in result:
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>
Maaari rin itong i-convert sa isang listahan na may list().
l = list(re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s))
print(l)
# [<re.Match object; span=(0, 11), match='aaa@xxx.com'>, <re.Match object; span=(13, 24), match='bbb@yyy.com'>, <re.Match object; span=(26, 37), match='ccc@zzz.net'>]
print(l[0])
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
print(type(l[0]))
# <class 're.Match'>
print(l[0].span())
# (0, 11)
Kung gusto mong makuha ang posisyon ng lahat ng tumutugmang bahagi, ang notasyon sa pag-unawa sa listahan ay mas maginhawa kaysa sa list().
print([m.span() for m in re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)])
# [(0, 11), (13, 24), (26, 37)]
Ang iterator ay naglalabas ng mga elemento sa pagkakasunud-sunod. Tandaan na kung susubukan mong kumuha ng higit pang mga elemento pagkatapos maabot ang dulo, wala kang maiiwan.
result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)
for m in result:
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>
print(list(result))
# []
Palitan ang mga katugmang bahagi: sub(), subn()
Gamit ang sub(), maaari mong palitan ang katugmang bahagi ng isa pang string. Ibabalik ang ipinalit na string.
s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'
result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net
print(type(result))
# <class 'str'>
Kapag nagpapangkat sa mga panaklong(), ang katugmang string ay maaaring gamitin sa pinalitan na string.
Bilang default, sinusuportahan ang sumusunod: Tandaan na para sa mga normal na string na hindi raw string, dapat na nakalista ang backslash bago ang backslash upang makatakas sa backslash.
\1 | Ang unang panaklong |
\2 | Ang pangalawang panaklong |
\3 | Ang ikatlong panaklong |
result = re.sub(r'([a-z]+)@([a-z]+)\.com', r'\1@\2.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net
?P<xxx>
Kung pangalanan mo ang pangkat sa pamamagitan ng pagsulat nito sa simula ng mga panaklong pattern ng regular na expression, maaari mo itong tukuyin gamit ang pangalan sa halip na numero, tulad ng ipinapakita sa ibaba.\g<xxx>
result = re.sub(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net
Tinutukoy ng bilang ng argumento ang maximum na bilang ng mga kapalit. Ang bilang lamang mula sa kaliwang bahagi ang papalitan.
result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# new-address, bbb@yyy.com, ccc@zzz.net
subn() ay nagbabalik ng isang tuple ng pinalit na string (katulad ng return value ng sub()) at ang bilang ng mga substituted na bahagi (ang numerong tumugma sa pattern).
result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# ('new-address, new-address, ccc@zzz.net', 2)
Ang paraan ng pagtukoy ng mga argumento ay kapareho ng sub(). Maaari mong gamitin ang bahaging nakapangkat sa pamamagitan ng panaklong, o tukuyin ang bilang ng argumento.
result = re.subn(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# ('aaa@xxx.net, bbb@yyy.net, ccc@zzz.net', 2)
result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# ('new-address, bbb@yyy.com, ccc@zzz.net', 1)
Paghahati ng mga string na may mga regular na pattern ng expression: split()
split() hinahati ang string sa bahaging tumutugma sa pattern, at ibinabalik ito bilang isang listahan.
Tandaan na ang una at huling mga tugma ay maglalaman ng mga walang laman na string sa simula at dulo ng magreresultang listahan.
s = '111aaa222bbb333'
result = re.split('[a-z]+', s)
print(result)
# ['111', '222', '333']
result = re.split('[0-9]+', s)
print(result)
# ['', 'aaa', 'bbb', '']
Tinutukoy ng maxsplit argument ang maximum na bilang ng mga split (piraso). Ang bilang lamang mula sa kaliwang bahagi ang mahahati.
result = re.split('[a-z]+', s, 1)
print(result)
# ['111', '222bbb333']
Mga metacharacter ng regular na expression, mga espesyal na sequence, at mga caveat sa Python
Ang pangunahing regular na expression meta character (mga espesyal na character) at mga espesyal na pagkakasunud-sunod na maaaring magamit sa Python 3 re module ay ang mga sumusunod
| metacharacter | nilalaman |
|---|---|
. | Anumang solong karakter maliban sa isang bagong linya (kabilang ang isang bagong linya na may bandila ng DOTALL) |
^ | Ang simula ng string (tumutugma din sa simula ng bawat linya sa MULTILINE flag) |
$ | Ang dulo ng string (tumutugma din sa dulo ng bawat linya sa MULTILINE flag) |
* | Ulitin ang nakaraang pattern nang higit sa 0 beses |
+ | Ulitin ang nakaraang pattern nang hindi bababa sa isang beses. |
? | Ulitin ang nakaraang pattern 0 o 1 beses |
{m} | Ulitin ang nakaraang pattern m beses |
{m, n} | Ang huling pattern.m~nulitin |
[] | Isang set ng mga character[]Tumutugma sa alinman sa mga character na ito |
| | OA|BTumutugma sa pattern ng A o B |
| espesyal na pagkakasunod-sunod | nilalaman |
|---|---|
\d | Unicode decimal number (limitado sa ASCII na numero ng ASCII flag) |
\D | \dIbig sabihin ay kabaligtaran nito. |
\s | Unicode whitespace character (limitado sa ASCII whitespace character sa pamamagitan ng ASCII flag) |
\S | \sIbig sabihin ay kabaligtaran nito. |
\w | Unicode word character at underscore (limitado sa ASCII alphanumeric character at underscore ng ASCII flag) |
\W | \wIbig sabihin ay kabaligtaran nito. |
Hindi lahat ng mga ito ay nakalista sa talahanayang ito. Tingnan ang opisyal na dokumentasyon para sa kumpletong listahan.
Tandaan din na ang ilan sa mga kahulugan ay iba sa Python 2.
Pagtatakda ng bandila
Gaya ng ipinapakita sa talahanayan sa itaas, binabago ng ilang meta character at mga espesyal na sequence ang kanilang mode depende sa flag.
Tanging ang mga pangunahing watawat lamang ang sakop dito. Tingnan ang opisyal na dokumentasyon para sa iba pa.
Limitado sa mga ASCII na character: re.ASCII
\wTutugma din ito sa double-byte na kanji, alphanumeric na character, atbp. bilang default para sa Python 3 string. Hindi ito katumbas ng mga sumusunod dahil hindi ito isang karaniwang regular na expression.[a-zA-Z0-9_]
m = re.match(r'\w+', '漢字ＡＢＣ１２３')
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>
m = re.match('[a-zA-Z0-9_]+', '漢字ＡＢＣ１２３')
print(m)
# None
Kung tinukoy mo ang re.ASCII para sa mga flag ng argumento sa bawat function, o idagdag ang sumusunod na inline na flag sa simula ng string ng pattern ng regular na expression, tutugma lang ito sa mga ASCII na character (hindi ito tutugma sa double-byte na Japanese, alphanumeric na character, atbp. .).(?a)
Sa kasong ito, ang sumusunod na dalawa ay katumbas.\w#ERROR![a-zA-Z0-9_]
m = re.match(r'\w+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# None
m = re.match(r'(?a)\w+', '漢字ＡＢＣ１２３')
print(m)
# None
Ang parehong naaangkop kapag nag-compile sa re.compile(). Gamitin ang argumentong flag o inline na flag.
p = re.compile(r'\w+', flags=re.ASCII)
print(p)
# re.compile('\\w+', re.ASCII)
print(p.match('漢字ＡＢＣ１２３'))
# None
p = re.compile(r'(?a)\w+')
print(p)
# re.compile('(?a)\\w+', re.ASCII)
print(p.match('漢字ＡＢＣ１２３'))
# None
Available din ang ASCII bilang short form re. A. Maaari mong gamitin ang alinman.
print(re.ASCII is re.A)
# True
Ang \W, ang kabaligtaran ng \W, ay apektado rin ng re.ASCII at mga inline na flag.
m = re.match(r'\W+', '漢字ＡＢＣ１２３')
print(m)
# None
m = re.match(r'\W+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>
Tulad ng sa \w, ang sumusunod na dalawa ay tumutugma sa parehong single-byte at double-byte na character bilang default, ngunit limitado sa mga single-byte na character kung re.ASCII o inline na mga flag ay tinukoy.
- Itugma ang mga numero
\d - Tumutugma sa isang blangkong espasyo
\s - Tumutugma sa mga hindi numero
\D - Tumutugma sa anumang hindi espasyo.
\S
m = re.match(r'\d+', '123')
print(m)
# <re.Match object; span=(0, 3), match='123'>
m = re.match(r'\d+', '１２３')
print(m)
# <re.Match object; span=(0, 3), match='１２３'>
m = re.match(r'\d+', '123', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 3), match='123'>
m = re.match(r'\d+', '１２３', flags=re.ASCII)
print(m)
# None
m = re.match(r'\s+', ' ') # full-width space
print(m)
# <re.Match object; span=(0, 1), match='\u3000'>
m = re.match(r'\s+', ' ', flags=re.ASCII)
print(m)
# None
Hindi case-sensitive:re.IGNORECASE
Bilang default, ito ay case-sensitive. Upang itugma ang pareho, kailangan mong isama ang parehong malalaking titik at maliliit na titik sa pattern.
re.IGNORECASEKung ito ay tinukoy, ito ay tutugma sa case-insensitively. Katumbas ng i flag sa karaniwang mga regular na expression.
m = re.match('[a-zA-Z]+', 'abcABC')
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>
m = re.match('[a-z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>
m = re.match('[A-Z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>
Maaari mong gamitin ang mas mababa sa o katumbas ng.
- inline na bandila
(?i) - pagdadaglat
re.I
Itugma ang simula at dulo ng bawat linya:re.MULTILINE
^Ang mga meta character sa regular na expression na ito ay tumutugma sa simula ng string.
Bilang default, ang simula lamang ng buong string ang tumutugma, ngunit ang mga sumusunod ay tutugma din sa simula ng bawat linya. Katumbas ng m flag sa karaniwang mga regular na expression.re.MULTILINE
s = '''aaa-xxx
bbb-yyy
ccc-zzz'''
print(s)
# aaa-xxx
# bbb-yyy
# ccc-zzz
result = re.findall('[a-z]+', s)
print(result)
# ['aaa', 'xxx', 'bbb', 'yyy', 'ccc', 'zzz']
result = re.findall('^[a-z]+', s)
print(result)
# ['aaa']
result = re.findall('^[a-z]+', s, flags=re.MULTILINE)
print(result)
# ['aaa', 'bbb', 'ccc']
$Tumutugma sa dulo ng string. Bilang default, ang dulo lamang ng buong string ang tumutugma.re.MULTILINEKung tutukuyin mo ito, tutugma din ito sa dulo ng bawat linya.
result = re.findall('[a-z]+$', s)
print(result)
# ['zzz']
result = re.findall('[a-z]+$', s, flags=re.MULTILINE)
print(result)
# ['xxx', 'yyy', 'zzz']
Maaari mong gamitin ang mas mababa sa o katumbas ng.
- inline na bandila
(?m) - pagdadaglat
re.M
Tukuyin ang maramihang mga flag
|Kung gusto mong paganahin ang maramihang mga flag sa parehong oras, gamitin ito. Sa kaso ng mga inline na flag, ang bawat karakter ay dapat na sundan ng isang titik tulad ng ipinapakita sa ibaba.(?am)
s = '''aaa-xxx
漢漢漢-字字字
bbb-zzz'''
print(s)
# aaa-xxx
# 漢漢漢-字字字
# bbb-zzz
result = re.findall(r'^\w+', s, flags=re.M)
print(result)
# ['aaa', '漢漢漢', 'bbb']
result = re.findall(r'^\w+', s, flags=re.M | re.A)
print(result)
# ['aaa', 'bbb']
result = re.findall(r'(?am)^\w+', s)
print(result)
# ['aaa', 'bbb']
Mga tugmang sakim at hindi sakim
Ito ay isang pangkalahatang problema sa mga regular na expression, hindi lamang isang problema sa Python, ngunit isusulat ko ang tungkol dito dahil ito ay may posibilidad na malagay ako sa problema.
Bilang default, ang sumusunod ay isang matakaw na tugma, na tumutugma sa pinakamahabang posibleng string.
*+?
s = 'aaa@xxx.com, bbb@yyy.com'
m = re.match(r'.+com', s)
print(m)
# <re.Match object; span=(0, 24), match='aaa@xxx.com, bbb@yyy.com'>
print(m.group())
# aaa@xxx.com, bbb@yyy.com
Ang ? pagkatapos nito ay magreresulta sa isang hindi matakaw, minimal na tugma, na tumutugma sa pinakamaikling posibleng string.
*?+???
m = re.match(r'.+?com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
print(m.group())
# aaa@xxx.com
Tandaan na ang default na greedy na tugma ay maaaring tumugma sa mga hindi inaasahang string.