පසුගිය ලිපියෙන් අපි **විචල්යයන් (Variables)** ගැන ඉගෙන ගත්තා. විචල්යයන් යනු දත්ත ගබඩා කරන බඳුන් වගෙයි. අද අපි කතා කරන්නේ programming වල තවත් අතිශය වැදගත් සංකල්පයක් වන **ලූප් (Loops)** ගැන. ලූප් එකක් කියන්නේ පරිගණකයට යම් කාර්යයක් කිහිප වතාවක් නැවත නැවතත් කරන්නට දෙන උපදෙසක්.

හිතන්න, ඔබට "Hello, World!" කියලා 100 පාරක් screen එකේ print කරන්න ඕන වුණා කියලා. ඔබ මොකක්ද කරන්නේ? `print("Hello, World!")` කියන line එක 100 පාරක් copy-paste කරනවද? ඒක කරන්න පුළුවන්, ඒත් ඒක හරිම වෙහෙසකර සහ අකාර්යක්ෂම වැඩක්. 1000 පාරක් print කරන්න වුනොත්? අන්න ඒ වගේ වෙලාවට තමයි ලූප්ස් අපේ උදව්වට එන්නේ. පේළි කිහිපයකින් අපිට ඒ කාර්යය ඉතා පහසුවෙන් කරගන්න පුළුවන්.

මේ ලිපියෙන් අපි ගැඹුරින් අධ්‍යනය කරන්නේ:

• ලූප් එකක් කියන්නේ සරලවම මොකක්ද සහ එහි ප්‍රධාන කොටස්.
• Programming වලදී ලූප්ස් නැතුවම බැරි ඇයි?
• ප්‍රධාන ලූප් වර්ග දෙක වන For Loop සහ While Loop අතර වෙනස.
• ලූප් පාලනය කරන Break සහ Continue ප්‍රකාශන.
• එකක් තුළ තවත් ලූපයක් ලියන Nested Loops සංකල්පය.
• ප්‍රායෝගික උදාහරණ සහ බහුලව සිදුවන වැරදි.

---

ලූප් (Loop) එකක් යනු සරලවම කුමක්ද? 🤔

සරලවම කිව්වොත්, **ලූපයක් යනු යම්කිසි කොන්දේසියක් (condition) සත්‍යව පවතින තාක්, කේත කොටසක් (block of code) නැවත නැවතත් ක්‍රියාත්මක (execute) කිරීමේ ක්‍රියාවලියයි.** මේකට **පුනරාවර්තනය (Iteration)** කියලත් කියනවා. ලූපයේ එක වටයක් යනු එක් iteration එකකි.

මූලික සංකල්පය: පුනරාවර්තනය (The Core Concept: Repetition)

එදිනෙදා ජීවිතයේදීත් අපි නොදැනුවත්වම ලූප්ස් භාවිතා කරනවා.

• ධාවන පථයක දුවනවා: ඔබ වට 10ක් දුවන්න ඉලක්කයක් තියාගන්නවා. ඔබ පළමු වටය දුවනවා, දෙවැන්න දුවනවා... දහවෙනි වටය ඉවර වෙනකම්ම ඔබ දුවන එක **නැවත නැවතත්** කරනවා. මෙතන කොන්දේසිය "වට 10 සම්පූර්ණ වී නැති වීමයි".
• බේකරියක පාන් පෙති කැපීම: බේකරියක යන්ත්‍රයක් සම්පූර්ණ පාන් ගෙඩියක් එකම ඝනකමට පෙති ඉවර වෙනකම්ම කපනවා. මෙතන කොන්දේසිය "තවදුරටත් කපන්න පාන් ඉතිරිව තිබීමයි".

Programming වලදීත් වෙන්නේ මේකමයි. අපි පරිගණකයට ආරම්භක ලක්ෂ්‍යයක්, නතර විය යුතු කොන්දේසියක් සහ නැවත නැවතත් කළ යුතු කාර්යයක් ලබා දෙනවා.

ලූපයක ප්‍රධාන කොටස් (Key Parts of a Loop)

සාමාන්‍යයෙන් ලූපයක් ප්‍රධාන කොටස් හතරකින් සමන්විත වෙනවා.

---

අපිට ලූප්ස් අවශ්‍ය වන්නේ ඇයි? (Why Do We Need Loops?) 🧐

ලූප්ස් යනු programming වලදී කාලය සහ ශ්‍රමය ඉතුරු කරන, කේතය වඩාත් බලවත් කරන මෙවලමකි.

