Python සාමාන්‍ය ප්‍රකාශන මොඩියුලය නැවත භාවිතා කරන්නේ කෙසේද (ගැලපීම, සෙවීම, උප, ආදිය)

ව්යාපාරික

Python හි නිත්‍ය ප්‍රකාශන සැකසුම් සිදු කිරීම සඳහා, අපි සම්මත පුස්තකාලයෙන් නැවත මොඩියුලය භාවිතා කරමු. එය ඔබට නිත්‍ය ප්‍රකාශන රටා භාවිතයෙන් නූල් උපුටා ගැනීමට, ප්‍රතිස්ථාපනය කිරීමට සහ බෙදීමට ඉඩ සලසයි.

මෙම කොටසේදී, අපි මුලින්ම re module හි කාර්යයන් සහ ක්‍රම විස්තර කරමු.

  • නිත්‍ය ප්‍රකාශන රටා සම්පාදනය කිරීම:compile()
  • ගැලපෙන වස්තුව
  • තන්තුවේ ආරම්භය ගැලපෙන්නේ දැයි පරීක්ෂා කරන්න, උපුටා ගන්න:match()
  • ආරම්භයට සීමා නොවී තරඟ සඳහා පරීක්ෂා කරන්න:search()
  • සම්පූර්ණ තන්තුව ගැලපේදැයි පරීක්ෂා කරන්න:fullmatch()
  • ගැලපෙන සියලුම කොටස් ලැයිස්තුවක් ලබා ගන්න:findall()
  • සියලුම ගැලපෙන කොටස් පුනරාවර්තකයක් ලෙස ලබා ගන්න:finditer()
  • ගැලපෙන කොටස ප්රතිස්ථාපනය කරන්න:sub(),subn()
  • නිත්‍ය ප්‍රකාශන රටා සහිත නූල් බෙදීම:split()

ඉන්පසුව, නැවත මොඩියුලයේ භාවිතා කළ හැකි මෙටා අක්ෂර (විශේෂ අක්ෂර) සහ සාමාන්‍ය ප්‍රකාශනවල විශේෂ අනුපිළිවෙල මම පැහැදිලි කරමි. මූලික වශයෙන්, එය සම්මත නිත්‍ය ප්‍රකාශන වාක්‍ය ඛණ්ඩය වේ, නමුත් කොඩි සැකසීමේදී ප්‍රවේශම් වන්න (විශේෂයෙන් re.ASCII).

  • Python හි නිත්‍ය ප්‍රකාශන metacharacters, විශේෂ අනුක්‍රම සහ අනතුරු ඇඟවීම්
  • ධජය සැකසීම
    • ASCII අක්ෂරවලට සීමා වේ:re.ASCII
    • සිද්ධි සංවේදී නොවේ:re.IGNORECASE
    • එක් එක් පේළියේ ආරම්භය සහ අවසානය ගලපන්න:re.MULTILINE
    • කොඩි කිහිපයක් සඳහන් කරන්න
  • ලෝභ සහ ලෝභ නැති ගැළපීම්

නිත්‍ය ප්‍රකාශන රටාව සම්පාදනය කරන්න: compile()

නැවත මොඩියුලය තුළ නිත්‍ය ප්‍රකාශන සැකසුම් සිදු කිරීමට ක්‍රම දෙකක් තිබේ.

කාර්යය සමඟ ධාවනය කරන්න

පළමුවැන්න ශ්‍රිතයකි.re.match(),re.sub()නිත්‍ය ප්‍රකාශන රටා භාවිතයෙන් නිස්සාරණය, ප්‍රතිස්ථාපනය සහ අනෙකුත් ක්‍රියාවලීන් සිදු කිරීමට මෙවැනි කාර්යයන් තිබේ.

ශ්‍රිතයන් පිළිබඳ විස්තර පසුව විස්තර කෙරෙනු ඇත, නමුත් ඒ සියල්ලෙහිම, පළමු තර්කය වන්නේ නිත්‍ය ප්‍රකාශන රටාවේ තන්තුවයි, පසුව සැකසීමට අවශ්‍ය නූල් සහ යනාදියයි. උදාහරණයක් ලෙස, ආදේශනය සිදු කරන re.sub() හි, දෙවන තර්කය ආදේශන තන්තුව වන අතර තුන්වන තර්කය සැකසිය යුතු තන්තුව වේ.

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

