Python Lists: දත්ත ගබඩා කිරීමේ සහ කළමනාකරණය කිරීමේ දක්ෂයා

ආයුබෝවන් කට්ටිය! කොහොමද ඉතින්, වැඩ එහෙම සාර්ථකද? Software development කරන අපිට දත්ත කියන්නේ අපේ වැඩවල හදවත වගේ දෙයක්. ඒ දත්ත හරියට organize කරලා, පහසුවෙන් access කරන්න පුළුවන් විදිහට තියාගන්න එක හරිම වැදගත්. හිතන්න, ඔයාගේ phone එකේ contacts ටික, library එකක පොත් ටික, නැත්නම් ඔයාගේ shopping list එක... මේ හැමදේම list එකක් විදිහට තමයි තියෙන්නේ නේද?

Python වල මේ වගේ දත්ත ගොඩක් එක තැනක තියාගෙන, ඒක පහසුවෙන් modify කරන්න පුළුවන් නියමම data structure එකක් තමයි Lists කියන්නේ. අද අපි මේ Lists ගැන මුල ඉඳලම ඉගෙන ගමු. එහෙනම් අපි පටන් ගමු!

1. Lists කියන්නේ මොනවද? (Mutable Sequences)

සරලවම කියනවා නම්, Python List එකක් කියන්නේ එකිනෙකට සම්බන්ධ නැති විවිධ වර්ගවල දත්ත එක පෙළට ගබඩා කරලා තියාගන්න පුළුවන් අනුපිළිවෙලක් (sequence). මේක හරියට පොත් පෙට්ටියක් වගේ. ඒ පොත් පෙට්ටියේ ඔයාට විවිධ වර්ගයේ පොත් (ඒ කියන්නේ numbers, strings, Booleans, arrays වගේ දේවල්) ඕනෑම ගානක් දාන්න පුළුවන්. අලුතෙන් පොත් එකතු කරන්න, අයින් කරන්න, නැත්නම් තිබ්බ පොත් වල අනුපිළිවෙල වෙනස් කරන්න පුළුවන්.

මෙහිදී 'mutable' කියන වචනය ගොඩක් වැදගත්. 'Mutable' කියන්නේ අපිට List එකක් හදපු පස්සේ වුණත්, ඒකේ තියෙන දත්ත වෙනස් කරන්න පුළුවන් කියන එකයි. අලුත් දේවල් එකතු කරන්න, තියෙන දේවල් අයින් කරන්න, නැත්නම් ඒවායේ අගයන් වෙනස් කරන්න පුළුවන්. මේක Lists වල තියෙන ලොකුම වාසියක්!

2. List එකක් හදමු! (Creating Lists)

Python වල List එකක් හදන එක හරිම ලේසියි. අපි square brackets [] ඇතුලේ අපිට ඕන දේවල් comma වලින් වෙන් කරලා දානවා. ඒකට විවිධ data types වුණත් දාන්න පුළුවන්.

හිස් List එකක් (Empty List)

මුලින්ම හිස් List එකක් හදමු. අපිට පස්සේ ඒකට දේවල් එකතු කරන්න පුළුවන්.

my_empty_list = []
print(my_empty_list)  # Output: []
print(type(my_empty_list)) # Output: <class 'list'>

දත්ත සහිත List එකක් (List with Data)

දැන් අපි දත්ත ටිකක් දාලා List එකක් හදමු. මේකට numbers, strings, Booleans වගේ ඕනෑම දෙයක් දාන්න පුළුවන්.

fruits = ["apple", "banana", "cherry", "date"]
numbers = [1, 2, 3, 4, 5]
mixed_data = ["hello", 123, True, 3.14, ["nested", "list"]] # List එකක් ඇතුලේ තව List එකක්

නියමයි නේද? දැන් ඔයාට List එකක් හදාගන්න පුළුවන්.

3. List එකක තියෙන දේවල් බලමු! (Accessing Elements)

