By Thisara Priyamal — 18 Jul 2025

Regex Basics Sinhala Tutorial | Python Regular Expressions SC Guide

හැඳින්වීම: Text රටා හඳුනාගැනීමේ බලය (The Power of Text Pattern Recognition)

ඔබ Software Engineering ලෝකයේ ඉන්න කෙනෙක් නම්, නිතරම වගේ Strings, Text Files, Data Validations වගේ දේවල් එක්ක වැඩ කරන්න වෙනවා නේද? Data Extraction, String Replacement, Input Validation වගේ කාර්යයන් වලදී අපිට නිශ්චිත රටාවන් (patterns) හඳුනාගන්න අවශ්‍ය වෙනවා. උදාහරණයක් විදියට, ඊමේල් ලිපින, දුරකථන අංක, නැත්නම් යම් විශේෂ වචන මාලාවක් වැනි දේවල්. මේ වගේ වෙලාවට අපිට ඕන කරන විශේෂ Patterns (සැකිලි) හොයාගන්න, වෙනස් කරන්න, නැත්නම් යම් තොරතුරක් වලංගුද කියලා බලන්න තියෙන බලගතුම Tools එකක් තමයි Regular Expressions (Regex) කියන්නේ.

මේ Regex කියන එක සමහර අයට ටිකක් බය හිතෙන, තේරුම් ගන්න අමාරු දෙයක් වුණත්, ඇත්තටම මේක හරියට තේරුම් ගත්තොත් ඔබේ වැඩ ගොඩක් පහසු කරගන්න පුළුවන්. මේ Guide එකෙන් අපි Regex වල Basics ටික හොඳටම තේරුම් අරගෙන, Python එක්ක කොහොමද මේවා පාවිච්චි කරන්නේ කියලා බලමු. ඔයාලා හැමෝම මේ ගමනට සූදානම්ද?

Regex කියන්නේ මොකක්ද? (What is Regex?)

සරලව කිව්වොත්, Regex කියන්නේ Text එකක් ඇතුළේ තියෙන විවිධ Patterns විස්තර කරන්න පාවිච්චි කරන විශේෂ භාෂාවක්. ඒ කියන්නේ, 'මේ Text එකේ අකුරු 3ක් තියෙන වචන විතරක් හොයන්න' නැත්නම් 'මෙතන තියෙන Email Addresses හැම එකක්ම තෝරගන්න' වගේ දේවල් කරන්න මේ භාෂාවෙන් අපිට උපදෙස් දෙන්න පුළුවන්. Imagine for a moment that you're searching for all the lines in a large log file that contain an IP address. Instead of manually sifting through thousands of lines, a Regex pattern can do it in milliseconds.

ගොඩක් Programming Languages වල Regex support කරනවා. Python වලට තියෙනවා re module එක. මේක තමයි අපිට මේ වැඩේට උදව් කරන්නේ.

import re

text = "Hello World! Today is 2024-07-26."
pattern = r"Today"

match = re.search(pattern, text)

if match:
    print("Pattern found!") # Output: Pattern found!
else:
    print("Pattern not found.")

මේ උදාහරණයේදී අපි re module එක import කරලා, 'Today' කියන Pattern එක 'text' කියන String එක ඇතුළේ තියෙනවද කියලා re.search() function එකෙන් බැලුවා.

මූලික Metacharacters: Regex ගොඩනගන අකුරු (Basic Metacharacters: The Building Blocks of Regex)

Regex වලදි අපිට Patterns හදන්න උදව් කරන විශේෂ අකුරු වගයක් තියෙනවා. මේවා තමයි Metacharacters කියන්නේ. මේවා තේරුම් ගත්තොත් Regex වලින් කරන්න පුළුවන් දේවල් අපිට හොඳටම පැහැදිලි වෙයි.

. (Dot - ඕනෑම අකුරක්): ඕනෑම තනි character එකක් (new line character එක හැර) match කරනවා.
* (Asterisk - බිංදුවක් හෝ ඊට වැඩි): ඊට කලින් තියෙන character එක බිංදුවක් හෝ ඊට වැඩි වාර ගණනක් ආවොත් match කරනවා.
+ (Plus - එකක් හෝ ඊට වැඩි): ඊට කලින් තියෙන character එක එකක් හෝ ඊට වැඩි වාර ගණනක් ආවොත් match කරනවා.
? (Question Mark - බිංදුවක් හෝ එකක්): ඊට කලින් තියෙන character එක බිංදුවක් හෝ එක වතාවක් ආවොත් match කරනවා.
[] (Character Sets - අක්ෂර කට්ටල): වරහන් ඇතුළේ තියෙන ඕනෑම character එකක් match කරනවා.
^ (Caret - ආරම්භය / Negation): String එකක ආරම්භය match කරනවා. Character Set එකක් ඇතුළේ ([^...]) තිබුණොත්, ඒ character Set එක ඇතුළේ නැති ඕනෑම character එකක් match කරනවා.
$ (Dollar - අවසානය): String එකක අවසානය match කරනවා.