මෙම උදාහරණයේ සාමාන්‍ය ප්‍රකාශන රටාවේ [a-z] යන්නෙන් අදහස් වන්නේ a සිට z දක්වා (එනම් කුඩා අකුරු හෝඩිය) සහ + යනු පෙර රටාව (මෙම අවස්ථාවේදී [a-z]) එක් වරක් හෝ කිහිප වතාවක් නැවත නැවත කිරීම බව සලකන්න. [a-z]+ කුඩා අකුරු අකාරාදී අක්ෂර එකක් හෝ කිහිපයක් පුනරාවර්තනය වන ඕනෑම තන්තුවකට ගැලපේ.

. යනු මෙටා චරිතයක් (විශේෂ අරුතක් සහිත චරිතයක්) සහ පසුබෑමකින් ගැලවිය යුතුය.

නිත්‍ය ප්‍රකාශන රටා තන්තු බොහෝ විට backslashes භාවිතා කරන බැවින්, උදාහරණයේ මෙන් raw strings භාවිතා කිරීම පහසු වේ.

නිත්‍ය ප්‍රකාශන රටා වස්තුවක ක්‍රමයක් තුළ ධාවනය වේ

නැවත මොඩියුලයේ නිත්‍ය ප්‍රකාශන සැකසීමේ දෙවන ක්‍රමය වන්නේ නිත්‍ය ප්‍රකාශන රටා වස්තු ක්‍රමයයි.

re.compile() භාවිතයෙන්, ඔබට නිත්‍ය ප්‍රකාශන රටා වස්තුවක් සෑදීමට සාමාන්‍ය ප්‍රකාශන රටා තන්තුවක් සම්පාදනය කළ හැක.

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()උදාහරණයක් ලෙස, මෙම ශ්‍රිතවල ක්‍රියාවලියම නිත්‍ය ප්‍රකාශන වස්තු වල ක්‍රම ගැලපෙන(),උප() ලෙස ක්‍රියාත්මක කල හැක.

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

පහත විස්තර කර ඇති සියලුම re.xxx() ශ්‍රිත සාමාන්‍ය ප්‍රකාශන වස්තුවේ ක්‍රම ලෙස ද සපයා ඇත.

ඔබ එකම රටාව භාවිතා කරන ක්‍රියාවලියක් නැවත සිදු කරන්නේ නම්, re.compile() සමඟ නිත්‍ය ප්‍රකාශන වස්තුවක් ජනනය කර එය වටා භාවිතා කිරීම වඩාත් කාර්යක්ෂම වේ.

පහත නියැදි කේතයේ, පහසුව සඳහා සම්පාදනය නොකර ශ්‍රිතය භාවිතා කරයි, නමුත් ඔබට එකම රටාව නැවත නැවත භාවිතා කිරීමට අවශ්‍ය නම්, එය කල්තියා සම්පාදනය කර එය සාමාන්‍ය ප්‍රකාශන වස්තුවක ක්‍රමයක් ලෙස ක්‍රියාත්මක කිරීම රෙකමදාරු කරනු ලැබේ.

ගැලපෙන වස්තුව

match(), search(), etc. 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'>

ගැළපෙන තන්තුව සහ පිහිටීම ගැලපීමේ වස්තුවේ පහත ක්‍රම භාවිතයෙන් ලබා ගනී.

  • තරඟයේ ස්ථානය ලබා ගන්න:start(),end(),span()
  • ගැළපෙන තන්තුව ලබා ගන්න:group()
  • එක් එක් කණ්ඩායම සඳහා තන්තුව ලබා ගන්න:groups()
print(m.start())
# 0

print(m.end())
# 11

print(m.span())
# (0, 11)

print(m.group())
# 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(m.groups())
# ('aaa', 'xxx', 'com')

තන්තුවක ආරම්භය ගැළපේදැයි පරීක්ෂා කරන්න, උපුටා ගැනීම: ගැලපීම()

තන්තුවේ ආරම්භය රටාවට ගැලපේ නම් match() ගැලපෙන වස්තුවක් ලබා දෙයි.

ඉහත සඳහන් කළ පරිදි, ගැළපෙන උපස්ථරය උකහා ගැනීමට හෝ ගැළපීමක් සිදු කළේ දැයි පරීක්ෂා කිරීමට ගැළපෙන වස්තුව භාවිත කළ හැක.

match() ආරම්භය පමණක් පරීක්ෂා කරයි. ආරම්භයේ ගැළපෙන තන්තුවක් නොමැති නම්, එය කිසිවක් නැත.

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