List එකක් හදාගත්තට විතරක් මදි. ඒක ඇතුලේ තියෙන දේවල් අවශ්‍ය වෙලාවට ගන්න පුළුවන් වෙන්නත් ඕනේ. ඒකට ක්‍රම දෙකක් තියෙනවා: Indexing සහ Slicing.

Indexing (තනි අගයක් ලබාගැනීම)

List එකක තියෙන හැම element එකකටම index number එකක් තියෙනවා. මේවා 0 (ශුන්‍යයෙන්) තමයි පටන් ගන්නේ. ඒ කියන්නේ, පළවෙනි element එකේ index එක 0, දෙවෙනි එකේ index එක 1, මේ විදිහට යනවා.

fruits = ["apple", "banana", "cherry", "date"]

first_fruit = fruits[0]  # Output: apple
second_fruit = fruits[1] # Output: banana

print(first_fruit)
print(second_fruit)

අපි negative indexing පාවිච්චි කරන්නත් පුළුවන්. ඒ කියන්නේ List එකේ අන්තිමේ ඉඳලා ගණන් කරනවා. -1 කියන්නේ අන්තිම element එක, -2 කියන්නේ අන්තිමට කලින් element එක.

last_fruit = fruits[-1]    # Output: date
second_last = fruits[-2] # Output: cherry

print(last_fruit)
print(second_last)

Slicing (කොටසක් ලබාගැනීම)

අපිට List එකක තියෙන element ගොඩකින් පොඩි කොටසක් විතරක් ගන්න අවශ්‍ය නම්, Slicing පාවිච්චි කරන්න පුළුවන්. මේකට අපි [start:end:step] කියන format එක පාවිච්චි කරනවා.

• start: Slice එක පටන් ගන්න index එක (මේකත් ඇතුලත් වෙනවා).
• end: Slice එක ඉවර වෙන index එක (මේක ඇතුලත් වෙන්නේ නෑ).
• step: එකකට එකක් පනින ප්‍රමාණය (මේක අනිවාර්ය නෑ, default එක 1).

my_list = ["A", "B", "C", "D", "E", "F", "G"]

subset1 = my_list[1:4]   # Output: ['B', 'C', 'D'] (index 1 සිට 4 දක්වා, 4 ඇතුලත් නෑ)
subset2 = my_list[:3]    # Output: ['A', 'B', 'C'] (මුල සිට index 3 දක්වා, 3 ඇතුලත් නෑ)
subset3 = my_list[4:]    # Output: ['E', 'F', 'G'] (index 4 සිට අග දක්වා)
subset4 = my_list[:]     # Output: ['A', 'B', 'C', 'D', 'E', 'F', 'G'] (මුළු List එකම copy කරනවා)
subset5 = my_list[::2]   # Output: ['A', 'C', 'E', 'G'] (එකක් පැන පැන ගන්නවා)
subset6 = my_list[::-1]  # Output: ['G', 'F', 'E', 'D', 'C', 'B', 'A'] (List එක reverse කරනවා)

දැන් ඔයාට List එකකින් ඕනෑම කොටසක් පහසුවෙන් ගන්න පුළුවන්!

4. List Methods: වැඩ ගොඩක් කරමු!

List එකක් හදාගෙන, ඒකෙන් දේවල් අරගෙන විතරක් මදි. අපිට Lists එක්ක ගොඩක් operations කරන්න සිද්ධ වෙනවා. Python මේකට ගොඩක් useful built-in methods දීලා තියෙනවා.

append(): List එකකට එකතු කිරීම

append() method එකෙන් List එකක අන්තිමට අලුත් element එකක් එකතු කරන්න පුළුවන්.

fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits) # Output: ['apple', 'banana', 'cherry']

insert(): නියමිත ස්ථානයකට එකතු කිරීම

