Python Tuples සිංහලෙන්: Data Structures ගමනක වැදගත් පියවරක් | SC Guide

ඉතින් කොහොමද යාලුවනේ? අදත් අලුත් දෙයක් ගැන කතා කරන්නයි අපි සූදානම් වෙන්නේ. Software Engineering කියන්නේ නිතරම අලුත් දේවල් ඉගෙන ගන්න, පරණ දේවල් නැවත බලන්න ඕන ක්ෂේත්‍රයක්නේ. Data Structures කියන්නේ ඒ වගේ අපි අනිවාර්යයෙන්ම හොඳට දැනගෙන ඉන්න ඕනම දෙයක්. විශේෂයෙන්ම, Python වගේ භාෂා වලදී මේ Data Structures තේරුම් ගැනීම අපේ කෝඩ් එකේ කාර්යක්ෂමතාවයට (efficiency) සහ නඩත්තු කිරීමට (maintainability) සෘජුවම බලපානවා. අද අපි කතා කරන්න යන්නේ ඒ වගේ පොඩ්ඩක් අමතක වෙලා වගේ තියෙන, හැබැයි නියම තැන් වලට පාවිච්චි කලොත් වැඩ ගොඩක් ලේසි කරගන්න පුළුවන් Data Structure එකක් ගැන – ඒ තමයි Tuples.

ලංකාවේ අපි දන්නවනේ, සමහර දත්ත තියෙනවා, ඒවා කවදාවත් වෙනස් වෙන්න හොඳ නෑ. උදාහරණයක් විදිහට, කොළඹ නගර සිතියමේ ඛණ්ඩාංක (coordinates) කට්ටලයක්. ඒවා කවුරු හරි අතින් හරි නොදැනුවත්ව හරි වෙනස් කලොත් අන්තිමට වෙන්නේ ගොඩක් අවුල්. අන්න ඒ වගේ තැන් වලට තමයි Tuples කියන Data Structure එක නියමෙටම ගැලපෙන්නේ. මොකද මේවා Immutable. ඒ කියන්නේ හදුවාට පස්සේ වෙනස් කරන්න බෑ. හරියට අපේ ජාතික හැඳුනුම්පත් අංකය වගේ, එක පාරක් දුන්නාට පස්සේ වෙනස් කරන්න බැරි විදිහට. හරි, එහෙනම් කෙලින්ම වැඩේට බහිමු.

ටියුපල්ස් කියන්නේ මොනවද? (What are Tuples?)

සරලව කිව්වොත්, Tuple එකක් කියන්නේ Python වල තියෙන ordered (පිළිවෙලකට තියෙන) සහ immutable (වෙනස් කරන්න බැරි) දත්ත එකතුවක්. List එකක් වගේම තමයි, Tuple එකකත් විවිධ වර්ගවල දත්ත (integers, strings, booleans, arrays, even other tuples) තියාගන්න පුළුවන්. හැබැයි List එකක වගේ Tuple එකක් හැදුවාට පස්සේ ඒක ඇතුළේ තියෙන elements වෙනස් කරන්න, අයින් කරන්න, හෝ අලුතින් එකතු කරන්න බෑ. මේක තමයි Tuple එකක තියෙන ප්‍රධානම ලක්ෂණය.

හිතලා බලන්න, ඔයාට බස් එකක route එකක් සටහන් කරගන්න ඕන නම්. Colombo – Kandy – Nuwara Eliya. මේ route එකේ පිළිවෙලත් වැදගත්, ඒ වගේම මේක වෙනස් වෙන්නත් හොඳ නෑ. අන්න ඒ වගේ තැන් වලට Tuple එකක් පාවිච්චි කරන එක ගොඩක් හොඳයි. මොකද කවුරු හරි වැරදීමකින් මේක වෙනස් කරන්න හැදුවොත්, Python එකෙන්ම අපිට Error එකක් දෙනවා, "මේක කරන්න බෑ" කියලා. මේකෙන් අපේ දත්ත වල ආරක්ෂාව තහවුරු වෙනවා.