ආරම්භයට සීමා නොවී ගැලපීම් සඳහා පරීක්ෂා කරන්න, උපුටා ගැනීම: සොයන්න()

match(), එය ගැලපෙන වස්තුවක් ගැලපෙන්නේ නම් එය ලබා දෙයි.

ගැළපෙන කොටස් කිහිපයක් තිබේ නම්, පළමු ගැලපෙන කොටස පමණක් ආපසු ලබා දෙනු ඇත.

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'>

ඔබට ගැලපෙන සියලුම කොටස් ලබා ගැනීමට අවශ්‍ය නම්, පහත විස්තර කර ඇති පරිදි findall() හෝ finditer() භාවිතා කරන්න.

සම්පූර්ණ තන්තුව ගැලපේදැයි පරීක්ෂා කරන්න: fullmatch()

සම්පූර්ණ තන්තුව සාමාන්‍ය ප්‍රකාශන රටාවට ගැළපේදැයි පරීක්ෂා කිරීමට, fullmatch() භාවිතා කරන්න. උදාහරණයක් ලෙස, තන්තුවක් ඊමේල් ලිපිනයක් ලෙස වලංගුද නැද්ද යන්න පරීක්ෂා කිරීමට මෙය ප්‍රයෝජනවත් වේ.

සම්පූර්ණ තන්තුව ගැලපෙන්නේ නම්, ගැළපෙන වස්තුවක් ආපසු එවනු ලැබේ.

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'>

නොගැලපෙන කොටස් තිබේ නම් (අර්ධ ගැලපීම් හෝ කිසිසේත්ම ගැලපීම් නොමැත), කිසිවක් ආපසු ලබා නොදේ.

s = '!!!aaa@xxx.com!!!'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# None

සම්පූර්ණ තරඟය() පයිතන් 3.4 හි එකතු කරන ලදී. ඔබට පෙර අනුවාද වලද එසේ කිරීමට අවශ්‍ය නම්, අවසානයේ Match() සහ ගැලපෙන meta අක්ෂරය $ භාවිතා කරන්න. මුල සිට අග දක්වා සම්පූර්ණ තන්තුව නොගැලපේ නම්, එය කිසිවක් නැත.

s = '!!!aaa@xxx.com!!!'

m = re.match(r'[a-z]+@[a-z]+\.com$', s)
print(m)
# None

ගැලපෙන සියලුම කොටස් ලැයිස්තුවක් ලබා ගන්න: findall()

findall() විසින් ගැලපෙන සියලුම උපස්ථර ලැයිස්තුවක් ලබා දෙයි. ලැයිස්තුවේ මූලද්‍රව්‍ය ගැළපෙන වස්තූන් නොව නූල් බව සලකන්න.

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']

ලැයිස්තුවේ ඇති මූලද්‍රව්‍ය සංඛ්‍යාව ආපසු ලබා දෙන බිල්ට් ශ්‍රිතය len() භාවිතයෙන් ගැළපෙන කොටස් ගණන පරීක්ෂා කළ හැක.

print(len(result))
# 3

සාමාන්‍ය ප්‍රකාශන රටාවකින් වරහන්() සමඟ සමූහගත කිරීම එක් එක් කාණ්ඩයේ මූලද්‍රව්‍ය වන ටියුපල් ලැයිස්තුවක් ලබා දෙයි. මෙය තරඟ වස්තුවේ කණ්ඩායම්() ට සමාන වේ.

result = re.findall(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(result)
# [('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', 'aaa', 'xxx', 'com'), ('bbb@yyy.com', 'bbb', 'yyy', 'com'), ('ccc@zzz.net', 'ccc', 'zzz', 'net')]

ගැළපීමක් සොයාගත නොහැකි නම්, හිස් ටුපල් එකක් ආපසු එවනු ලැබේ.

result = re.findall('[0-9]+', s)
print(result)
# []

සියලුම ගැලපෙන කොටස් පුනරාවර්තකයක් ලෙස ලබා ගන්න: finditer()

finditer() සියලුම ගැලපෙන කොටස් පුනරාවර්තකයක් ලෙස ලබා දෙයි. මූලද්‍රව්‍ය යනු findall() වැනි තන්තු නොවේ, නමුත් ගැලපෙන වස්තු, එබැවින් ඔබට ගැලපෙන කොටස්වල පිහිටීම (දර්ශකය) ලබා ගත හැකිය.

පුනරාවර්තකය එහි අන්තර්ගතය ලබා ගැනීම සඳහා මුද්‍රණය () සමඟ මුද්‍රණය කළ නොහැක. ඔබ බිල්ට්-ඉන් ශ්‍රිතය next() හෝ for ප්‍රකාශය භාවිතා කරන්නේ නම්, ඔබට අන්තර්ගතය එකින් එක ලබා ගත හැක.

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'>

එය 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)

