Python රෙගුලර් ප්රකාශනවල විශේෂ සංකේත හුරු කිරීම
ඔබට විශේෂ සංකේතයක් එයම නිරූපණය කිරීමට අවශ්ය බව සිතමු. මේ සඳහා එය backslash එකක් භාවිතයෙන් හුරු කළ යුතුය. අපි උදාහරණ බලමු.
උදාහරණය
ඊළඟ උදාහරණයේ, රෙගුලර් ප්රකාශනයේ රචකයාට අවශ්ය වූයේ සෙවුම් රටාව
මෙලෙස පෙනෙන ලෙසය: අකුර 'a', ඉන්පසු එකතු කිරීමේ සංකේතය
'+', ඉන්පසු අකුර 'x'. කෙසේ වෙතත්, කේත රචකයා
'+' සංකේතය හුරු නොකළ අතර, එම නිසා සැබෑ සෙවුම් රටාව
මෙලෙස පෙනේ: අකුර 'a' එක් හෝ ඊට වැඩි වාර ගණනක්,
ඉන්පසු අකුර 'x':
txt = 'a+x ax aax aaax'
res = re.sub('a+x', '!', txt)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'a+x ! ! !'
උදාහරණය
දැන් රචකයා එකතු කිරීමේ සංකේතය backslash එකකින් හුරු කර ඇත.
දැන් සෙවුම් රටාව නිවැරදිව පෙනේ: අකුර 'a', ඉන්පසු එකතු කිරීමේ සංකේතය
'+', ඉන්පසු අකුර 'x':
txt = 'a+x ax aax aaax'
res = re.sub('a\+x', '!', txt)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'! ax aax aaax'
උදාහරණය
මෙම උදාහරණයේ රටාව මෙලෙස පෙනේ:
අකුර 'a', ඉන්පසු කාලය '.',
ඉන්පසු අකුර 'x':
txt = 'a.x abx azx'
res = re.sub('a\.x', '!', txt)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'! abx azx'
උදාහරණය
ඊළඟ උදාහරණයේ රචකයා කාලය හුරු කිරීමට අමතක කළ අතර, රෙගුලර් ප්රකාශනයට සියලු උපස්ත්රිං වලට ගැලපුණි, එයට හේතුව හුරු නොකළ කාලයක් ඕනෑම සංකේතයක් නිරූපණය කිරීමයි:
txt = 'a.x abx azx'
res = re.sub('a.x', '!', txt)
print(res)
කේතය ක්රියාත්මක කිරීමේ ප්රතිඵලය:
'! ! !'
සටහන
සටහන් කර ගන්න, ඔබ කාලය සඳහා backslash එක අමතක කළහොත් (එය එයම නිරූපණය කළ යුතු විට) - එය දැකීමට පවා නොහැකි විය හැකිය:
res = re.sub('a.x', '!', 'a.x')
print(res) # '!' ලෙස ආපසු දෙයි, අපට අවශ්ය ලෙසම
දෘශ්යමාන වශයෙන් නිවැරදිව ක්රියා කරයි (කාලයක් ඕනෑම සංකේතයක්
නිරූපණය කරන බැවින්, සාමාන්ය කාලය '.' ද ඇතුළුව). නමුත් අපි
ප්රතිස්ථාපන සිදුවන පේළිය වෙනස් කළහොත් - අපගේ වරද අපට දැක ගත හැකිය:
res = re.sub('a.x', '!', 'a.x abx azx')
print(res) # '! ! !' ලෙස ආපසු දෙයි, නමුත් අපේක්ෂා කළේ '! abx azx' වේ
විශේෂ සංකේත සහ සාමාන්ය සංකේත ලැයිස්තුව
සාමාන්ය සංකේතයක් හුරු කළහොත් - භයානක කිසිවක් සිදු නොවේ - එය තවමත් එයම නිරූපණය කරයි. ව්යතිරේකය වන්නේ ඉලක්කම්, ඒවා හුරු කළ නොහැක.
දී ඇති සංකේතයක් විශේෂද යන්න පිළිබඳව බොහෝ විට සැකයක් ඇති වේ. සමහරු සැක සහිත සියලුම සංකේත backslash මගින් එකින් එක හුරු කරති. කෙසේ වෙතත්, මෙය නරක භාවිතයකි (රෙගුලර් ප්රකාශනය backslash වලින් අවුල් කරයි).
විශේෂ සංකේත වන්නේ: $ ^ . * + ? \ / {} [] () |
විශේෂ සංකේත නොවන්නේ: @ : , ' " - _ = < > % # ~ `& !
ප්රායෝගික කාර්යයන්
පේළියක් ලබා දී ඇත:
txt = 'a.a aba aea'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය පේළිය
'a.a' සොයා ගනී, අනෙක් ඒවා අල්ලා නොගෙන.
පේළියක් ලබා දී ඇත:
txt = '2+3 223 2223'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය පේළිය
'2+3' සොයා ගනී, අනෙක් ඒවා අල්ලා නොගෙන.
පේළියක් ලබා දී ඇත:
txt = '23 2+3 2++3 2+++3 345 567'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය පේළි
'2+3', '2++3', '2+++3',
සොයා ගනී, අනෙක් ඒවා අල්ලා නොගෙන (+ ඕනෑම
අංකයක් විය හැකිය).
පේළියක් ලබා දී ඇත:
txt = '23 2+3 2++3 2+++3 445 677'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය පේළි
'23', '2+3', '2++3',
'2+++3', සොයා ගනී, අනෙක් ඒවා අල්ලා නොගෙන.
පේළියක් ලබා දී ඇත:
txt = '*+ *q+ *qq+ *qqq+ *qqq qqq+'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය පේළි
'*q+', '*qq+', '*qqq+',
සොයා ගනී, අනෙක් ඒවා අල්ලා නොගෙන.
පේළියක් ලබා දී ඇත:
txt = '[abc] {abc} abc (abc) [abc]'
රෙගුලර් ප්රකාශනයක් ලියන්න, එය හතරැස් වරහන් තුළ ඇති පේළි
සොයා ගෙන ඒවා '!' ලෙස ප්රතිස්ථාපනය කරයි.