import re

print(re.search(r"World$", "Hello World")) # <re.Match object; span=(6, 11), match='World'>
print(re.search(r"Hello$", "Hello World")) # None (Hello is not at the end)

import re

print(re.search(r"^Hello", "Hello World")) # <re.Match object; span=(0, 5), match='Hello'>
print(re.search(r"^World", "Hello World")) # None (World is not at the start)
print(re.findall(r"[^aeiou]", "hello world")) # ['h', 'l', 'l', ' ', 'w', 'r', 'l', 'd'] (non-vowels)

import re

print(re.search(r"[aeiou]", "hello")) # <re.Match object; span=(1, 2), match='e'>
print(re.findall(r"[0-9]", "The year is 2024")) # ['2', '0', '2', '4'] (matches any digit)
print(re.findall(r"[a-zA-Z]", "Hello 123 World")) # Matches any uppercase or lowercase letter

import re

print(re.search(r"colou?r", "color"))  # <re.Match object; span=(0, 5), match='color'>
print(re.search(r"colou?r", "colour")) # <re.Match object; span=(0, 6), match='colour'>
print(re.search(r"colou?r", "coloor")) # None

import re

print(re.search(r"ab+c", "abc"))  # <re.Match object; span=(0, 3), match='abc'>
print(re.search(r"ab+c", "abbc")) # <re.Match object; span=(0, 4), match='abbc'>
print(re.search(r"ab+c", "ac"))   # None (b must appear at least once)

import re

print(re.search(r"ab*c", "ac"))   # <re.Match object; span=(0, 2), match='ac'> (b zero times)
print(re.search(r"ab*c", "abc"))  # <re.Match object; span=(0, 3), match='abc'> (b one time)
print(re.search(r"ab*c", "abbc")) # <re.Match object; span=(0, 4), match='abbc'> (b two times)

import re

print(re.search(r"c.t", "cat"))   # <re.Match object; span=(0, 3), match='cat'>
print(re.search(r"c.t", "cot"))   # <re.Match object; span=(0, 3), match='cot'>
print(re.search(r"c.t", "ct"))    # None

Python වල Regex භාවිතය: search vs. match (Using Regex in Python: search vs. match)

Python වල re module එක හරහා Regex පාවිච්චි කරන විදිය බලමු. විශේෂයෙන්ම අපි re.search() සහ re.match() කියන Functions දෙක ගැන කතා කරමු. මේ දෙකේ පොඩි වෙනසක් තියෙනවා, ඒක හරියටම තේරුම් ගැනීම වැදගත්.

`re.search(pattern, string, flags=0)`

මේ search() function එක String එකේ ඕනෑම තැනක Pattern එක තියෙනවද කියලා බලනවා. තිබුණොත්, පළමු Match එකට අදාල Match object එකක් return කරනවා. නැත්නම් None return කරනවා.

import re

text = "My phone number is 0771234567. Call me!"
pattern = r"077\d{7}" # \d means any digit (0-9). {7} means exactly 7 digits.

match = re.search(pattern, text)

if match:
    print(f"Found: {match.group()}") # Output: Found: 0771234567
else:
    print("Pattern not found.")

`re.match(pattern, string, flags=0)`

මේ match() function එක String එකේ මුල ඉඳලම (beginning of the string) Pattern එක match වෙනවද කියලා බලනවා. Match වුණොත් Match object එකක් return කරනවා, නැත්නම් None return කරනවා. search() වගේ String එකේ ඕනෑම තැනක බලන්නේ නැහැ.

import re

text1 = "Hello World!"
text2 = "Greetings, Hello World!"

# Pattern for 'Hello'
pattern = r"Hello"

match1 = re.match(pattern, text1)
match2 = re.match(pattern, text2)

if match1:
    print(f"Match 1 found: {match1.group()}") # Output: Match 1 found: Hello
else:
    print("Match 1 not found.")

if match2:
    print(f"Match 2 found: {match2.group()}")
else:
    print("Match 2 not found.") # Output: Match 2 not found.

දැන් ඔබට search() සහ match() අතර වෙනස පැහැදිලි ඇති. search() නම් String එක ඇතුලේ ඕනෑම තැනක Pattern එකක් හොයනවා. match() නම් String එකේ මුල ඉඳලම Pattern එකක් හොයනවා.