List එකක් හැදුවම අපි [] (square brackets) පාවිච්චි කරනවා වගේම, Tuple එකක් හදද්දී අපි () (parentheses / වරහන්) පාවිච්චි කරනවා. උදාහරණයක් බලමු:

# List එකක්
my_list = [10, 20, 30]
print(my_list) # Output: [10, 20, 30]
my_list[0] = 5 # List එක වෙනස් කරන්න පුළුවන්
print(my_list) # Output: [5, 20, 30]

# Tuple එකක්
my_tuple = (10, 20, 30)
print(my_tuple) # Output: (10, 20, 30)
# my_tuple[0] = 5 # මේක කරන්න බෑ! TypeError එකක් එනවා
# print(my_tuple)

දැක්කනේ? my_tuple[0] = 5 කියලා දාපු ගමන් Error එකක් එනවා. අන්න ඒක තමයි Tuple වල තියෙන සුවිශේෂත්වය.

ටියුපල්ස් හදන්නේ කොහොමද? සහ Element වලට යන්නේ කොහොමද? (How to Create Tuples? And How to Access Elements?)

ටියුපල්ස් හදන විදි (Ways to Create Tuples)

Tuple එකක් හදන එක ගොඩක් සරලයි. අපි parentheses () ඇතුලේ අපිට ඕන දත්ත ටික දානවා.

# හිස් Tuple එකක් (Empty Tuple)
empty_tuple = ()
print(empty_tuple) # Output: ()
print(type(empty_tuple)) # Output: <class 'tuple'>

# එක element එකක් තියෙන Tuple එකක් (Tuple with a single element)
# මෙතනදී මතක තියාගන්න ඕන දේ තමයි element එකෙන් පස්සේ comma (,) එකක් දාන්න ඕන එක.
# එහෙම නැතුව දාපුවම Python එක ඒක tuple එකක් විදිහට හඳුනගන්නේ නෑ.
single_element_tuple = ("Apple",) # මෙතන comma එක අමතක කරන්න එපා!
print(single_element_tuple) # Output: ('Apple',)
print(type(single_element_tuple)) # Output: <class 'tuple'>

not_a_tuple = ("Apple") # මේක tuple එකක් නෙවෙයි!
print(not_a_tuple) # Output: Apple
print(type(not_a_tuple)) # Output: <class 'str'>

# සාමාන්‍ය Tuple එකක් (Tuple with multiple elements)
my_coordinates = (7.0, 80.0)
print(my_coordinates) # Output: (7.0, 80.0)

my_info = ("Kamal", 30, "Colombo", True)
print(my_info) # Output: ('Kamal', 30, 'Colombo', True)

# Parentheses නැතුවත් Tuple හදන්න පුළුවන් (Tuple without parentheses - "Tuple Packing")
# මේක "Tuple Packing" කියලා හඳුන්වනවා.
# මේක වැඩිපුර පාවිච්චි වෙන්නේ function වලින් multiple values return කරද්දී.
colors = "red", "green", "blue"
print(colors) # Output: ('red', 'green', 'blue')
print(type(colors)) # Output: <class 'tuple'>

Element වලට Access කරන විදි (Accessing Elements)

List එකක වගේම Tuple එකකත් elements වලට index එක පාවිච්චි කරලා access කරන්න පුළුවන්. Index එක පටන් ගන්නේ 0 න් කියලා මතක තියාගන්න. ඒ වගේම negative indexing පාවිච්චි කරලා අන්තිමේ ඉඳන් elements වලට access කරන්නත් පුළුවන්.

my_tuple = ("Python", "Java", "C++", "JavaScript")

# පළමු element එක (First element)
print(my_tuple[0]) # Output: Python

# දෙවන element එක (Second element)
print(my_tuple[1]) # Output: Java

# අන්තිම element එක (Last element using negative indexing)
print(my_tuple[-1]) # Output: JavaScript

