Python වල බලය Unlock කරමු: Operators සහ Expressions ගැනමයි මේ!

ආයුබෝවන් හැමෝටම! කොහොමද ඉතින්, තේ එකක් එහෙම බීලා සෙට් වෙලා ඉන්නවද? අද අපි කතා කරන්න යන්නේ Python programming වල හරිම වැදගත්, ඒ වගේම අපේ කෝඩ් එකේ හැම තැනකම වගේ පාවිච්චි වෙන දෙයක් ගැනයි – ඒ තමයි Operators සහ Expressions.

ඔයාලා දැන් Python ඉගෙන ගන්න පටන් ගත්තා නම්, එහෙම නැත්නම් දැනටමත් ටිකක් දුරට ඉගෙනගෙන තියෙනවා නම්, මේ operators කියන දේ නැතුව කෝඩ් ලියන්නම බෑ. Operators කියන්නේ අර කෝඩ් එකේ 'ගණන් හදන' අය, 'සසඳන' අය, 'තීරණ ගන්න' අය වගේ විවිධ වැඩ කරන පොඩි 'සංකේත' (symbols) ටිකකට. Expressions කියන්නේ මේ operators පාවිච්චි කරලා අපි හදන පොඩි 'වාක්‍ය' වගේ දේවල් වලට. බය වෙන්න එපා, සරලවම කියලා දෙන්නම්කෝ. අද මේ article එක කියවලා ඉවර වෙනකොට ඔයාලාට operators ගැන හොඳ අවබෝධයක් ලැබෙයි කියලා මම විශ්වාස කරනවා.

මොකද, කෝඩ් එකක් ලියනවා කියන්නේ හරියට ගෙයක් හදනවා වගේ වැඩක්. ගඩොල්, සිමෙන්ති නැතුව ගෙයක් හදන්න බැහැනේ. අන්න ඒ වගේ තමයි Python වලදී මේ operators කියන්නේ අපේ කෝඩ් එකේ building blocks වගේ. අපි බලමු මේ අය කවුද කියලා!

ගණන් හදන Arithmetic Operators (ගණිත කර්ම කරන අය)

මූලිකවම, අපි හැමෝටම හුරුපුරුදු ගණිත කර්ම ටික Python වල කරන්න පුළුවන් මේ operators ලා පාවිච්චි කරලා. මේවා නම් ගොඩක්ම සරලයි.

• + (Addition / එකතු කිරීම): අංක දෙකක් එකතු කරනවා.
  x = 10 + 5 # x becomes 15
• - (Subtraction / අඩු කිරීම): අංක දෙකක් අඩු කරනවා.
  y = 20 - 7 # y becomes 13
• * (Multiplication / ගුණ කිරීම): අංක දෙකක් ගුණ කරනවා.
  z = 4 * 6 # z becomes 24
• / (Division / බෙදීම): අංක දෙකක් බෙදනවා. මතක තියාගන්න, මේකෙන් අපිට ලැබෙන්නේ float (දශම) අගයක්.
  result = 25 / 4 # result becomes 6.25
• % (Modulus / ඉතිරිය): බෙදීමකදී ඉතිරි වෙන අගය ගන්න මේක පාවිච්චි කරනවා.
  remainder = 10 % 3 # remainder becomes 1 (10 / 3 = 3, remainder 1)
• // (Floor Division / පූර්ණ බෙදීම): මේකත් බෙදීමක් තමයි, හැබැයි මේකෙන් ලැබෙන්නේ පූර්ණ සංඛ්‍යාව විතරයි, දශම කොටස අයින් කරනවා.
  floor_div = 25 // 4 # floor_div becomes 6
• ** (Exponentiation / බලය): එක අංකයක්, තව අංකයක බලය ගන්න පාවිච්චි කරනවා.
  power = 2 ** 3 # power becomes 8 (2*2*2)

Example:

num1 = 50
num2 = 10

sum_val = num1 + num2
print(f"එකතුව: {sum_val}") # Output: එකතුව: 60

diff_val = num1 - num2
print(f"වෙනස: {diff_val}") # Output: වෙනස: 40

prod_val = num1 * num2
print(f"ගුණිතය: {prod_val}") # Output: ගුණිතය: 500