1. කාර්යක්ෂමතාව සහ කේතය අඩු කිරීම (Efficiency and Reducing Code)

අපි මුලින්ම කතා කරපු උදාහරණයම ගමු. "Hello" 10 පාරක් print කිරීමට ලූපයක් නැතුව සහ ඇතුව ලියන කේත බලන්න.

ලූපයක් නොමැතිව (Without a Loop):

print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")
    

ලූපයක් සමඟ (With a Loop - Python):

for i in range(10):
    print("Hello")
    

පේළි 10ක් වෙනුවට පේළි 2කින් වැඩේ ඉවරයි. Software development වලදී "Don't Repeat Yourself" (DRY) කියලා මූලධර්මයක් තියෙනවා. ලූප්ස් කියන්නේ DRY මූලධර්මය ක්‍රියාවට නංවන්න තියෙන හොඳම ක්‍රමයක්.

2. දත්ත එකතුවක් හරහා ගමන් කිරීම (Iterating Through Collections)

ඔබට ශිෂ්‍යයන් 50 දෙනෙකුගේ නම් ඇතුළත් list එකක් තියෙනවා කියලා හිතන්න. ඔබට මේ හැමෝගෙම නම් screen එකේ print කරන්න ඕන. හැම ශිෂ්‍යයෙක් වෙනුවෙන්ම වෙනම `print` statement එකක් ලියනවද? නැහැ. ලූපයක් භාවිතා කරලා ඒ list එකේ තියෙන හැම නමක් හරහාම ගිහින් ඒවා එකින් එක print කරන්න පුළුවන්.

student_names = ["Nimal", "Kamala", "Sunil", "Amara", "Ruwan"]

for name in student_names:
    print("Welcome,", name)
    

3. පරිශීලක ආදානය (User Input) බලාපොරොත්තුවෙන් සිටීම

ATM යන්ත්‍රයක මෙනු එකක් ගැන හිතන්න. ඔබ "Withdraw", "Check Balance" වගේ option එකක් තෝරනවා. ඊට පස්සේ ආයෙත් ප්‍රධාන මෙනු එකට එනවා. ඔබ "Exit" තෝරනකම්ම ඒ මෙනු එක නැවත නැවතත් පෙන්වනවා. මේ වගේ දේවල් හදන්න ලූප්ස් අත්‍යවශ්‍යයි.

---

For Loop | නිශ්චිත වාර ගණනක් සඳහා 🔢

For Loop එකක් ප්‍රධාන වශයෙන්ම භාවිතා වෙන්නේ **නිශ්චිත වාර ගණනක්** යම් කාර්යයක් කිරීමට හෝ list එකක් වැනි දත්ත එකතුවක (sequence) ඇති සෑම உறுப்படிகள் (item) එකක් හරහාම ගමන් කිරීමටයි. ඔබ ලූපය කොපමණ වාරයක් ක්‍රියාත්මක විය යුතුද කියා **කලින්ම දන්නවා නම්**, For Loop එක තමයි වඩාත්ම සුදුසු.

Python හි For Loop Syntax එක

Python වල For Loop එක ඉතාම සරල සහ කියවීමට පහසුයි.

for variable_name in sequence:
    # Code to be repeated
    # This is the loop body
    

• `for`: මෙය for loop එකක් බව කියන keyword එක.
• `variable_name`: ඔබ කැමති නමක්. sequence එකේ තියෙන එක item එකක්, ලූපයේ එක වටයකදී මේ variable එකට ලැබෙනවා.
• `in`: sequence එකේ item එකක් variable එකට ලබාදෙන බව කියන keyword එක.
• `sequence`: list එකක්, string එකක්, හෝ `range()` වැනි පුනරාවර්තනය විය හැකි ඕනෑම දෙයක්.

`range()` ශ්‍රිතය (The `range()` function)

නිශ්චිත වාර ගණනක් ලූපය ක්‍රියාත්මක කිරීමට `range()` function එක ඉතාම ප්‍රයෝජනවත්. `range()` මගින් සංඛ්‍යා අනුක්‍රමයක් (sequence of numbers) ජනනය කරනවා.

• `range(5)` -> 0, 1, 2, 3, 4 (සංඛ්‍යා 5ක්, 0 සිට 4 දක්වා)
• `range(1, 6)` -> 1, 2, 3, 4, 5 (1 සිට 5 දක්වා)
• `range(0, 10, 2)` -> 0, 2, 4, 6, 8 (0 සිට 9 දක්වා, 2 ගානේ වැඩිවෙමින්)