insert() method එකෙන් අපිට ඕනෑම index එකකට අලුත් element එකක් එකතු කරන්න පුළුවන්. මේකෙන් අනිත් element ටික ඉස්සරහට තල්ලු වෙනවා.

fruits = ["apple", "banana", "cherry"]
fruits.insert(1, "orange") # index 1 ට orange එකතු කරනවා
print(fruits) # Output: ['apple', 'orange', 'banana', 'cherry']

remove(): අගය අනුව ඉවත් කිරීම

remove() method එකෙන් List එකෙන් අපිට අවශ්‍ය අගයක් ඉවත් කරන්න පුළුවන්. එකම අගය කිහිප වතාවක් තිබ්බොත්, පළවෙනි වතාවට හම්බවෙන එක තමයි remove කරන්නේ.

fruits = ["apple", "banana", "cherry", "banana"]
fruits.remove("banana")
print(fruits) # Output: ['apple', 'cherry', 'banana']

pop(): Index එක අනුව ඉවත් කිරීම (සහ ලබාගැනීම)

pop() method එකෙන් අපිට index එකක් දීලා element එකක් ඉවත් කරන්න පුළුවන්. මේකේ විශේෂත්වය තමයි, ඉවත් කරන element එක අපිට return කරන එක. Index එකක් නොදුන්නොත් අන්තිම element එක remove කරනවා.

fruits = ["apple", "banana", "cherry"]

removed_fruit = fruits.pop(1) # index 1 (banana) ඉවත් කරලා ගන්නවා
print(removed_fruit) # Output: banana
print(fruits)       # Output: ['apple', 'cherry']

last_item = fruits.pop() # අන්තිම element (cherry) ඉවත් කරලා ගන්නවා
print(last_item)    # Output: cherry
print(fruits)       # Output: ['apple']

sort(): අනුපිළිවෙලට සැකසීම

sort() method එකෙන් List එකක් in-place (ඒ කියන්නේ මුල් List එකම) අකුරු, සංඛ්‍යා වගේ පිළිවෙලට සකසනවා. Default එක ascending order (කුඩා ඉඳන් ලොකුවට/A ඉඳන් Z ට).

numbers = [5, 2, 8, 1, 9]
numbers.sort()
print(numbers) # Output: [1, 2, 5, 8, 9]

fruits = ["cherry", "banana", "apple"]
fruits.sort()
print(fruits) # Output: ['apple', 'banana', 'cherry']

# descending order එකට sort කරන්න
fruits.sort(reverse=True)
print(fruits) # Output: ['cherry', 'banana', 'apple']

සැලකිය යුතුයි: sort() method එක මුල් List එකම modify කරනවා. අලුත් sorted List එකක් ඕන නම් sorted() function එක පාවිච්චි කරන්න පුළුවන්.

original_numbers = [5, 2, 8, 1, 9]
sorted_numbers = sorted(original_numbers)
print(original_numbers) # Output: [5, 2, 8, 1, 9] (මුල් List එක වෙනස් වෙන්නේ නෑ)
print(sorted_numbers)   # Output: [1, 2, 5, 8, 9]

reverse(): ප්‍රතිවිරුද්ධ අනුපිළිවෙලට හැරවීම

reverse() method එකෙන් List එකේ element වල අනුපිළිවෙල ප්‍රතිවිරුද්ධ කරනවා. මේකත් in-place modification එකක්.

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list) # Output: [5, 4, 3, 2, 1]

extend(): Lists දෙකක් එකතු කිරීම

extend() method එකෙන් List එකකට තව List එකක හෝ වෙනත් iterable එකක (tuples, sets වගේ) තියෙන element එකතු කරන්න පුළුවන්.

fruits = ["apple", "banana"]
more_fruits = ["cherry", "date"]
fruits.extend(more_fruits)
print(fruits) # Output: ['apple', 'banana', 'cherry', 'date']