# දෙවෙනි අන්තිම element එක (Second last element)
print(my_tuple[-2]) # Output: C++

Slicing: Tuple එකක කොටසක් (a slice) ගන්නත් පුළුවන්. මේකත් List එකක slicing වගේම තමයි. [start:end] කියන format එක පාවිච්චි කරනවා. end කියන index එකට අයිති element එක slice එකට එකතු වෙන්නේ නෑ කියලා මතක තියාගන්න.

numbers = (10, 20, 30, 40, 50, 60, 70)

# පළමු element තුන (First three elements)
print(numbers[0:3]) # Output: (10, 20, 30)

# තුන්වෙනි element එකේ ඉඳන් අන්තිම වෙනකල් (From third element to the end)
print(numbers[2:]) # Output: (30, 40, 50, 60, 70)

# මුල ඉඳන් පස්වෙනි element එක වෙනකල් (From beginning up to the fifth element)
print(numbers[:5]) # Output: (10, 20, 30, 40, 50)

# සම්පූර්ණ Tuple එකේ copy එකක් (A copy of the entire tuple)
print(numbers[:]) # Output: (10, 20, 30, 40, 50, 60, 70)

ටියුපල් Unpacking සහ Practical Use Cases (Tuple Unpacking and Practical Use Cases)

ටියුපල් Unpacking (Tuple Unpacking)

Tuple Unpacking කියන්නේ Tuple එකක තියෙන elements වෙන වෙනම variables වලට assign කරන ක්‍රමයක්. මේක අපේ කෝඩ් එක කියවන්න ලේසි කරනවා වගේම, සමහර වෙලාවට වැඩ ගොඩක් ලේසි කරනවා.

# සරල Unpacking
student_details = ("Nimal", 22, "IT")
name, age, major = student_details

print(name)  # Output: Nimal
print(age)   # Output: 22
print(major) # Output: IT

# Function එකකින් multiple values return කරද්දී
def get_user_data():
    return "Sunil", 28, "Galle" # මේක Tuple එකක් විදිහට return වෙන්නේ

user_name, user_age, user_city = get_user_data()
print(f"{user_name} is {user_age} years old and lives in {user_city}.")
# Output: Sunil is 28 years old and lives in Galle.

# Loop එකක් ඇතුලේ (e.g., iterating over dictionary items)
my_dict = {"apple": 1, "banana": 2, "cherry": 3}
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")
# Output:
# Key: apple, Value: 1
# Key: banana, Value: 2
# Key: cherry, Value: 3

# Swap variables (වෙන වෙනම variables swap කරන්න)
a = 10
b = 20
a, b = b, a # Python වල තියෙන ලස්සන විශේෂාංගයක්
print(f"a: {a}, b: {b}") # Output: a: 20, b: 10

Practical Use Cases

Function Argument Passing (Function වලට Argument විදිහට දෙනකොට):Tuple එකක් function එකකට argument එකක් විදිහට දෙනකොට, ඒ tuple එක function එක ඇතුළේදී වෙනස් කරන්න බෑ. මේකෙන් function එකේ side effects අඩු වෙනවා වගේම, දත්ත වල ආරක්ෂාවත් තහවුරු වෙනවා.

def process_student_data(data):
    # data කියන්නේ (name, age, major) වගේ Tuple එකක් වෙන්න පුළුවන්
    print(f"Processing student: {data[0]}, Age: {data[1]}")
    # data[1] = 23 # Error! Tuple එක වෙනස් කරන්න බෑ
    
student1 = ("Amara", 20, "Science")
process_student_data(student1)

Dictionary Keys සහ Set Elements විදිහට (As Dictionary Keys and Set Elements):Dictionaries වල keys සහ Sets වල elements hashable වෙන්න ඕන. ඒ කියන්නේ immutable වෙන්න ඕන. Lists mutable නිසා ඒවා dictionary keys හෝ set elements විදිහට පාවිච්චි කරන්න බෑ. හැබැයි Tuples immutable නිසා, ඒවා මේ තැන් වලට නියමෙටම ගැලපෙනවා.