div_val = num1 / num2
print(f"බෙදීමේ ප්‍රතිඵලය (දශම සහිතව): {div_val}") # Output: බෙදීමේ ප්‍රතිඵලය (දශම සහිතව): 5.0

mod_val = num1 % 7
print(f"7 න් බෙදූ විට ඉතිරිය: {mod_val}") # Output: 7 න් බෙදූ විට ඉතිරිය: 1

floor_div_val = num1 // 7
print(f"7 න් බෙදූ විට පූර්ණ සංඛ්‍යා කොටස: {floor_div_val}") # Output: 7 න් බෙදූ විට පූර්ණ සංඛ්‍යා කොටස: 7

pow_val = 2 ** 4
print(f"2 න් 4 වෙනි බලය: {pow_val}") # Output: 2 න් 4 වෙනි බලය: 16

දැක්කනේ වැඩේ? මේවා අපි සාමාන්‍යයෙන් ගණිතයේදී පාවිච්චි කරන ඒවාම තමයි.

සසඳන Comparison Operators (සසඳන ඔපරේටර්ස්ලා)

දැන් අපි බලමු අගයන් දෙකක් සංසන්දනය කරන්නේ කොහොමද කියලා. මේ operators ලා වැඩේදී අපිට Boolean (True / False) අගයක් තමයි ලැබෙන්නේ.

• == (Equal to / සමානද?): අගයන් දෙකක් සමානද කියලා බලනවා.
  print(5 == 5) # True
print(5 == 10) # False
• != (Not equal to / අසමානද?): අගයන් දෙකක් අසමානද කියලා බලනවා.
  print(5 != 10) # True
print(5 != 5) # False
• > (Greater than / වඩා විශාලද?): වම් පැත්තේ අගය දකුණු පැත්තේ අගයට වඩා විශාලද කියලා බලනවා.
  print(10 > 5) # True
• < (Less than / වඩා කුඩාද?): වම් පැත්තේ අගය දකුණු පැත්තේ අගයට වඩා කුඩාද කියලා බලනවා.
  print(5 < 10) # True
• >= (Greater than or equal to / වඩා විශාල හෝ සමානද?): වම් පැත්තේ අගය දකුණු පැත්තේ අගයට වඩා විශාලද නැත්නම් සමානද කියලා බලනවා.
  print(10 >= 10) # True
• <= (Less than or equal to / වඩා කුඩා හෝ සමානද?): වම් පැත්තේ අගය දකුණු පැත්තේ අගයට වඩා කුඩාද නැත්නම් සමානද කියලා බලනවා.
  print(5 <= 5) # True

Example:

age = 18
has_license = True

# වයස 18ට වඩා වැඩිද නැත්නම් සමානද?
print(f"වයස 18ට වඩා වැඩි හෝ සමානද?: {age >= 18}") # Output: True

# License එක තියෙනවද?
print(f"License එක තියෙනවද?: {has_license == True}") # Output: True (or simply has_license)

# නමක් සහ වයසක් සමානද?
name1 = "Kasun"
name2 = "kasun"
print(f"නම් දෙක සමානද?: {name1 == name2}") # Output: False (Case sensitive)

මේවා කොහොමද if statements වගේ තැන්වලදී පාවිච්චි වෙන්නේ කියලා පස්සේ බලමු, දැනට මේවායේ වැඩේ මොකක්ද කියලා තේරුම් ගන්න. මතක තියාගන්න, = කියන්නේ අගයක් assign කරන එක, == කියන්නේ සමානද කියලා බලන එක.

තර්කානුකූල වැඩ කරන Logical Operators (තීරණ ගන්න අය)

මේ operators ලා පාවිච්චි කරන්නේ Boolean values (True / False) කිහිපයක් එකතු කරලා තනි Boolean අගයක් ගන්න. මේවා Conditionals (if statements) එක්ක තමයි වැඩියෙන්ම පාවිච්චි වෙන්නේ.

• and (සහ): දෙපැත්තේම තියෙන condition දෙකම True නම් විතරයි මේක True වෙන්නේ. නැත්නම් False.
  print(True and True) # True
print(True and False) # False
• or (හෝ): දෙපැත්තේ තියෙන condition දෙකෙන් එකක් හරි True නම්, මේක True වෙනවා. දෙකම False නම් විතරයි False වෙන්නේ.
  print(True or False) # True
