Regex මූලික කරුණු: Python සමග Patterns හඳුනාගැනීම | SC Guide
හැඳින්වීම: Regex කියන්නේ මොකද්ද?
ආයුබෝවන් හැමෝටම! ✋ ඔයාලා දන්නවද, අපි සොෆ්ට්වෙයාර් ඉංජිනේරුවන් විදිහට හැමදාම වගේ ඩේටා එක්ක වැඩ කරනවා. ඒ කියන්නේ, text strings අතරින් අපිට ඕන කරන විශේෂ patterns හොයාගන්න, validate කරන්න, නැත්නම් වෙනස් කරන්න අපිට ගොඩක් වෙලාවට සිද්ධ වෙනවා. උදාහරණයක් විදිහට, user කෙනෙක්ගේ email address එකක් හරි, phone number එකක් හරි හරි format එකට තියෙනවද කියලා බලන එක. එතකොට තමයි Regular Expressions, නැත්නම් කෙටියෙන් Regex, කියන මේ අපූරු ටූල් එක අපේ පිහිටට එන්නේ!
Regex කියන්නේ text strings වල තියෙන patterns describe කරන්න පාවිච්චි කරන special character sequence එකක්. මේක හරියටම කිව්වොත්, text data ඇතුළේ 'හොයාගන්න' (search), 'ගැලපෙනවාද බලන්න' (match), 'වෙනස් කරන්න' (replace) වගේ දේවල් කරන්න පුළුවන් පුදුමාකාර බලයක් තියෙන පොඩි Programming Language එකක් වගේ දෙයක්. 😱
අද මේ guide එකෙන් අපි Regex වල මූලිකම දේවල් ගැන කතා කරනවා. විශේෂයෙන්ම Python Programming Language එක ඇතුළේ Regex කොහොමද පාවිච්චි කරන්නේ කියලා අපි බලමු. මේක ඉගෙන ගත්තම ඔයාලට ඔයාලගේ දෛනික coding වැඩ ගොඩක් ලේසි කරගන්න පුළුවන් වෙයි කියලා මට විශ්වාසයි. එහෙනම්, අපි පටන් ගමු!
Regex වල මූලික Metacharacters
Regex කියන්නේ පොඩි භාෂාවක් වගේ නිසා, ඒකට තියෙනවා විශේෂ අකුරු, නැත්නම් Symbols. මේවාට කියන්නේ Metacharacters කියලා. මේ Metacharacters තේරුම් ගත්තම Regex වල හැකියාවන් ගැන ඔයාලට පුදුම හිතෙයි. අපි කීපයක් බලමු:
1. The Dot (.) - ඕනෑම අකුරක්
මේක තමයි Regex වල ඉන්න ආසම Metacharacter එකක්! . (dot) එකෙන් කියවෙන්නේ newline character (\n) හැර ඕනෑම character එකක් කියන එකයි. ඒ කියන්නේ, space එකක්, අකුරක්, ඉලක්කමක්, Symbol එකක්... ඕනෑම එකක්. හරියටම කිව්වොත්, 'wildcard' එකක් වගේ.
c.tමේ pattern එකෙන් cat, cot, cut, c8t වගේ ඕනෑම character එකක් c සහ t අතර තියෙන වචන match කරනවා.
2. The Asterisk (*) - බිංදුවක් හෝ ඊට වැඩි
* (asterisk) එක කලින් Metacharacter එකට පස්සේ ආවොත්, ඒකෙන් කියවෙන්නේ ඒ Metacharacter එක match වෙන character එක බිංදුවක් හෝ ඊට වැඩි වාර ගණනක් ආවොත් කියන එකයි. තේරුණේ නැත්ද? උදාහරණයක් බලමු.
ab*cමේකෙන් match වෙනවා:
ac(b බිංදුවක්)abc(b එකක්)abbc(b දෙකක්)abbbbc(b කීපයක්)
3. The Plus (+) - එකක් හෝ ඊට වැඩි
+ (plus) එකත් * වගේමයි. නමුත් මේකෙන් කියවෙන්නේ ඒ Metacharacter එක match වෙන character එක එකක් හෝ ඊට වැඩි වාර ගණනක් ආවොත් කියන එකයි. ඒ කියන්නේ, අඩුම තරමේ එක පාරක්වත් තියෙන්න ඕන.
ab+cමේකෙන් match වෙනවා:
abcabbcabbbbc
නමුත් ac නම් match වෙන්නේ නැහැ, මොකද b අකුර එක පාරක්වත් නැති නිසා.
4. The Question Mark (?) - බිංදුවක් හෝ එකක්
? (question mark) එකෙන් කියවෙන්නේ ඒ Metacharacter එක match වෙන character එක බිංදුවක් හෝ එක වාරයක් පමණක් ආවොත් කියන එකයි. ඒ කියන්නේ, ඒක තියෙන්නත් පුළුවන්, නැති වෙන්නත් පුළුවන්.
colou?rමේකෙන් match වෙනවා:
color(u නැහැ)colour(u එකයි)
ඉංග්‍රීසි භාෂාවේ British සහ American spelling දෙකටම මේක ප්‍රයෝජනවත්.
5. Square Brackets ([]) - Character Set එකක්
[] (square brackets) ඇතුළේ දාන characters වලින් කියවෙන්නේ ඒ bracket එක ඇතුළේ තියෙන characters වලින් එකක් කියන එකයි.
[aeiou]මේකෙන් a, e, i, o, u කියන ඕනෑම character එකක් match කරනවා.
Range එකක් විදිහටත් දෙන්න පුළුවන්:
[0-9]- ඕනෑම ඉලක්කමක් (0-9)[a-z]- ඕනෑම පොඩි අකුරක් (a-z)[A-Z]- ඕනෑම ලොකු අකුරක් (A-Z)[a-zA-Z]- ඕනෑම පොඩි හෝ ලොකු අකුරක්[a-zA-Z0-9]- ඕනෑම අකුරක් හෝ ඉලක්කමක්
^ (caret) Symbol එක bracket එක ඇතුළේ මුලට දැම්මොත්, ඒකෙන් කියවෙන්නේ negation එකක්, ඒ කියන්නේ bracket එක ඇතුළේ තියෙන characters නොවන ඕනෑම character එකක් කියන එකයි.
[^0-9]මේකෙන් ඉලක්කම් නොවන ඕනෑම character එකක් match කරනවා.
6. Caret (^) - String එකක ආරම්භය
^ (caret) Symbol එක Regex pattern එකක මුලට දැම්මොත්, ඒකෙන් කියවෙන්නේ string එකක ආරම්භය කියන එකයි. ඒ කියන්නේ, pattern එක string එකේ මුලින්ම තියෙන්න ඕන.
^Helloමේකෙන් match වෙන්නේ Hello World වගේ Hello වලින් පටන් ගන්න strings විතරයි. Hi Hello වගේ strings match වෙන්නේ නැහැ.
7. Dollar Sign ($) - String එකක අවසානය
$ (dollar sign) Symbol එක Regex pattern එකක අගට දැම්මොත්, ඒකෙන් කියවෙන්නේ string එකක අවසානය කියන එකයි. ඒ කියන්නේ, pattern එක string එකේ අන්තිමටම තියෙන්න ඕන.
World$මේකෙන් match වෙන්නේ Hello World වගේ World වලින් ඉවර වෙන strings විතරයි. World Wide Web වගේ strings match වෙන්නේ නැහැ.
^ සහ $ දෙකම එකට පාවිච්චි කරොත්, ඒකෙන් කියවෙන්නේ මුළු string එකම pattern එකට match වෙන්න ඕන කියන එකයි.
^Hello World$මේකෙන් match වෙන්නේ හරියටම Hello World කියන string එක විතරයි.
Python වල re Module එක
Python වලට Regex එක්ක වැඩ කරන්න පුළුවන් re කියන built-in module එකක් තියෙනවා. අපි මේක import re කියලා code එකට ගන්න ඕන.
re.search()
re.search() function එකෙන් කරන්නේ, දීලා තියෙන string එක ඇතුළේ, දීලා තියෙන Regex pattern එකට match වෙන පළවෙනි තැන හොයාගන්න එක. match එකක් හම්බ වුණොත් match object එකක් return කරනවා, නැත්නම් None return කරනවා.
import re
text = "අපේ රටේ ගස්, ගල්, මල් ගොඩක් ලස්සනයි."
pattern = r"ගල්"
match = re.search(pattern, text)
if match:
print(f"'ගල්' යන වචනය හමුවිය: {match.group()}")
print(f"ආරම්භක ස්ථානය: {match.start()}")
print(f"අවසාන ස්ථානය: {match.end()}")
else:
print("'ගල්' යන වචනය හමු නොවීය.")
re.match()
re.match() function එකත් re.search() වගේමයි, නමුත් මේකෙන් බලන්නේ string එකේ මුලින්ම pattern එක match වෙනවද කියලා විතරයි. string එකේ මැද හරි අග හරි pattern එක match වුණත්, re.match() එකෙන් None return කරනවා.
import re
text1 = "Python programming is fun."
text2 = "I love Python programming."
pattern = r"Python"
match1 = re.match(pattern, text1)
match2 = re.match(pattern, text2)
if match1:
print(f"Text 1: '{match1.group()}' මුලින්ම හමුවිය.")
else:
print("Text 1: 'Python' මුලින්ම හමු නොවීය.")
if match2:
print(f"Text 2: '{match2.group()}' මුලින්ම හමුවිය.")
else:
print("Text 2: 'Python' මුලින්ම හමු නොවීය.")
මේ code එක run කරාම ඔයාලට පෙනෙයි text1 එක match වුණාට, text2 එක match වෙන්නේ නැහැ කියලා. මොකද Python කියන එක text2 එකේ මුලින්ම නැති නිසා.
re.findall()
re.findall() function එකෙන් කරන්නේ, දීලා තියෙන string එක ඇතුළේ දීලා තියෙන Regex pattern එකට match වෙන හැම තැනක්ම හොයාගෙන, ඒවා list එකක් විදිහට return කරන එක.
import re
text = "අපේ රටේ ගස්, ගල්, මල්, කඳු, ගංගා ගොඩක් ලස්සනයි. ගල් ආශ්‍රිත ප්‍රදේශ ලස්සනයි."
pattern = r"ග[ස්ල]"
matches = re.findall(pattern, text)
print(f"හමුවූ ගැලපීම්: {matches}")
# Output: හමුවූ ගැලපීම්: ['ගස්', 'ගල්', 'ගල්']
ප්‍රායෝගික උදාහරණ: Regex වල බලය!
දැන් අපි Metacharacters සහ Python වල re module එක ගැන දන්න නිසා, පොඩි Practical Examples ටිකක් බලමු.
1. සරල Patterns හොයමු: දුරකථන අංක
ලංකාවේ දුරකථන අංක සාමාන්‍යයෙන් 07X-XXXXXXX format එකට තියෙන්නේ. මේ වගේ pattern එකක් කොහොමද හොයන්නේ කියලා බලමු.
import re
phone_numbers_text = "අපේ customer services අංකය 077-1234567. support අංකය 011-9876543. තවත් එකක් 071-1112223."
# Regex pattern for Sri Lankan mobile/landline numbers
# ^0: Starts with 0
# [17]: Next digit is 1 or 7 (for 011 or 07X numbers)
# [0-9]{1}: Any digit (0-9) once
# -: a hyphen
# [0-9]{7}: Any digit (0-9) exactly 7 times
# Note: This is a simplified pattern and might not cover all edge cases.
pattern = r"0[17][0-9]-[0-9]{7}"
found_numbers = re.findall(pattern, phone_numbers_text)
if found_numbers:
print("හමුවූ දුරකථන අංක:")
for num in found_numbers:
print(num)
else:
print("දුරකථන අංක හමු නොවීය.")
මේ උදාහරණයේ [0-9]{7} කියන එකේ {7} වලින් කියවෙන්නේ, කලින් character එක (මේ අවස්ථාවේ [0-9]) හරියටම 7 පාරක් එන්න ඕන කියන එකයි. මේවාට Quantifiers කියලා කියනවා.
2. මූලික Email වලංගු කිරීම (Basic Email Validation)
Email address එකක් හරි format එකට තියෙනවද කියලා බලන එක ගොඩක් වෙලාවට අපිට ඕන වෙනවා. මේකට අපි Regex pattern එකක් පාවිච්චි කරමු. හැබැයි මතක තියාගන්න, email validation වලට තියෙන Regex patterns ටිකක් සංකීර්ණ වෙන්න පුළුවන්. අපි මෙතන බලන්නේ සරල, පොදු patterns වලට ගැලපෙන එකක් විතරයි.
import re
def validate_email(email):
# Basic email regex pattern
# ^: start of the string
# [a-zA-Z0-9._%+-]+: one or more letters, numbers, or . _ % + -
# @: literal '@'
# [a-zA-Z0-9.-]+: one or more letters, numbers, . or -
# \.: literal '.'
# [a-zA-Z]{2,}: two or more letters for the top-level domain (e.g., com, org, lk)
# $: end of the string
pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
if re.match(pattern, email):
return True
else:
return False
# Test emails
email1 = "[email protected]"
email2 = "invalid-email"
email3 = "[email protected]"
print(f"'{email1}' is valid: {validate_email(email1)}")
print(f"'{email2}' is valid: {validate_email(email2)}")
print(f"'{email3}' is valid: {validate_email(email3)}")
මේ pattern එකේ \ (backslash) එක පාවිච්චි කරලා තියෙන්නේ, . (dot) එක Metacharacter එකක් විදිහට නෙවෙයි, සාමාන්‍ය character එකක් විදිහට ගන්න ඕන නිසා. මේකට කියන්නේ escaping කියලා. ඒ වගේම {2,} කියන්නේ, character එක දෙකක් හෝ ඊට වැඩි ගණනක් තියෙන්න ඕන කියන එකයි.
Regex වලට හුරු වෙමු! (Best Practices සහ Tools)
Regex මුලින් ඉගෙන ගන්නකොට ටිකක් අමාරුයි වගේ දැනෙන්න පුළුවන්. ඒක සාමාන්‍ය දෙයක්! මොකද මේක පොඩි භාෂාවක් වගේ නිසා, හුරු වෙනකල් ටිකක් කල් යනවා. ඒත් බය වෙන්න එපා. පොඩි Tips ටිකක් තියෙනවා:
1. පොඩි Patterns වලින් පටන් ගන්න
හැමදාම ලොකු, සංකීර්ණ Regex pattern එකක් එකපාරටම ලියන්න යන්න එපා. පොඩි පොඩි කොටස් වලට කඩලා, ටිකෙන් ටික ලොකු කරගන්න. උදාහරණයක් විදිහට, email pattern එකට කලින් @ එක විතරක් match කරන එකක් හදාගෙන, ඊට පස්සේ user part එක එකතු කරලා, ඊට පස්සේ domain part එක එකතු කරන්න.
2. Online Regex Testers පාවිච්චි කරන්න
මේවා Regex ඉගෙන ගන්න කෙනෙක්ට තියෙන්නම ඕන Tools. ඔයාලට පුළුවන් ඔයාලගේ Regex pattern එකක් දාලා, ඒක test කරන්න ඕන string එකකුත් දාලා, ඒක කොහොමද match වෙන්නේ කියලා live බලන්න. ගොඩක් useful sites තියෙනවා:
මේවාට ගිහින් බලන්න, ඒකෙන් ඔයාලට Regex syntax එක ගැන හොඳට අවබෝධයක් ගන්න පුළුවන්.
3. Documentation බලන්න
Python වල re module එකට අදාළ Documentation එක ඉතාම හොඳින් ලියලා තියෙනවා. මොකක් හරි Metacharacter එකක් හරි Function එකක් හරි ගැන හරියටම තේරුම් ගන්න ඕන වුණොත්, බලන්න. Google එකේ search කරාම ඕන තරම් resources හොයාගන්න පුළුවන්.
නිගමනය
ඉතින් යාලුවනේ, ඔන්න ඔයාලා අද Regex කියන මේ සුපිරි ටූල් එකේ මූලිකම දේවල් ඉගෙන ගත්තා. මේක මුලින් ටිකක් අමාරු වුණාට, ටිකක් practice කරාම ගොඩක් ලේසි වෙනවා. ඔයාලගේ දෛනික coding වැඩ වලදී මේකෙන් ලොකු කාලයක් ඉතුරු කරගන්න පුළුවන්. Data validation, text parsing, data cleaning වගේ ගොඩක් දේවල් වලට Regex නැතුවම බෑ!
මතක තියාගන්න, හොඳම විදිහ තමයි මේක අත්හදා බලන එක. අදම ගිහින් ඔයාලගේ පොඩි project එකක මේ Regex patterns පාවිච්චි කරලා බලන්න. එතකොට තව හොඳට මේ ගැන ඔලුවට යයි. 🧠
මේ ගැන ඔයාලට තියෙන ප්‍රශ්න, අදහස්, නැත්නම් මේක පාවිච්චි කරපු Interesting Cases තියෙනවා නම්, පහළ Comment Section එකේ දාගෙන යන්න. ඔයාලගේ අදහස් දැනගන්න අපි ආසයි! ⬇️
තවත් අලුත් දෙයක් එක්ක ඉක්මනටම හමුවෙමු! Happy Coding! ✨