# Tuple එකක් dictionary key එකක් විදිහට
locations = {
    (6.9271, 79.8612): "Colombo",
    (7.2906, 80.6337): "Kandy"
}
print(locations[(6.9271, 79.8612)]) # Output: Colombo

# Tuple එකක් set element එකක් විදිහට
unique_points = {(1, 2), (3, 4), (1, 2)}
print(unique_points) # Output: {(1, 2), (3, 4)} - duplicate එක remove වෙනවා

Fixed Data Sets (ස්ථාවර දත්ත කට්ටල):ඛණ්ඩාංක (coordinates), RGB වර්ණ කේත (RGB color codes), දින වකවානු (dates) වගේ වෙනස් වෙන්න හොඳ නැති දත්ත ගබඩා කරන්න Tuple එකක් පාවිච්චි කරන එක ආරක්ෂිතයි. මොකද මේවා වැරදීමකින්වත් වෙනස් වෙන්නේ නෑ.

# RGB වර්ණයක්
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

# නගරයක ඛණ්ඩාංක (Latitude, Longitude)
colombo_coords = (6.9271, 79.8612)
kandy_coords = (7.2906, 80.6337)

# මේවා immutable නිසා, වැරදීමකින් වෙනස් කරන්න බෑ
# colombo_coords[0] = 7.0 # TypeError!

ටියුපල්ස් පාවිච්චි කරද්දී පරිස්සම් වෙන්න: Errors සහ Best Practices (Be Careful When Using Tuples: Errors and Best Practices)

Tuples වල ප්‍රධානම ලක්ෂණය තමයි ඒවා immutable වීම. මේක හොඳ දෙයක් වුණත්, ඒකෙන් එන Error ගැන දැනගෙන ඉන්න එක වැදගත්.

TypeError: 'tuple' object does not support item assignment

අපි කලින් දැක්කා වගේ, Tuple එකක element එකක් වෙනස් කරන්න හැදුවොත් මේ Error එක එනවා. මේක වැරදීමක් නෙවෙයි, Tuple වල ක්‍රියාකාරීත්වයම තමයි. Tuple එකක් create කරාට පස්සේ ඒක ඇතුළේ තියෙන දත්ත වෙනස් කරන්න බෑ.

my_fixed_data = ("API_KEY_123", "v1.0", True)
# my_fixed_data[0] = "NEW_API_KEY" # මෙතනදී TypeError එකක් එනවා!

මතක තියාගන්න: Tuple එකක් ඇතුළේ mutable object එකක් (උදා: List එකක්) තිබ්බොත්, ඒ mutable object එකේ elements වෙනස් කරන්න පුළුවන්. හැබැයි Tuple එක ඇතුළේ mutable object එක තියෙන reference එක වෙනස් කරන්න බෑ.

my_complex_tuple = ("User1", [10, 20, 30], "Active")
print(my_complex_tuple) # Output: ('User1', [10, 20, 30], 'Active')

# Tuple එක ඇතුළේ තියෙන list එක වෙනස් කරන්න පුළුවන්
my_complex_tuple[1][0] = 100
print(my_complex_tuple) # Output: ('User1', [100, 20, 30], 'Active')

# හැබැයි tuple එකේ list එක තියෙන reference එක වෙනස් කරන්න බෑ
# my_complex_tuple[1] = [50, 60] # TypeError!

මේක ටිකක් සංකීර්ණයි නේද? සරලව කිව්වොත්, Tuple එකක් කියන්නේ elements වල references ටිකක් තියාගෙන ඉන්න කන්ටේනර් එකක් වගේ. ඒ references වෙනස් කරන්න බෑ. හැබැයි ඒ references වලින් පෙන්නන objects (ඒ කියන්නේ Lists වගේ mutable objects) වෙනස් කරන්න පුළුවන්.