print(False or False) # False
• not (නැහැ / ප්‍රතිවිරුද්ධ): මේකෙන් කරන්නේ Boolean අගයක ප්‍රතිවිරුද්ධ දේ දෙන එක. True නම් False, False නම් True.
  print(not True) # False
print(not False) # True

Example:

age = 20
is_student = True
has_discount_card = False

# වයස 18ට වඩා වැඩිද AND ශිෂ්‍යයෙක්ද?
can_enter_party = (age >= 18 and is_student)
print(f"Party එකට එන්න පුළුවන්ද (වයස සහ ශිෂ්‍ය)? {can_enter_party}") # Output: Party එකට එන්න පුළුවන්ද (වයස සහ ශිෂ්‍ය)? True

# ශිෂ්‍යයෙක්ද OR discount card එකක් තියෙනවද?
get_special_price = (is_student or has_discount_card)
print(f"විශේෂ මිලක් ගන්න පුළුවන්ද? {get_special_price}") # Output: විශේෂ මිලක් ගන්න පුළුවන්ද? True

# discount card එකක් නැද්ද?
no_discount = not has_discount_card
print(f"Discount එකක් නෑ කියන්නේ ඇත්තද?: {no_discount}") # Output: Discount එකක් නෑ කියන්නේ ඇත්තද?: True

මේ operators ලා පාවිච්චි කරලා අපිට සංකීර්ණ තීරණ ගන්න පුළුවන්. ටිකක් හිතලා බැලුවොත් මේවායේ Truth Tables (ඒ කියන්නේ මොනවට මොනවද ගැලපෙන්නේ කියලා) තේරුම් ගන්න පුළුවන්.

අගයන් දෙන Assignment Operators (අගයන් දෙන ඔපරේටර්ස්ලා)

දැන් අපි Variable එකකට අගයක් දාන්නේ කොහොමද කියලා බලමු. මේක තනිකරම = symbol එකෙන් කරනවා. ඒ වගේම කෙටි ක්‍රමත් තියෙනවා.

• = (Assignment): දකුණු පැත්තේ තියෙන අගය වම් පැත්තේ තියෙන Variable එකට දෙනවා.
  my_num = 10
• += (Add and assign): Variable එකක දැනට තියෙන අගයට අලුත් අගයක් එකතු කරලා ඒ Variable එකටම assign කරනවා.
  x = 5; x += 3 # Same as x = x + 3; x becomes 8
• -= (Subtract and assign): Variable එකක දැනට තියෙන අගයෙන් අලුත් අගයක් අඩු කරලා ඒ Variable එකටම assign කරනවා.
  y = 10; y -= 4 # Same as y = y - 4; y becomes 6
• *= (Multiply and assign): Variable එකක දැනට තියෙන අගය අලුත් අගයකින් ගුණ කරලා ඒ Variable එකටම assign කරනවා.
  z = 3; z *= 5 # Same as z = z * 5; z becomes 15
• /= (Divide and assign): Variable එකක දැනට තියෙන අගය අලුත් අගයකින් බෙදලා ඒ Variable එකටම assign කරනවා.
  a = 20; a /= 4 # Same as a = a / 4; a becomes 5.0
• %= (Modulus and assign): Variable එකක දැනට තියෙන අගය අලුත් අගයකින් බෙදලා ඉතිරි වන අගය ඒ Variable එකටම assign කරනවා.
  b = 17; b %= 5 # Same as b = b % 5; b becomes 2
• **= (Exponent and assign): Variable එකක දැනට තියෙන අගය අලුත් අගයක බලයට නංවලා ඒ Variable එකටම assign කරනවා.
  c = 2; c **= 3 # Same as c = c ** 3; c becomes 8

Example:

counter = 10
print(f"මුලින්ම: {counter}") # Output: මුලින්ම: 10

counter += 5 # counter = 10 + 5
print(f"5ක් එකතු උනාට පස්සේ: {counter}") # Output: 5ක් එකතු උනාට පස්සේ: 15

counter *= 2 # counter = 15 * 2
print(f"දෙකෙන් ගුණ කරාට පස්සේ: {counter}") # Output: දෙකෙන් ගුණ කරාට පස්සේ: 30