Email Address එකක් Validate කරමුද? (Let's Validate an Email Address?)

අපි දැන් පොඩි Practical Example එකක් බලමු. Email Address එකක් Basic Level එකකින් Validate කරන විදිය. මතක තියාගන්න, Email Validation වලට Full-proof Regex Pattern එකක් හදන එක ගොඩක් සංකීර්ණයි. ඒකට RFC Standards වගේ ගොඩක් දේවල් බලපානවා. හැබැයි, මෙතනින් අපි සරලම Pattern එකක් බලමු.

import re

def validate_email_basic(email):
    # A very basic regex for email validation
    # It checks for: characters, then @, then characters, then dot, then characters
    # e.g., [email protected]
    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 cases
print(f"[email protected] is valid: {validate_email_basic('[email protected]')}") # True
print(f"[email protected] is valid: {validate_email_basic('[email protected]')}") # True
print(f"invalid-email is valid: {validate_email_basic('invalid-email')}") # False
print(f"@domain.com is valid: {validate_email_basic('@domain.com')}") # False
print(f"user@domain is valid: {validate_email_basic('user@domain')}") # False
print(f"[email protected] is valid: {validate_email_basic('[email protected]')}") # False

මේ pattern එක ගැන ටිකක් බලමු:

^: String එකේ ආරම්භය.
[a-zA-Z0-9._%+-]+: User Name කොටස. අකුරු (කුඩා/ලොකු), ඉලක්කම්, ., _, %, +, - යන Character එකක් හෝ ඊට වැඩි ගණනක්.
@: අනිවාර්යයෙන්ම @ Symbol එකක් තියෙන්න ඕනේ.
[a-zA-Z0-9.-]+: Domain Name කොටස. අකුරු, ඉලක්කම්, ., - යන Character එකක් හෝ ඊට වැඩි ගණනක්.
\.[a-zA-Z]{2,}: Top-Level Domain (TLD) කොටස. . (අපි \. කියලා ලිව්වේ Dot එක Metacharacter එකක් නිසා, සාමාන්‍ය Dot එකක් match කරන්න) පස්සේ අකුරු 2ක් හෝ ඊට වැඩි ගණනක් තියෙන්න ඕනේ (උදා: com, org, lk).
$: String එකේ අවසානය.

Regex වලට බය වෙන්න එපා! (Don't be Afraid of Regex!)

Regex කියන්නේ ටිකක් Syntax එක සංකීර්ණ දෙයක් බව ඇත්ත. මුලින්ම බැලුවම තේරුම් ගන්න අමාරු වුණාට, Practice කරනකොට මේක හරිම ලේසියි. මෙන්න පොඩි Tips ටිකක්:

Online Regex Testers පාවිච්චි කරන්න: regex101.com, regexr.com වගේ Websites වලට ගිහින් ඔයාගේ Patterns Test කරන්න පුළුවන්. මේවා හරිම ප්‍රයෝජනවත්. මේවායේදී ඔයාගේ Pattern එක Live එකේදී මොනවද Match කරන්නේ කියලා පැහැදිලිව පෙන්නනවා.
සරලව පටන් ගන්න: මුලින්ම පොඩි Patterns වලින් පටන් අරගෙන, ටිකෙන් ටික සංකීර්ණ කරන්න. එක පාරටම ලොකු Pattern එකක් හදන්න යන්න එපා.
Pattern එක කොටස් වලට කඩන්න: ලොකු Pattern එකක් හදනකොට, ඒක පොඩි පොඩි කොටස් වලට කඩලා හදන්න. ඊට පස්සේ ඒවා එකට එකතු කරන්න.
Documentation කියවන්න: Python වල re module Documentation එක හොඳට කියවන්න. ඒකේ ගොඩක් ප්‍රයෝජනවත් Metacharacters සහ Functions ගැන තියෙනවා.

නිගමනය (Conclusion)

මේ Guide එකෙන් අපි Regular Expressions වල Basics, ඒ කියන්නේ Metacharacters, Python වල re module එක පාවිච්චි කරන විදිය, re.search() සහ re.match() අතර වෙනස, වගේම සරල Email validation එකක් කරන විදියත් ඉගෙන ගත්තා. Regex කියන්නේ Text Processing වලදී ගොඩක් බලගතු Tool එකක්. මේක තේරුම් අරගෙන Practice කරනකොට ඔබේ Software Development වැඩ ගොඩක් පහසු කරගන්න පුළුවන්. Data Cleaning, Log Parsing, Web Scraping වගේ දේවල් වලට මේක අත්‍යවශ්‍යයි.

ඔයාටත් මේ Regex ගැන අලුත් අදහසක් ආවනම්, මේක ඔයාගේ Project එකක පාවිච්චි කරලා බලන්න. ඔයාගේ අත්දැකීම් පහල Comment Section එකේ අපිත් එක්ක බෙදාගන්න අමතක කරන්න එපා! Regular Expressions කියන අලුත් ලෝකය අත්හදා බලන්න ඔබට Good Luck!