Best Practices: Tuples vs. Lists

ඉතින් කවදද අපි Tuple එකක් පාවිච්චි කරන්නේ, කවදද List එකක් පාවිච්චි කරන්නේ?

• Data Immutability (දත්ත වෙනස් නොකිරීම):දත්ත කට්ටලයක් හැදුවාට පස්සේ ඒක වෙනස් වෙන්න හොඳ නෑ කියලා අපිට guarantee කරන්න ඕන නම්, Tuple එකක් පාවිච්චි කරන්න. උදාහරණයක් විදිහට, database connection details (host, port, user, password), cryptographic keys, configuration settings වගේ දේවල්.
• Performance (කාර්යක්ෂමතාවය):සාමාන්‍යයෙන් Tuples, Lists වලට වඩා පොඩ්ඩක් වේගවත්. ඒ වගේම memory භාවිතයත් ටිකක් අඩුයි. හැබැයි මේ වෙනස කැපී පෙනෙන්නේ ගොඩක් විශාල දත්ත කට්ටල එක්ක වැඩ කරද්දී විතරයි. පොඩි දේවල් වලට මේක එච්චර ලොකු බලපෑමක් කරන්නේ නෑ.
• Semantics (අර්ථය):ඔයාගේ data එකට structure එකක් තියෙනවා නම් (එකතුවක් විදිහට අර්ථයක් තියෙනවා නම්), Tuple එකක් පාවිච්චි කරන එක හොඳයි. උදාහරණයක් විදිහට, (x, y) කියන්නේ point එකක්. ("name", "age", "city") කියන්නේ කෙනෙක්ගේ විස්තර ටිකක්. මේවා එකට අයිති දේවල් කියලා පෙන්නන්න Tuple එකක් හොඳයි.
• Hashing (හැෂින්):Tuple එකක් immutable නිසා hashable වෙනවා. ඒ නිසා Dictionary keys සහ Set elements විදිහට පාවිච්චි කරන්න පුළුවන්. Lists එහෙම කරන්න බෑ.

සරලවම කිව්වොත්, ඔයාට එකතු කරන්න, අයින් කරන්න, වෙනස් කරන්න පුළුවන් collection එකක් ඕන නම් List එකක් පාවිච්චි කරන්න. දත්ත ස්ථාවරව තියාගන්න ඕන නම් Tuple එකක් පාවිච්චි කරන්න.

නිගමනය (Conclusion)

හරි යාලුවනේ, ඔන්න එහෙනම් අද අපි Python Tuples ගැන හොඳට කතා කලා. මුලින් ටිකක් අමාරු වගේ පෙනුනත්, මේක තේරුම් ගත්තම අපේ කෝඩ් එකේ ගුණාත්මකභාවය (quality) වැඩි කරගන්න කොච්චර උදව් වෙනවද කියලා තේරෙනවා. විශේෂයෙන්ම, immutable දත්ත කට්ටල (fixed data sets) සහ function වලින් multiple values return කරන අවස්ථා වලදී Tuples නියමෙටම ගැලපෙනවා.

මේවා කට පාඩම් කරනවට වඩා, ඔයාලාම Python IDE එකක් (PyCharm, VS Code) ඇරලා පොඩි පොඩි කෝඩ් කෑලි ලියලා බලන්න. Tuple එකක් හදලා, element එකක් වෙනස් කරන්න හදලා Error එක එන හැටි බලන්න. Unpacking කරලා බලන්න. එතකොට තව හොඳටම තේරෙයි.

අද කතා කරපු දේවල් ගැන ඔයාලගේ අදහස් මොනවද? ඔයාලා Tuples පාවිච්චි කරලා තියෙන cool use cases මොනවද? පහළින් comment එකක් දාගෙන යන්න අමතක කරන්න එපා. මේ වගේ තවත් Software Engineering කතා බහක් එක්ක ආයෙත් හම්බවෙමු! තවත් අලුත් දෙයක් ඉගෙනගන්නකම්!