counter /= 3 # counter = 30 / 3
print(f"තුනෙන් බෙදුවාම: {counter}") # Output: තුනෙන් බෙදුවාම: 10.0

මේ කෙටි ක්‍රම කෝඩ් එක ලියනකොට අපිට ගොඩක් වෙලාවට පහසුවක් වෙනවා. ඒ වගේම කෝඩ් එක කියවන්නත් ලේසියි.

විශේෂ Identity සහ Membership Operators (විශේෂ ඔපරේටර්ස්ලා)

මේ operators ලා පොඩ්ඩක් වෙනස් විදිහේ වැඩ ටිකක් තමයි කරන්නේ. මේවා ඔයාට ටිකක් advanced concepts වලදී වැදගත් වෙයි, නමුත් මූලික අවබෝධයක් තියාගන්න එක හොඳයි.

Identity Operators (එකම වස්තුවද?): is සහ is not

මේවා පාවිච්චි කරන්නේ Variables දෙකක් එකම object එකට (memory location එකට) refer කරනවද කියලා බලන්න මිසක්, අගයන් සමානද කියලා බලන්න නෙවෙයි. == එකෙන් අගය බලනවා, is එකෙන් object එකම බලනවා.

• is: Variable දෙකක් එකම object එකට refer කරනවද?
  a = [1, 2, 3]; b = a; print(a is b) # True (b refers to the same list as a)
c = [1, 2, 3]; d = [1, 2, 3]; print(c is d) # False (d is a new list object, even if values are same)
• is not: Variable දෙකක් එකම object එකට refer කරන්නේ නැද්ද?
  print(c is not d) # True

Example:

list1 = [10, 20, 30]
list2 = list1 # list2 now points to the SAME object as list1
list3 = [10, 20, 30] # list3 is a NEW object with same values

print(f"list1 සහ list2 එකම object එකද?: {list1 is list2}") # Output: True
print(f"list1 සහ list3 එකම object එකද?: {list1 is list3}") # Output: False (අගයන් සමාන උනත්, objects දෙකක්)

print(f"list1 සහ list3 අගයන්ගෙන් සමානද?: {list1 == list3}") # Output: True (අගයන් නම් සමානයි)

මේ is operator එක ගොඩක් වෙලාවට None (කිසිම අගයක් නැති බව හඟවන විශේෂ අගයක්) වගේ දේවල් චෙක් කරන්න පාවිච්චි කරනවා. if variable is None: වගේ.

Membership Operators (කොටසක්ද?): in සහ not in

මේවා පාවිච්චි කරන්නේ යම්කිසි අගයක්, String එකක්, List එකක්, Tuple එකක්, Dictionary එකක් වගේ Collection එකක් ඇතුළේ තියෙනවද නැද්ද කියලා බලන්න.

• in: අගය Collection එක ඇතුලේ තියෙනවද?
  print('a' in 'apple') # True
print(3 in [1, 2, 3, 4]) # True
• not in: අගය Collection එක ඇතුලේ නැද්ද?
  print('z' not in 'apple') # True

Example:

my_fruits = ["apple", "banana", "cherry"]
my_text = "Hello World"

# 'banana' තියෙනවද my_fruits list එකේ?
print(f"'banana' fruit list එකේ තියෙනවද?: {'banana' in my_fruits}") # Output: True

# 'mango' තියෙනවද my_fruits list එකේ?
print(f"'mango' fruit list එකේ තියෙනවද?: {'mango' in my_fruits}") # Output: False

# 'World' කියන වචනය my_text එකේ තියෙනවද?
print(f"'World' වචනය text එකේ තියෙනවද?: {'World' in my_text}") # Output: True

# 'X' අකුර my_text එකේ නැද්ද?
print(f"'X' අකුර text එකේ නැද්ද?: {'X' not in my_text}") # Output: True

මේ operators ලාත් ගොඩක් ප්‍රයෝජනවත්, විශේෂයෙන්ම දත්ත විශාල ප්‍රමාණයක් එක්ක වැඩ කරනකොට.

කාටද මුලින්ම වැඩේ? Operator Precedence

