Python හි නිත්ය ප්රකාශන වල ගිජුකම සීමා කිරීම
නිත්ය ප්රකාශන මූලිකවම ගිජු වේ. මෙයින් අදහස් කරන්නේ ඒවා සංකේත උපරිම වශයෙන් හැකි තරම් ග්රහණය කරන බවයි. අපි උදාහරණයක් සමඟ අධ්යයනය කරමු. අපට පහත දැක්වෙන නූල තිබිය යුතුය:
txt = 'aeeex zzz x kkk'
මෙම නූල තුළ, අපට උප නූල සොයා ගැනීමට අවශ්යය
'aeeex' පහත සංයුක්ත රටාව අනුව:
'a' අක්ෂරය 'a', ඉන්පසු ඕනෑම අක්ෂරයක්
එක් හෝ වැඩි වාර ගණනක්, ඉන්පසු 'x' අක්ෂරය 'x':
res = re.sub('a.+x', '!', txt)
print(res)
අපට '! zzz x kkk' නූල ලැබිය යුතු වුවද, '! kkk' නූල මුද්රණය වේ.
හේතුව නම් අපගේ නිත්ය ප්රකාශනය
'a' අක්ෂරයේ සිට 'x' අක්ෂරය දක්වා සියලු අක්ෂර සොයයි.
නමුත් අපගේ නූල තුළ 'x' අක්ෂර දෙකක් තිබේ!
ගිජුකම හේතුවෙන්, නිත්ය ප්රකාශනය අවසාන x දක්වා සොයයි,
එමඟින් අපට අවශ්ය නොවූ දේ ග්රහණය කරයි.
නිසැකවම, බොහෝ විට මෙම හැසිරීම අපට අවශ්ය වේ. නමුත් මෙම නිශ්චිත අවස්ථාවේදී ගිජුකම අවලංගු කිරීමට සහ නිත්ය ප්රකාශනයට පැවසිය යුතුය, එය පළමු x දක්වා සොයා බලන ලෙස. මෙම අවස්ථාවේදී පුනරාවර්තන ක්රියාකරුගෙන් පසුව ප්රශ්නාර්ථ ලකුණ තැබිය යුතුය:
res = re.sub('a.+?x', '!', txt)
print(res) # '! zzz x kkk' නූල මුද්රණය කරයි
සියලුම පුනරාවර්තන ක්රියාකරුවන්ට ගිජුකම සීමා කළ හැකිය:
*, ? සහ
{} - මේ ආකාරයට: *?, ??
සහ {}?.
නූලක් ලබා දී ඇත:
txt = 'aba accca azzza wwwwa'
නිත්ය ප්රකාශනයක් ලියන්න, එය සොයා ගනී
'a' අක්ෂර පැතිවල ඇති සියලුම
නූල, සහ ඒවායින් එක් එක් ආදේශ කරයි
'!' සමඟ. 'a' අක්ෂර අතර
ඕනෑම අක්ෂරයක් තිබිය හැක ('a' හැර).