ඔබට ගැලපෙන සියලුම කොටස්වල පිහිටීම ලබා ගැනීමට අවශ්‍ය නම්, ලැයිස්තුව () ට වඩා ලැයිස්තු අවබෝධතා අංකනය වඩාත් පහසු වේ.

print([m.span() for m in re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)])
# [(0, 11), (13, 24), (26, 37)]

පුනරාවර්තකය අනුපිළිවෙලින් මූලද්‍රව්‍ය පිටතට ගනී. ඔබ අවසානයට පැමිණි පසු තවත් මූලද්‍රව්‍ය උකහා ගැනීමට උත්සාහ කළහොත් ඔබට කිසිවක් ඉතිරි නොවන බව සලකන්න.

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))
# []

ගැලපෙන කොටස් ප්‍රතිස්ථාපනය කරන්න: sub(), subn()

sub() භාවිතයෙන් ඔබට ගැලපෙන කොටස වෙනත් තන්තුවකින් ප්‍රතිස්ථාපනය කළ හැක. ආදේශ කළ තන්තුව ආපසු ලබා දෙනු ඇත.

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'>

වරහන්() සමඟ සමූහගත කරන විට, ප්‍රතිස්ථාපනය කළ තන්තුවෙහි ගැළපෙන තන්තුව භාවිතා කළ හැක.

පෙරනිමියෙන්, පහත සඳහන් දෑ සඳහා සහය දක්වයි: අමු නූල් නොවන සාමාන්‍ය නූල් සඳහා, පසුබෑමෙන් බේරීමට පසුපසට පෙරාතුව පසුබෑමක් ලැයිස්තුගත කළ යුතු බව සලකන්න.

\1පළමු වරහන්
\2දෙවන වරහන්
\3තුන්වන වරහන්
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>
ඔබ සාමාන්‍ය ප්‍රකාශන රටාවේ වරහන් ආරම්භයේදී මෙය ලිවීමෙන් කණ්ඩායම නම් කරන්නේ නම්, පහත දැක්වෙන පරිදි අංකය වෙනුවට නම භාවිතයෙන් ඔබට එය නියම කළ හැක.
\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

තර්ක ගණන උපරිම ප්‍රතිස්ථාපන ගණන නියම කරයි. වම් පැත්තේ සිට ගණන් කිරීම පමණක් ප්රතිස්ථාපනය කරනු ලැබේ.

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() ආදේශ කළ තන්තුවේ ටියුපල් (උප() හි ප්‍රතිලාභ අගයට සමාන) සහ ආදේශක කොටස් ගණන (රටාවට ගැළපෙන සංඛ්‍යාව) ලබා දෙයි.

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# ('new-address, new-address, ccc@zzz.net', 2)

තර්ක නියම කිරීමේ ක්‍රමය උප() ට සමාන වේ. ඔබට වරහන් මගින් කාණ්ඩ කළ කොටස භාවිතා කළ හැක, නැතහොත් තර්ක ගණන සඳහන් කරන්න.

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)

නිත්‍ය ප්‍රකාශන රටා සහිත නූල් බෙදීම: බෙදීම()

split() රටාවට ගැළපෙන කොටසෙහි තන්තුව බෙදා, ලැයිස්තුවක් ලෙස ආපසු ලබා දෙයි.

පළමු සහ අවසාන තරඟවල ප්‍රතිඵල ලැයිස්තුවේ ආරම්භයේ සහ අවසානයේ හිස් නූල් අඩංගු වන බව සලකන්න.

s = '111aaa222bbb333'

result = re.split('[a-z]+', s)
print(result)
# ['111', '222', '333']

result = re.split('[0-9]+', s)
print(result)
# ['', 'aaa', 'bbb', '']

maxsplit තර්කය උපරිම බෙදීම් ගණන (කෑලි) නියම කරයි. වම් පැත්තෙන් ගණන් කිරීම පමණක් බෙදනු ලැබේ.

result = re.split('[a-z]+', s, 1)
print(result)
# ['111', '222bbb333']

Python හි නිත්‍ය ප්‍රකාශන metacharacters, විශේෂ අනුක්‍රම සහ අනතුරු ඇඟවීම්