# මේක + operator එකෙන් කරනවා වගේමයි, හැබැයි extend() එකෙන් මුල් List එකම modify වෙනවා.
list1 = [1, 2]
list2 = [3, 4]
list3 = list1 + list2 # list3 = [1, 2, 3, 4]. list1 වෙනස් වෙන්නේ නෑ.

count(): අගයක වාර ගණන ගණනය කිරීම

count() method එකෙන් List එකක් ඇතුලේ යම්කිසි අගයක් කී වතාවක් තියෙනවද කියලා බලන්න පුළුවන්.

my_list = [1, 2, 2, 3, 4, 2, 5]
count_of_2 = my_list.count(2)
print(count_of_2) # Output: 3

index(): අගයක index එක සොයා ගැනීම

index() method එකෙන් යම්කිසි අගයක් මුලින්ම තියෙන index එක මොකක්ද කියලා හොයන්න පුළුවන්.

fruits = ["apple", "banana", "cherry", "banana"]
index_of_banana = fruits.index("banana")
print(index_of_banana) # Output: 1

# නැති අගයක් දුන්නොත් ValueError එකක් එනවා
# try:
#     fruits.index("grape")
# except ValueError as e:
#     print(e) # Output: 'grape' is not in list

5. To-Do List එකක් හදමු! (Practical Application)

දැන් අපි ඉගෙන ගත්තු දේවල් පාවිච්චි කරලා, පොඩි To-Do List application එකක් හදමු. මේකෙන් අපිට tasks add කරන්න, බලන්න, complete කරන්න, සහ delete කරන්න පුළුවන්.

todo_list = []

def add_task(task):
    todo_list.append(task)
    print(f"'{task}' successfully added to the To-Do list.")

def view_tasks():
    if not todo_list:
        print("Your To-Do list is empty!")
        return
    print("\n--- Your To-Do List ---")
    for i, task in enumerate(todo_list):
        print(f"{i+1}. {task}")
    print("----------------------")

def mark_task_complete(task_index):
    if 0 <= task_index < len(todo_list):
        # Task එක remove කරලා completed කියලා print කරනවා
        completed_task = todo_list.pop(task_index)
        print(f"'{completed_task}' marked as completed and removed.")
    else:
        print("Invalid task number. Please try again.")

def remove_task(task_index):
    if 0 <= task_index < len(todo_list):
        removed_task = todo_list.pop(task_index)
        print(f"'{removed_task}' has been removed from the list.")
    else:
        print("Invalid task number. Please try again.")

while True:
    print("\n--- To-Do List Menu ---")
    print("1. Add Task")
    print("2. View Tasks")
    print("3. Mark Task as Completed (Remove)")
    print("4. Remove Task by Number")
    print("5. Exit")
    
    choice = input("Enter your choice: ")

    if choice == '1':
        task = input("Enter the task: ")
        add_task(task)
    elif choice == '2':
        view_tasks()
    elif choice == '3':
        view_tasks()
        try:
            task_num = int(input("Enter the number of the task to mark as completed: "))
            mark_task_complete(task_num - 1) # User input is 1-based, list is 0-based
        except ValueError:
            print("Invalid input. Please enter a number.")
    elif choice == '4':
        view_tasks()
        try:
            task_num = int(input("Enter the number of the task to remove: "))
            remove_task(task_num - 1) # User input is 1-based, list is 0-based
        except ValueError:
            print("Invalid input. Please enter a number.")
    elif choice == '5':
        print("Exiting To-Do List. Goodbye!")
        break
    else:
        print("Invalid choice. Please choose again.")

මේ code එක run කරලා බලන්න. ඔයාට දැන් Lists පාවිච්චි කරලා කොහොමද real-world scenario එකක පොඩි application එකක් හදන්නේ කියලා අදහසක් එනවා ඇති.

6. පොඩ්ඩක් පරිස්සමින්! (Troubleshooting & Best Practices)