ප්‍රායෝගික For Loop උදාහරණ

1. 1 සිට 5 දක්වා මුද්‍රණය කිරීම:

print("Numbers from 1 to 5:")
for number in range(1, 6):
    print(number)
    

2. List එකක ඇති නම් මුද්‍රණය කිරීම:

fruits = ["Apple", "Banana", "Cherry", "Orange"]
print("Available fruits:")
for fruit in fruits:
    print("- " + fruit)
    

3. ගුණන චක්‍රයක් (Multiplication Table) සෑදීම:

# 5 times table
number_to_multiply = 5
print(f"Multiplication table for {number_to_multiply}:")

for i in range(1, 11):  # Loop from 1 to 10
    result = number_to_multiply * i
    print(f"{number_to_multiply} x {i} = {result}")
    

---

While Loop | කොන්දේසියක් සපුරන තුරු 🔁

While Loop එකක් භාවිතා වෙන්නේ යම්කිසි කාර්යයක් **කොන්දේසියක් සත්‍ය (True) වන තාක් කල්** නැවත නැවතත් කිරීමටයි. මෙහිදී ලූපය කොපමණ වාරයක් ක්‍රියාත්මක වේදැයි අපි කලින්ම දන්නේ නැහැ. කොන්දේසිය අසත්‍ය (False) වූ සැනින් ලූපය නතර වෙනවා.

Python හි While Loop Syntax එක

while condition:
    # Code to be repeated as long as the condition is True
    # This is the loop body
    # IMPORTANT: Update the variable used in the condition
    

• `while`: while loop එකක් බව කියන keyword එක.
• `condition`: `True` හෝ `False` ලෙස ප්‍රතිඵලයක් දෙන ඕනෑම තර්කයක්.

ප්‍රායෝගික While Loop උදාහරණ

1. 1 සිට 5 දක්වා මුද්‍රණය කිරීම (For Loop එක කළ දෙයම):

print("Numbers from 1 to 5:")
counter = 1  # 1. Initialization
while counter <= 5:  # 2. Condition
    print(counter)   # 3. Body
    counter = counter + 1  # 4. Update
    

2. පරිශීලකයා 'quit' ලෙස type කරන තුරු input ගැනීම:

user_input = ""
while user_input.lower() != "quit":
    user_input = input("Enter a message (type 'quit' to exit): ")
    print(f"You typed: {user_input}")

print("Goodbye!")
    

3. සරල Guessing Game එකක්:

import random

secret_number = random.randint(1, 10)
guess = 0

print("I'm thinking of a number between 1 and 10.")
while guess != secret_number:
    guess = int(input("What is your guess? "))
    if guess < secret_number:
        print("Too low! Try again.")
    elif guess > secret_number:
        print("Too high! Try again.")

print("Congratulations! You guessed it right!")
    

---

ලූප් පාලනය කිරීම (Advanced Loop Control) ⚙️

සමහර වෙලාවට අපිට ලූපයක සාමාන්‍ය ගමනට බාධා කරන්න සිද්ධ වෙනවා. එක්කෝ ලූපය සම්පූර්ණයෙන්ම නතර කරන්න, නැත්නම් වත්මන් වටය විතරක් මඟහැරලා ඊළඟ වටයට යන්න. මේ සඳහා `break` සහ `continue` කියන ප්‍රකාශන (statements) යොදාගන්නවා.

1. `break` ප්‍රකාශය: ලූපයෙන් වහාම ඉවත් වීම

`break` statement එක හමුවූ සැනින්, පරිගණකය එම ලූපය සම්පූර්ණයෙන්ම නතර කර, ලූපයෙන් පසුව ඇති කේතය ක්‍රියාත්මක කිරීම ආරම්භ කරනවා.

උදාහරණය: List එකක 'Sunil' යන නම සෙවීම

'Sunil' හමුවූ සැනින් සෙවීම නතර කළ හැකියි, ඉතිරි අයව check කිරීම අනවශ්‍යයි.

student_names = ["Nimal", "Kamala", "Sunil", "Amara", "Ruwan"]

for name in student_names:
    print("Checking:", name)
    if name == "Sunil":
        print("Found Sunil! Stopping the search.")
        break  # Exit the loop immediately
    
print("Loop finished.")
    

2. `continue` ප්‍රකාශය: වත්මන් වටය මඟ හැරීම