දැන් අපි මේ operators ලා ගැන ඉගෙන ගත්තනේ. හැබැයි මේ හැමෝම එකම Expression එකකදී ආවොත්, කාටද මුලින්ම වැඩේ ලැබෙන්නේ? මේක තමයි Operator Precedence කියන්නේ.

හරියට ගණිතයේදී BODMAS (හෝ PEMDAS) වගේ තමයි. Python වලත් Operators ලාට වැඩ කරන පිළිවෙළක් තියෙනවා. වැඩිම precedence තියෙන operator ට තමයි මුලින්ම වැඩේ ලැබෙන්නේ.

සාමාන්‍යයෙන් පිළිවෙළ මෙහෙමයි (උඩ ඉඳන් පහළට):

1. 괄호 (Parentheses) (): මේවාට තමයි ඉහළම ප්‍රමුඛතාවය. වරහන් ඇතුලේ තියෙන දේවල් මුලින්ම solve වෙනවා.
2. Exponentiation **
3. Multiplication, Division, Modulus, Floor Division *, /, %, //: මේවාට එකම precedence එකක් තියෙනවා. වම් පැත්තේ ඉඳන් දකුණු පැත්තට යනවා.
4. Addition and Subtraction +, -: මේවාටත් එකම precedence එකක් තියෙනවා. වම් පැත්තේ ඉඳන් දකුණු පැත්තට යනවා.
5. Comparison Operators ==, !=, >, <, >=, <=
6. Identity Operators is, is not
7. Membership Operators in, not in
8. Logical Operators not, and, or: not ට මුල් තැන, ඊට පස්සේ and, අන්තිමට or.

Example:

result = 10 + 5 * 2 # මොකද වෙන්නේ?
print(result)

මේකේ Output එක 30ද, 20ද? Python ගණිත නීති වලට අනුව, * (multiplication) එකට + (addition) එකට වඩා වැඩි precedence එකක් තියෙනවා. ඒ නිසා මුලින්ම 5 * 2 (10) ගණනය වෙනවා, ඊට පස්සේ 10 + 10 (20) ගණනය වෙනවා.

Output: 20

result_with_parentheses = (10 + 5) * 2
print(result_with_parentheses)

මේකේ Output එක 30 වෙයි. මොකද () වරහන් ඇතුලේ තියෙන එකට මුල් තැන ලැබෙනවා. (10 + 5) (15) මුලින් ගණනය වෙනවා, ඊට පස්සේ 15 * 2 (30).

Best Practice: වරහන් පාවිච්චි කරන්න!

ඔයාගේ කෝඩ් එකේ ගණනය කිරීම් ටිකක් සංකීර්ණ නම්, operator precedence එක ගැන හිත හිත ඉන්නවා වෙනුවට වරහන් () පාවිච්චි කරන එක තමයි හොඳම දේ. එතකොට කෝඩ් එක කියවන අයට (ඔයාට වුණත් මාස ගානකට පස්සේ) පැහැදිලිව තේරෙනවා මොකක්ද මුලින්ම වෙන්න ඕනේ කියලා. මේකෙන් වැරදි අඩු කරගන්න පුළුවන්. ඒක තමයි හොඳම පුරුද්ද.

අපිම කරලා බලමු! Practical Examples & Tips

දැන් අපි ඉගෙන ගත්ත දේවල් ටිකක් ප්‍රැක්ටිකල් විදිහට පාවිච්චි කරලා බලමු. හිතන්න, අපිට ශිෂ්‍යයෙක්ගේ ලකුණු මත පදනම්ව, එයා විභාගය පාස්ද ෆේල්ද කියලා බලන්න ඕන කියලා. ඒ වගේම එයාට ඩිස්කවුන්ට් එකක් හම්බවෙනවද කියලා බලමු.

student_marks = 75
passing_marks = 50
attendance_percentage = 85
required_attendance = 75
has_scholarship = True

# 1. ශිෂ්‍යයා විභාගය පාස්ද? (Comparison Operator)
# ලකුණු passing marks වලට වඩා වැඩි හෝ සමාන වෙන්න ඕනේ.
is_passed = (student_marks >= passing_marks)
print(f"විභාගය පාස්ද?: {is_passed}")