Lists එක්ක වැඩ කරනකොට අපිට පොඩි පොඩි problems එන්න පුළුවන්. ඒවා වළක්වාගන්නත්, හොඳ habits develop කරගන්නත් මේ tips ටික වැදගත්.

IndexError: List index out of range

මේක ගොඩක් එන error එකක්. ඔයා List එකක නැති index එකක් access කරන්න හැදුවොත් මේ error එක එනවා. උදාහරණයක් විදිහට, elements 3ක් තියෙන List එකක index 5ක් ඉල්ලුවොත් මේ error එක එනවා.

my_list = [10, 20, 30]
# print(my_list[3]) # IndexError: list index out of range (මෙය error එකක්)

මේක වළක්වාගන්න, හැමවිටම List එකේ දිග (length) ගැන අවබෝධයෙන් වැඩ කරන්න. len() function එකෙන් List එකක දිග ගන්න පුළුවන්.

if 0 <= index < len(my_list):
    # safe to access
    print(my_list[index])
else:
    print("Index is out of range.")

In-place Modifications: මතක තියාගන්න

අපි ඉස්සෙල්ලා කතා කරපු append(), insert(), remove(), pop(), sort(), reverse(), extend() වගේ methods වලින් List එක in-place modify වෙනවා. ඒ කියන්නේ, මුල් List එකම වෙනස් වෙනවා. සමහර වෙලාවට අපිට මුල් List එකට හානියක් නැතුව copy එකක් හදලා ඒක modify කරන්න ඕන වෙන්න පුළුවන්. ඒකට slicing (my_list[:]) හෝ copy() method එක පාවිච්චි කරන්න පුළුවන්.

original_list = [1, 2, 3]
modified_list = original_list[:] # copy එකක් හදනවා
modified_list.append(4)

print(original_list) # Output: [1, 2, 3]
print(modified_list) # Output: [1, 2, 3, 4]

හොඳම පුරුදු (Best Practices)

• තේරුමක් තියෙන නම් දෙන්න (Meaningful Variable Names): List එකකට නමක් දානකොට ඒකෙන් List එකේ තියෙන දේවල් මොනවද කියලා තේරෙන නමක් දෙන්න. x = [1,2,3] කියනවට වඩා student_ages = [18, 20, 22] කියන එක හොඳයි.
• Code එකට Comments දාන්න: ඔයා හදන code එක තව කෙනෙක්ට හෝ ඔයාටම පස්සේ බලනකොට තේරෙන්න පහසු වෙන්න comments දාන්න.
• List Comprehension: advanced topic එකක් වුණත්, මේක Lists හසුරවන්න තියෙන powerful tool එකක්. අපි මේක ගැන වෙනම article එකකින් කතා කරමු.

අවසාන වශයෙන්...

List කියන්නේ Python වල අත්‍යවශ්‍යම data structure එකක්. දත්ත ගබඩා කරන්න, ඒවට access කරන්න, modify කරන්න, manage කරන්න මේක අතිශයින්ම වැදගත්. අපි මේ article එකෙන් Lists වල මූලික දේවල් වගේම, ඒවා practical විදිහට පාවිච්චි කරන්නේ කොහොමද කියලත් ඉගෙන ගත්තා. ඔයාලට දැන් පුළුවන් මේ concepts පාවිච්චි කරලා පොඩි පොඩි projects කරන්න පටන් ගන්න. උදාහරණයක් විදිහට, shopping list app එකක්, movie collection app එකක් වගේ දේවල්.

අමතක කරන්න එපා, programming කියන්නේ practice කරන තරමට දියුණු වෙන දෙයක්. මේ concepts ඔයාලගේම code එකෙන් try කරලා බලන්න. ඔයාලගේ අදහස්, ප්‍රශ්න පහලින් comment කරන්න! තව මොනවා ගැනද ඔයාලට දැනගන්න ඕනේ කියලා කියන්නත් අමතක කරන්න එපා. අපි ඊළඟ article එකෙන් හම්බවෙමු!