Python 3 re මොඩියුලයේ භාවිතා කළ හැකි ප්‍රධාන නිත්‍ය ප්‍රකාශන මෙටා අක්ෂර (විශේෂ අක්ෂර) සහ විශේෂ අනුපිළිවෙල පහත පරිදි වේ.

metacharacterඅන්තර්ගතය
.නව රේඛාවක් හැර වෙනත් ඕනෑම තනි අක්ෂරයක් (DOTALL ධජය සහිත නව රේඛාවක් ඇතුළුව)
^තන්තුවේ ආරම්භය (එක් එක් පේළියේ ආරම්භය MULTILINE ධජය සමඟ ද ගැලපේ)
$තන්තුවේ අවසානය (එක් එක් පේළියේ අවසානය MULTILINE ධජය සමඟද ගැලපේ)
*පෙර රටාව 0 වතාවකට වඩා නැවත නැවත කරන්න
+අවම වශයෙන් එක් වරක්වත් පෙර රටාව නැවත කරන්න.
?පෙර රටාව 0 හෝ 1 වතාවක් නැවත නැවත කරන්න
{m}පෙර රටාව m වාරයක් නැවත කරන්න
{m, n}අන්තිම රටාව.m~nනැවත නැවත
[]චරිත කට්ටලයක්[]මෙම අක්ෂරවලින් ඕනෑම එකකට ගැලපේ
|හෝA|BA හෝ B රටාවට ගැලපේ
විශේෂ අනුපිළිවෙලඅන්තර්ගතය
\dයුනිකෝඩ් දශම සංඛ්‍යා (ASCII ධජය මගින් ASCII අංකවලට සීමා වේ)
\D\dමෙහි ප්රතිවිරුද්ධ අර්ථය.
\sUnicode whitespace අක්ෂර (ASCII ධජය මගින් ASCII whitespace අක්ෂරවලට සීමා වේ)
\S\sමෙහි ප්රතිවිරුද්ධ අර්ථය.
\wයුනිකෝඩ් වචන අක්ෂර සහ යටි ඉරි (ASCII අක්ෂරාංක අක්ෂරවලට සීමා වූ අතර ASCII ධජයෙන් යටින් ඉරි)
\W\wමෙහි ප්රතිවිරුද්ධ අර්ථය.

ඒවා සියල්ලම මෙම වගුවේ ලැයිස්තුගත කර නොමැත. සම්පූර්ණ ලැයිස්තුවක් සඳහා නිල ලේඛන බලන්න.

Python 2 හි සමහර අර්ථයන් වෙනස් බව ද සලකන්න.

ධජය සැකසීම

ඉහත වගුවේ පෙන්වා ඇති පරිදි, සමහර මෙටා අක්ෂර සහ විශේෂ අනුපිළිවෙල ධජය මත පදනම්ව ඒවායේ මාදිලිය වෙනස් කරයි.

මෙහි ආවරණය කර ඇත්තේ ප්‍රධාන කොඩි පමණි. ඉතිරිය සඳහා නිල ලේඛන බලන්න.

ASCII අක්ෂරවලට සීමා වේ: re.ASCII