# 2. ශිෂ්‍යයාට ඩිස්කවුන්ට් එකක් හම්බවෙනවද? (Logical Operators)
# Discount එකක් ලැබෙන්නේ: (පාස් වෙලා නම් AND attendance 75%ට වැඩිනම්) OR scholarship තියෙනවා නම්.

# මුලින්ම attendance condition එක බලමු
is_good_attendance = (attendance_percentage >= required_attendance)

# දැන් discount condition එක.
# වරහන් පාවිච්චි කරලා Precedence එක පැහැදිලි කරමු.
can_get_discount = (is_passed and is_good_attendance) or has_scholarship

print(f"හොඳ attendance ද?: {is_good_attendance}")
print(f"Discount එකක් ගන්න පුළුවන්ද?: {can_get_discount}")

# මෙතන (is_passed and is_good_attendance) මුලින්ම ගණනය වෙනවා, ඊට පස්සේ ඒ result එක has_scholarship එක්ක 'or' වෙනවා.
# අපේ උදාහරණයට:
# (True and True) or True
# (True) or True
# True

Output:

විභාගය පාස්ද?: True
හොඳ attendance ද?: True
Discount එකක් ගන්න පුළුවන්ද?: True

දැක්කනේ මේ operators ලා කොච්චර ප්‍රයෝජනවත්ද කියලා? අපිට ඕනෑම ආකාරයක තීරණයක් ගන්න මේවා පාවිච්චි කරන්න පුළුවන්.

Troubleshooting: මතක තියාගන්න ඕන දේවල්

• Precedence Confusion (ප්‍රමුඛතා අවුල්): සමහර වෙලාවට අපිට හිතෙනවා එක විදිහකට, හැබැයි කෝඩ් එක වැඩ කරන්නේ වෙන විදිහකට. මේක වෙන්නේ operator precedence එක හරියට තේරුම් නොගත්තාමයි. මේක වළක්වා ගන්න හොඳම දේ තමයි හැමතිස්සෙම වරහන් () පාවිච්චි කරන එක. ඒක කෝඩ් එක කියවන්න පහසු කරනවා වගේම වැරදි අඩු කරනවා.
• = vs. == (Assign කරන එකද, Compare කරන එකද?): මේක Python වල beginner ලා කරන ප්‍රධානම වැරැද්දක්. = කියන්නේ Variable එකකට අගයක් දාන එක (assignment), == කියන්නේ අගයන් දෙකක් සමානද කියලා බලන එක (comparison). හොඳට මතක තියාගන්න.
• Data Types (දත්ත වර්ග): operators ලා හැම වෙලාවෙම හැම data type එකක් එක්කම වැඩ කරන්නේ නෑ. උදාහරණයක් විදිහට, ඔයාට Number එකක් String එකක් එක්ක කෙලින්ම add කරන්න බැහැ. 10 + "5" මේක error එකක් දෙයි.

අවසාන වශයෙන්… (Wrapping Up)

මොකද හිතෙන්නේ? Python Operators සහ Expressions ගැන හොඳ අදහසක් ලැබුණාද? මේවා තමයි Python programming වල මූලිකම දේවල්. මේවා හොඳට තේරුම් ගත්තා නම්, ඕනෑම සංකීර්ණ program එකක් ලියන්න ඔයාට හොඳ පදනමක් තියෙනවා.

වැදගත්ම දේ තමයි පුරුදු වීම (Practice). ඔයාගේම පොඩි පොඩි කෝඩ් කෑලි ලියලා මේ operators ලා පාවිච්චි කරලා බලන්න. Calculator එකක් හදන්න බලන්න, නැත්නම් පොඩි game එකක කොන්දේසි ලියලා බලන්න. එතකොට මේවා ගැන තියෙන දැනුම තවත් වැඩි කරගන්න පුළුවන්.

මම හිතනවා මේ article එක ඔයාලට වැදගත් වෙන්න ඇති කියලා. මොකද හිතෙන්නේ? තව මොනවා හරි දැනගන්න ඕන නම්, එහෙම නැත්නම් මේකේ මොනවා හරි පැහැදිලි නැත්නම් comment section එකේ අහන්න. පුළුවන් ඉක්මනටම මම උත්තර දෙන්නම්.

ඊළඟ Python SC Guide එකෙන් හම්බවෙමු! සුභ දවසක්!