`continue` statement එක හමුවූ විට, ලූපයේ වත්මන් වටයේ (current iteration) ඉතිරි කේත කොටස ක්‍රියාත්මක නොකර, ඊළඟ වටය ආරම්භ කරනවා. ලූපය සම්පූර්ණයෙන් නතර වෙන්නේ නැහැ.

උදාහරණය: 1 සිට 10 දක්වා ඇති ඔත්තේ සංඛ්‍යා මඟහැර ඉරට්ටේ සංඛ්‍යා පමණක් මුද්‍රණය කිරීම

for number in range(1, 11):
    if number % 2 != 0:  # Check if the number is odd
        continue  # If it's odd, skip to the next number
    print(number) # This line only runs for even numbers
    

3. Nested Loops (එකක් තුළ තවත් ලූපයක්)

එක් ලූපයක් ඇතුළේ තවත් ලූපයක් ලිවීම Nested Loops ලෙස හඳුන්වනවා. පිටතින් ඇති ලූපයේ (outer loop) එක වටයක් සඳහා, ඇතුළත ලූපය (inner loop) සම්පූර්ණයෙන්ම ක්‍රියාත්මක වී අවසන් වෙනවා.

මෙය ඔරලෝසුවක පැය කටුව සහ මිනිත්තු කටුව වගෙයි. පැය කටුව එක පියවරක් යන්න, මිනිත්තු කටුව සම්පූර්ණ වට 60ක්ම යන්න ඕන.

උදාහරණය: තරු (*) වලින් හැදූ රටාවක් (Pattern) මුද්‍රණය කිරීම

# This will print a 3x5 rectangle of stars
for row in range(3):      # Outer loop for rows
    for column in range(5): # Inner loop for columns
        print("*", end=" ") # Print a star and stay on the same line
    print() # After the inner loop finishes, move to the next line
    

ප්‍රතිදානය (Output):

* * * * * * * * * * * * * * * 

---

සාරාංශය (Conclusion) ✨

ලූප්ස් යනු programming වලදී පුනරාවර්තන කාර්යයන් පහසුවෙන් සහ කාර්යක්ෂමව කරගැනීමට ඇති අද්විතීය මෙවලමකි. ඔබ මේ සංකල්පය ප්‍රගුණ කළා යනු, ඔබට වඩාත් සංකීර්ණ සහ ප්‍රයෝජනවත් පරිගණක වැඩසටහන් ලිවීමේ හැකියාව ලැබුණා යන්නයි.

අපි ඉගෙන ගත් ප්‍රධාන කරුණු:

• ලූපයක් යනු කොන්දේසියක් සපුරන තාක් කේත කොටසක් නැවත නැවත ක්‍රියාත්මක කිරීමයි.
• For Loop: ක්‍රියාත්මක විය යුතු වාර ගණන ඔබ කලින්ම දන්නා විට භාවිතා කරයි (Definite Iteration).
• While Loop: යම් කොන්දේසියක් සත්‍ය වන තාක් ක්‍රියාත්මක කිරීමට භාවිතා කරයි. වාර ගණන කලින් නොදනී (Indefinite Iteration).
• `break` මගින් ලූපය වහාම නතර කරන අතර, `continue` මගින් වත්මන් වටය පමණක් මඟ හරියි.
• Nested Loops යනු ලූපයක් තුළ තවත් ලූපයක් භාවිතා කිරීමයි.

දැන් ඔබ විචල්යයන් සහ ලූප්ස් යන මූලික කුළුණු දෙකම ගැන දන්නවා. දැන් කළ යුත්තේ මේවා භාවිතා කර විවිධ ගැටළු විසඳීමට උත්සාහ කිරීමයි. මෙම ලිපියේ ඇති උදාහරණ ඔබම type කර, ඒවායේ අගයන් වෙනස් කර ලැබෙන ප්‍රතිඵල බලන්න. එයින් ඔබේ අවබෝධය තවත් වැඩි දියුණු වනු ඇත.

ඊළඟට මොකක්ද? ඔබ දැන් කේත නැවත නැවතත් ක්‍රියාත්මක කරවන්න දන්නවා. ඊළඟට, අපි මේ කේත කොටස් පිළිවෙලට සංවිධානය කර, අවශ්‍ය විටෙක නැවත නැවත භාවිතා කරන්නේ කෙසේදැයි ඉගෙන ගනිමු. අපේ ඊළඟ ලිපිය වන **"ෆංක්ෂන් (Function) යනු කුමක්ද?"** කියවන්නට අපි ඔබට ආරාධනා කරනවා!