\wමෙය Python 3 තන්තු සඳහා පෙරනිමියෙන් ද්විත්ව-බයිට් කන්ජි, අක්ෂරාංක අක්ෂර ආදියට ගැලපේ. එය සම්මත නිත්‍ය ප්‍රකාශනයක් නොවන නිසා එය පහත ඒවාට සමාන නොවේ.[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

ඔබ එක් එක් ශ්‍රිතයේ තර්ක ධජ සඳහා re.ASCII සඳහන් කළහොත් හෝ සාමාන්‍ය ප්‍රකාශන රටා තන්තුවේ ආරම්භයට පහත පේළිගත ධජය එක් කළහොත්, එය ගැළපෙන්නේ ASCII අක්ෂරවලට පමණි (එය ද්විත්ව බයිට් ජපන්, අක්ෂරාංක අක්ෂර, ආදිය නොගැළපේ. .)
(?a)
මෙම අවස්ථාවේදී, පහත සඳහන් දෙක සමාන වේ.
\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

re.compile() සමඟ සම්පාදනය කිරීමේදී ද එය අදාළ වේ. තර්ක කොඩි හෝ පේළිගත කොඩි භාවිතා කරන්න.

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

ASCII කෙටි පෝරමය re ලෙසද පවතී. පිළිතුර – ඔබට ඕනෑම එකක් භාවිතා කළ හැකිය.

print(re.ASCII is re.A)
# True

\W, \W හි ප්‍රතිවිරුද්ධය, re.ASCII සහ පේළිගත කොඩි මගින් ද බලපායි.

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='漢字ＡＢＣ１２３'>

\w සමඟින්, පහත දැක්වෙන දෙක පෙරනිමියෙන් තනි-බයිට් සහ ද්විත්ව-බයිට් අක්ෂර දෙකටම ගැලපේ, නමුත් re.ASCII හෝ පේළිගත කොඩි සඳහන් කර ඇත්නම් තනි-බයිට් අක්ෂරවලට සීමා වේ.

  • ඉලක්කම් ගළපන්න\d
  • හිස් අවකාශයකට ගැලපේ\s
  • ඉලක්කම් නොවන ඒවාට ගැලපේ\D
  • ඕනෑම ඉඩක් නොවන ඉඩකට ගැලපේ.\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

සිද්ධි සංවේදී නොවේ:re.IGNORECASE

පෙරනිමියෙන්, එය සිද්ධි සංවේදී වේ. දෙකම ගැළපීමට, ඔබ රටාවේ ලොකු අකුරු සහ කුඩා අකුරු දෙකම ඇතුළත් කළ යුතුය.

re.IGNORECASEමෙය සඳහන් කර ඇත්නම්, එය සංවේදී නොවන ලෙස ගැළපේ. සම්මත නිත්‍ය ප්‍රකාශනවල i ධජයට සමාන වේ.

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'>

ඔබට වඩා අඩු හෝ සමාන භාවිතා කළ හැක.

  • පේළිගත කොඩිය(?i)
  • කෙටි යෙදුමre.I

එක් එක් පේළියේ ආරම්භය සහ අවසානය ගලපන්න:re.MULTILINE

^මෙම නිත්‍ය ප්‍රකාශනයේ මෙටා අක්ෂර තන්තුවේ ආරම්භයට ගැලපේ.

පෙරනිමියෙන්, සම්පූර්ණ තන්තුවෙහි ආරම්භය පමණක් ගැලපේ, නමුත් පහත දැක්වෙන්නේ එක් එක් පේළියේ ආරම්භයටද ගැලපේ. සම්මත නිත්‍ය ප්‍රකාශනවල m කොඩියට සමාන වේ.
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']

$තන්තුවේ අවසානයට ගැලපේ. පෙරනිමියෙන්, සම්පූර්ණ තන්තුවෙහි අවසානය පමණක් ගැලපේ.
re.MULTILINEඔබ මෙය සඳහන් කළහොත්, එය එක් එක් පේළියේ අවසානයට ද ගැලපේ.

result = re.findall('[a-z]+$', s)
print(result)
# ['zzz']

result = re.findall('[a-z]+$', s, flags=re.MULTILINE)
print(result)
# ['xxx', 'yyy', 'zzz']

ඔබට වඩා අඩු හෝ සමාන භාවිතා කළ හැක.

  • පේළිගත කොඩිය(?m)
  • කෙටි යෙදුමre.M

කොඩි කිහිපයක් සඳහන් කරන්න

|ඔබට එකවර ධජ කිහිපයක් සක්‍රීය කිරීමට අවශ්‍ය නම්, මෙය භාවිතා කරන්න. පේළිගත කොඩි සම්බන්ධයෙන්, සෑම අක්ෂරයක්ම පහත දැක්වෙන පරිදි අකුරක් අනුගමනය කළ යුතුය.
(?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']

ලෝභ සහ ලෝභ නැති ගැළපීම්

මෙය නිත්‍ය ප්‍රකාශන වල සාමාන්‍ය ගැටලුවකි, පයිතන් වල ප්‍රශ්නයක් පමණක් නොව, එය මා අමාරුවේ වැටෙන බැවින් මම ඒ ගැන ලියන්නම්.

පෙරනිමියෙන්, පහත දැක්වෙන්නේ ගිජු ගැලපීමකි, එය හැකි දිගම තන්තුවට ගැලපේ.

  • *
  • +
  • ?
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

එම ? එය ගිජු නොවන, අවම ගැළපීමක් ඇති කළ පසු, හැකි කෙටිම තන්තුවට ගැලපේ.

  • *?
  • +?
  • ??
m = re.match(r'.+?com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.group())
# aaa@xxx.com

පෙරනිමි කෑදර ගැළපීම අනපේක්ෂිත තන්තුවලට ගැළපිය හැකි බව සලකන්න.

Copied title and URL