පයිතන් හි නිත්ය ප්රකාශන සඳහා ධජ
නිත්ය ප්රකාශන සමඟ වැඩ කරන ක්රම සඳහා විකල්ප පරාමිති වලින් එකක් ලෙස ධජ සැකසීමට පහත වාක්ය ඛණ්ඩය භාවිතා කරයි:
flags=re.ධජයේ නම
නිත්ය ප්රකාශන සමඟ වැඩ කිරීම සඳහා ප්රධාන ධජ
| ධජය | අරමුණ |
|---|---|
re.IGNORECASE |
අක්ෂර ලිවීමේ වර්ගීකරණය නොසලකා හැරීම. |
re.DOTALL |
තිත ඕනෑම අක්ෂරයක්, පේළියක් බිඳීම ද ඇතුළුව, නිරූපණය කරයි. |
re.I |
සෙවීම වර්ගීකරණයට සංවේදී නොවන ආකාරයට සකසයි. |
re.L |
වර්තමාන භාෂාව අනුව වචන සොයයි.
මෙම අර්ථ නිරූපණය අක්ෂරමය කණ්ඩායම (\w සහ \W) මෙන්ම
වචන සීමාවේ හැසිරීම (\b සහ
\B) ද බලපායි.
|
re.M |
$ සංකේතය ඕනෑම පෙළ පේළියක අවසානයේ සෙවීම සිදු කරයි
(පෙළේ අවසානය පමණක් නොව) සහ ^ සංකේතය ඕනෑම
පෙළ පේළියක ආරම්භයේ සෙවීම සිදු කරයි (පෙළේ ආරම්භයේ
පමණක් නොව).
|
re.S |
තිත (.) හි අගය වෙනස් කර නව
පේළිය ඇතුළුව ඕනෑම අක්ෂරයක් සමඟ ගැලපීමට සකසයි.
|
re.U |
අක්ෂර යුනිකේත සමූහය අනුව අක්ෂර අර්ථ නිරූපණය කරයි.
මෙම ධජය බලපායි \w, \W, \b,
\B හි හැසිරීමට. පයිතන් 3+ හි මෙම ධජය
පෙරනිමිය ලෙස සකසා ඇත.
|
re.X |
බහු-පේළි නිත්ය ප්රකාශන වාක්ය ඛණ්ඩය ඉඩ දෙයි.
එය රටාව තුළ ඇති හිස් අවකාශ (සමූහය තුළ ඇති හිස් අවකාශ හැර
[] හෝ පසුපස ආවරණය මගින් ආරක්ෂා කළ විට) නොසලකා හරින අතර
ආරක්ෂා නොකළ '#' අදහස් දැක්වීමක් ලෙස සැකසයි.
|
උදාහරණය
re.IGNORECASE ධජය භාවිතා කර අක්ෂරවල
වර්ගීකරණය නොසලකා හැරිය හැකිය. එය කරන ආකාරය
බලමු. මෙම උදාහරණයේ නිත්ය ප්රකාශනය කුඩා අකුරු පමණක් සොයා ගනී:
txt = 'aaa bbb CCC DDD'
res = re.sub('[a-z]+', '!', txt)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'! ! CCC DDD'
උදාහරණය
දැන් ක්රමයේ සිව්වන පරාමිතියට
re.IGNORECASE ධජය එකතු කර නිත්ය ප්රකාශනය
සියලුම වර්ගීකරණ වල අක්ෂර සෙවීම ආරම්භ කරයි:
txt = 'aaa AAA bbb BBB'
res = re.sub('[a-z]+', '!', txt, flags=re.IGNORECASE)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'! ! ! !'
උදාහරණය
නිත්ය ප්රකාශනය මගින් සියලු පේළි බිඳීම් සොයා ගනිමු:
txt = '''aaa
bbb'''
res = re.sub('\n', '!', txt)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'aaa!bbb'
උදාහරණය
නමුත්, සියලුම අක්ෂර ප්රතිස්ථාපනය කිරීමට අවශ්ය නම්, නිත්ය ප්රකාශනයේ තිත තැබුවද, පේළි බිඳීම් අල්ලා ගන්නේ නැත:
txt = '''aaa
bbb'''
res = re.sub('.', '!', txt)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'!!!
!!!'
උදාහරණය
මෙම දෝෂය නිවැරදි කිරීමට,
re.DOTALL ධජය යෙදිය යුතුය:
res = re.sub('.', '!', txt, flags=re.DOTALL)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'!!!!!!!'
උදාහරණය
පරාමිතිය තුළට ධජ කිහිපයක් සම්ප්රේෂණය කළ හැකිය,
ඒවා අතර + ක්රියාකරු තබා.
පළමුව 'a' අක්ෂරය
පේළිය අවසානයේ ප්රතිස්ථාපනය කරමු:
txt = '''
aaa
AAA
aaa'''
res = re.sub('aaa$', '!', txt)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'''
aaa
AAA
!
'''
උදාහරණය
දැන් re.M ධජය තබමු:
res = re.sub('aaa$', '!', txt, flags=re.M)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'''
!
AAA
!
'''
උදාහරණය
දැන් වර්ගීකරණය නොසලකා හැරීමේ ධජය ද යොදමු:
res = re.sub('aaa$', '!', txt, flags=re.M+re.IGNORECASE)
print(res)
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
'''
!
!
!
'''
