ආයුබෝවන් කස්ටියටම! දත්ත ටිකක් පිළිවෙලට තියාගන්න හැටි ඉගෙනගමු!

කොහොමද ඉතින් ඔයාලට? Tech ලෝකේ දියුණු වෙන්න දඟලන හැමෝම සාදරයෙන් පිළිගන්නවා අපේ අලුත්ම Ghost Blog Post එකට! අද අපි කතා කරන්න යන්නේ ඔයාලා හැමෝටම Software Engineering පාරේ යනකොට නැතුවම බැරි Data Structure එකක් ගැන. ඒ තමයි Dictionaries!

දත්ත කියන්නේ අද ලෝකේ රන් හා සමාන දෙයක්. ඉතින් ඒ දත්ත ටිකක් හරි පිළිවෙලකට, ක්‍රමවත්ව තියාගන්න බැරි නම්, ඒක හොයාගන්නත්, පාවිච්චි කරන්නත්, වෙනස් කරන්නත් අමාරු වෙනවා. හිතන්නකෝ ඔයාගේ යාළුවෝ දහස් ගාණකගේ නම් ලිස්ට් එකක්, ඒ හැමෝගේම ෆෝන් නම්බර්, ගෙවල්වල ලිපිනයන්, කැමති කෑම වර්ග වගේ දත්ත ගොඩක් තියෙනවා කියලා. ඒක අහුමුළු නැති ගුදමක් වගේ නම්, ඕන වෙලාවට ඕන දත්තයක් හොයාගන්න පුදුම අමාරුවක් නේද?

අන්න ඒ වගේ අවස්ථා වලදී අපිට Dictionaries කියන Data Structure එක තමයි පිහිටට එන්නේ. මේක හරියට පොත් රාක්කයක් වගේ. හැම පොතකටම තියෙනවා අඳුරගන්න ලේබල් එකක් (Key එකක්). ඒ ලේබල් එකෙන් අපිට පුළුවන් පොතේ තියෙන විස්තර (Value එක) හොයාගන්න. මේක List එකකට වඩා වෙනස්, මොකද List එකක නම් දත්ත තියෙන්නේ Index එකකට අනුව (0, 1, 2, ...). ඒත් Dictionary එකක තියෙන්නේ unique Key එකකට අදාළ Value එකක්!

අද අපි බලමු මේ Dictionaries කියන්නේ මොකක්ද, ඒවා හදන්නේ කොහොමද, පාවිච්චි කරන්නේ කොහොමද, ඒ වගේම අපිට වැඩේ කරගන්න උදව් වෙන methods ටිකකුත්. ඒ විතරක් නෙවෙයි, මේවා පාවිච්චි කරනකොට එන පොඩි පොඩි අවුල් (Errors) විසඳගන්නෙ කොහොමද, හොඳටම Dictionary එකක් පාවිච්චි කරන්නේ කොහොමද කියලත් අපි කතා කරමු.

Dictionary එකක රහස: Key-Value Pairs

Dictionary එකක් කියන්නේ Key-Value Pairs එකතුවක්. හරියට අපේ ගෙදර තියෙන cupboard එකක් වගේ. cupboard එකේ තියෙන හැම ලාච්චුවකටම නමක් (Key එකක්) තියෙනවා. ඒ නමෙන් අපිට පුළුවන් ඒ ලාච්චුවේ තියෙන බඩු ටික (Value එක) හොයාගන්න. මේ Key එක හැමවිටම unique වෙන්න ඕනේ. එකම Key එකෙන් Values දෙකක් තියෙන්න බැහැ. ඒත් Values නම් duplicate වෙන්න පුළුවන්. ඒ කියන්නේ එකම බඩු කට්ටිය ලාච්චු දෙක තුනක තියෙන්න පුළුවන්, හැබැයි ලාච්චු දෙකකට එකම නමක් තියෙන්න බැහැනේ?

Python වලදී Dictionaries ලියන්නේ curly braces {} ඇතුලෙ. Key එකයි Value එකයි වෙන් කරන්නේ colon : එකකින්. හැම Key-Value Pair එකක්ම වෙන් කරන්නේ comma , එකකින්.

සරල උදාහරණයක් බලමු:

# ශිෂ්‍යයෙක්ගේ විස්තර Dictionary එකක තියාගමු
student_info = {
    "name": "නිමාෂා පෙරේරා",
    "age": 22,
    "major": "Computer Science",
    "grades": {"Math": "A", "Physics": "B+", "Programming": "A+"},
    "is_active": True
}

# මෙතන "name", "age", "major" කියන්නේ Keys. 
# "නිමාෂා පෙරේරා", 22, "Computer Science" කියන්නේ Values.

මේ Dictionary එකේ Keys විදියට Strings ("name", "age") වගේම Numbers (අපි උදාහරණයක් විදියට Keys විදියට නම්බර්ස් පාවිච්චි කළේ නැති වුණාට ඒක කරන්න පුළුවන්) වුණත් පාවිච්චි කරන්න පුළුවන්. ඒ වගේම Values විදියට Strings, Numbers, Booleans, Lists, නැත්නම් තවත් Dictionary එකක් වුණත් පාවිච්චි කරන්න පුළුවන්. මේකේ Key එකක් හැමවිටම Immutable (වෙනස් කරන්න බැරි) data type එකක් වෙන්න ඕනේ (e.g., strings, numbers, tuples). නමුත් Value එකක් Mutable (වෙනස් කරන්න පුළුවන්) හෝ Immutable වෙන්න පුළුවන්.

Dictionary එකක් හදමු, දත්ත ටිකක් බලමු

1. Dictionary එකක් හදන හැටි

හිස් Dictionary එකක් හදාගන්න පුළුවන් මේ විදියට:

empty_dict = {}
print(empty_dict) # Output: {}

නැත්නම් මුලින්ම දත්ත ටිකක් එක්කම Dictionary එකක් හදාගන්නත් පුළුවන්:

# ක්‍රිකට් ටීම් එකක players ලාගේ scores ටිකක්
cricket_scores = {
    "ලාහිරු": 85,
    "අකිල": 32,
    "සමන්": 50,
    "කමල්": 12
}
print(cricket_scores) 
# Output: {'ලාහිරු': 85, 'අකිල': 32, 'සමන්': 50, 'කමල්': 12}

dict() constructor එක පාවිච්චි කරලත් අපිට Dictionary එකක් හදාගන්න පුළුවන්. විශේෂයෙන්ම, Key-Value pairs list එකක් තියෙනවා නම්, එහෙම නැත්නම් keyword arguments විදියට Keys assign කරලා.

# dict() constructor එක පාවිච්චි කරලා
products = dict(apple=150, banana=50, orange=100)
print(products)
# Output: {'apple': 150, 'banana': 50, 'orange': 100}

# List of tuples විදියට
student_list = [('ID001', 'ආලෝක'), ('ID002', 'සහන්'), ('ID003', 'කාවින්දි')]
student_names = dict(student_list)
print(student_names)
# Output: {'ID001': 'ආලෝක', 'ID002': 'සහන්', 'ID003': 'කාවින්දි'}

2. Dictionary එකකින් Value එකක් හොයන හැටි

Value එකක් හොයන්න නම් අදාළ Key එක square brackets [] ඇතුලෙ දෙන්න ඕනේ:

student_info = {
    "name": "නිමාෂා පෙරේරා",
    "age": 22,
    "major": "Computer Science"
}

# නම ගන්න
print(student_info["name"]) # Output: නිමාෂා පෙරේරා

# වයස ගන්න
print(student_info["age"])  # Output: 22

3. Value එකක් වෙනස් කරන හැටි නැත්නම් අලුතින් එකතු කරන හැටි

තියෙන Key එකකට අලුත් Value එකක් assign කලාම ඒ Key එකේ තියෙන Value එක update වෙනවා. නැත්නම් අලුත් Key එකක් දීලා Value එකක් assign කලාම අලුත් Key-Value Pair එකක් Dictionary එකට එකතු වෙනවා.

student_info = {
    "name": "නිමාෂා පෙරේරා",
    "age": 22,
    "major": "Computer Science"
}

# Major එක වෙනස් කරමු
student_info["major"] = "Software Engineering"
print(student_info) 
# Output: {'name': 'නිමාෂා පෙරේරා', 'age': 22, 'major': 'Software Engineering'}

# අලුත් Key-Value pair එකක් එකතු කරමු
student_info["university"] = "UCSC"
print(student_info) 
# Output: {'name': 'නිමාෂා පෙරේරා', 'age': 22, 'major': 'Software Engineering', 'university': 'UCSC'}

වැඩේට ඕන වෙන Dictionary Methods

Python Dictionaries පාවිච්චි කරනකොට අපිට වැඩේ පහසු කරගන්න පුළුවන් Methods ගොඩක් තියෙනවා. අපි වැදගත්ම ටිකක් බලමු.

keys()

මේ method එකෙන් Dictionary එකේ තියෙන හැම Key එකක්ම ගන්න පුළුවන්.

student_grades = {
    "Math": "A",
    "Physics": "B+",
    "Programming": "A+"
}

all_keys = student_grades.keys()
print(all_keys) # Output: dict_keys(['Math', 'Physics', 'Programming'])

# Keys එකින් එක print කරන්න for loop එකක් පාවිච්චි කරන්න පුළුවන්
for key in student_grades.keys():
    print(key)
# Output:
# Math
# Physics
# Programming

values()

මේකෙන් කරන්න පුළුවන් Dictionary එකේ තියෙන හැම Value එකක්ම ගන්න එක.

student_grades = {
    "Math": "A",
    "Physics": "B+",
    "Programming": "A+"
}

all_values = student_grades.values()
print(all_values) # Output: dict_values(['A', 'B+', 'A+'])

# Values එකින් එක print කරන්න
for value in student_grades.values():
    print(value)

items()

මේකෙන් Key-Value pairs ඔක්කොම tuple විදියට ගන්න පුළුවන්. මේක for loop එකකදී Keys සහ Values දෙකම එකට access කරන්න පුදුම විදියට ප්‍රයෝජනවත් වෙනවා.

student_grades = {
    "Math": "A",
    "Physics": "B+",
    "Programming": "A+"
}

all_items = student_grades.items()
print(all_items) 
# Output: dict_items([('Math', 'A'), ('Physics', 'B+'), ('Programming', 'A+')])

# Keys and Values දෙකම print කරන්න
for subject, grade in student_grades.items():
    print(f"Subject: {subject}, Grade: {grade}")
# Output:
# Subject: Math, Grade: A
# Subject: Physics, Grade: B+
# Subject: Programming, Grade: A+

get()

Value එකක් access කරනකොට [] පාවිච්චි කරනවා වගේම get() method එකත් පාවිච්චි කරන්න පුළුවන්. මේකෙන් තියෙන ලොකුම වාසිය තමයි, අපි හොයන Key එක Dictionary එකේ නැත්නම් Error එකක් එන එක නවත්වන එක. ඒ වෙනුවට None කියලා default Value එකක් return කරනවා. අපිට කැමති default Value එකක් දෙන්නත් පුළුවන්.

student_info = {
    "name": "නිමාෂා පෙරේරා",
    "age": 22
}

# තියෙන Key එකක් access කරමු
print(student_info.get("name"))  # Output: නිමාෂා පෙරේරා

# නැති Key එකක් access කරමු
print(student_info.get("major")) # Output: None (Error එකක් එන්නේ නැහැ)

# Default Value එකක් එක්ක access කරමු
print(student_info.get("city", "Not Specified")) # Output: Not Specified

pop()

මේ method එකෙන් Dictionary එකෙන් Key-Value Pair එකක් අයින් කරලා, අයින් කරපු Value එක return කරනවා.

student_grades = {
    "Math": "A",
    "Physics": "B+",
    "Programming": "A+"
}

# 'Physics' subject එක අයින් කරමු
removed_grade = student_grades.pop("Physics")
print(f"Removed grade: {removed_grade}") # Output: Removed grade: B+
print(student_grades)
# Output: {'Math': 'A', 'Programming': 'A+'}

# නැති Key එකක් pop කරන්න හැදුවොත් error එකක් එනවා
# ඒක වළක්වන්න default Value එකක් දෙන්න පුළුවන්
not_existing = student_grades.pop("Chemistry", "Not Found")
print(f"Result for non-existing key: {not_existing}") # Output: Result for non-existing key: Not Found

අවුල් ටිකක් විසඳගමු: KeyError සහ Keys

KeyError එකක් කියන්නේ මොකක්ද?

මේක තමයි Dictionaries එක්ක වැඩ කරනකොට නිතරම වගේ එන පොදු Error එකක්. KeyError එකක් එන්නේ අපි Dictionary එකක නැති Key එකකින් Value එකක් access කරන්න හැදුවොත්. හරියට ඔයා cupboard එකේ නැති ලාච්චුවක් හොයනවා වගේ වැඩක්.

student_info = {
    "name": "සමන් කුමාර"
}

# මේකෙන් KeyError එකක් එනවා මොකද 'age' කියන Key එක මේ Dictionary එකේ නැහැ
# print(student_info["age"]) # Uncomment කරලා බලන්න KeyError එක එන හැටි

මේක වළක්වගන්න අපිට get() method එක පාවිච්චි කරන්න පුළුවන්, නැත්නම් in operator එකෙන් Key එක තියෙනවද කියලා check කරන්න පුළුවන්.

student_info = {
    "name": "සමන් කුමාර"
}

# Key එක තියෙනවද කියලා බලමු
if "age" in student_info:
    print(student_info["age"])
else:
    print("Age information not available.") # Output: Age information not available.

# get() method එක පාවිච්චි කරමු
print(student_info.get("age", "Age information not available.")) # Output: Age information not available.

Mutable vs. Immutable Keys

මතක තියාගන්න Dictionary Keys හැමවිටම Immutable data types වෙන්න ඕනේ. ඒ කියන්නේ ඒවා හදපු පස්සේ වෙනස් කරන්න බැරි ඒවා වෙන්න ඕනේ. Strings, Numbers (integers, floats), සහ Tuples කියන්නේ Immutable data types. Lists, Sets, සහ වෙනත් Dictionaries කියන්නේ Mutable data types. ඒ නිසා මේවා Keys විදියට පාවිච්චි කරන්න බැහැ.

# මේවා Keys විදියට පාවිච්චි කරන්න පුළුවන් (Immutable)
valid_dict = {
    "name": "ප්‍රියංකා",
    123: "නොම්බරය",
    (1, 2): "tuple එකක්"
}
print(valid_dict)

# මේකෙන් TypeError එකක් එනවා මොකද List එකක් Key විදියට පාවිච්චි කරන්න බැහැ (Mutable)
# invalid_dict = {[1, 2]: "list key"} # Uncomment කරලා බලන්න TypeError එක එන හැටි

List එකක් mutable නිසා, ඒකේ අගය වෙනස් වුණොත් Key එක අඳුරගන්න බැරි වෙනවා. ඒ නිසා තමයි Python එක මේකට ඉඩ නොදෙන්නේ.

හොඳටම Dictionary එකක් පාවිච්චි කරමු: Best Practices

හරි, දැන් අපි Dictionaries ගැන හොඳටම ඉගෙනගත්තා. දැන් බලමු මේවා ප්‍රයෝජනවත් විදියට, 효율මත්ව (efficiently) පාවිච්චි කරන්නේ කොහොමද කියලා.

Memory Usage ගැනත් හිතන්න

Dictionaries List එකකට වඩා Memory වැඩිපුර ගන්න පුළුවන්. මොකද Key-Value pairs වලට අමතරව Keys manage කරන්නත් extra memory යනවා. ඒ නිසා පොඩි, simple data sets වලට List එකක් හොඳයි. නමුත් Complex relationships තියෙන, නිතරම lookup කරන්න වෙන data වලට Dictionary එකක් තමයි best.

ලොකු Data Set වලට Dictionaries පාවිච්චි කරන්න

Dictionary එකක් කියන්නේ දත්ත හොයන්න පුදුම විදියට වේගවත් Data Structure එකක්. Key එකක් දීලා Value එකක් හොයන්න (lookup) යන වෙලාව දත්ත ප්‍රමාණය මත වැඩි වෙන්නේ නැහැ. (Average case O(1) complexity). ඒ නිසා විශාල දත්ත ප්‍රමාණයක් තියෙනකොට Dictionaries පාවිච්චි කරන එක ලොකු වාසියක්.

get() method එක නිතරම පාවිච්චි කරන්න

විශේෂයෙන්ම ඔයාට විශ්වාස නැත්නම් Key එක Dictionary එකේ තියෙනවද කියලා. KeyError එකක් ඇවිත් ඔයාගේ Program එක crash වෙනවට වඩා None එකක් නැත්නම් default Value එකක් return වෙන එක හොඳයි නේද?

Keys වලට Consistency තියාගන්න

ඒ කියන්නේ, ඔයා Keys වලට camelCase (studentName) පාවිච්චි කරනවා නම් හැම Key එකකටම ඒකම පාවිච්චි කරන්න. snake_case (student_name) පාවිච්චි කරනවා නම් හැම එකටම ඒකම පාවිච්චි කරන්න. ඒකෙන් Code එක පිළිවෙලයි, කියවන්නත් ලේසියි.

Descriptive Keys පාවිච්චි කරන්න

ඔයාගේ Keys වලට තේරුමක් තියෙන නම් දෙන්න. x, y, z වගේ නම් දෙනවට වඩා "student_name", "enrollment_date" වගේ නම් දෙන එකෙන් Code එක කියවන අයට තේරුම් ගන්න ලේසියි.

# නරක පුරුද්දක්
d = {'n': 'අමිලා', 'a': 25}

# හොඳ පුරුද්දක්
student = {'name': 'අමිලා', 'age': 25}

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

අද අපි Dictionaries ගැන ලොකු ගමනක් ආවා නේද? Key-Value pairs කියන්නේ මොකක්ද, ඒවා හදන්නේ කොහොමද, Values හොයන්නේ කොහොමද, ඒ වගේම අපිට උදව් වෙන methods ටිකයි, පොඩි පොඩි අවුල් විසඳගන්න හැටි වගේම හොඳම පුරුදු ටිකකුත් අපි ඉගෙනගත්තා.

Dictionaries කියන්නේ Python වල වගේම වෙනත් Programming Languages වලත් (Hash Maps, Hash Tables, Associative Arrays වගේ නම් වලින්) ඉතාම වැදගත් Data Structure එකක්. Data Management, Database Operations, Configuration Settings, Caching වගේ තැන් ගොඩකට මේවා පාවිච්චි කරනවා. ඉතින් මේක හොඳට තේරුම් ගන්න එක ඔයාලගේ Software Engineering Skills වලට ලොකු ශක්තියක්.

දැන් ඉතින් අතපය වනලා විතරක් මදි. ඔයාලත් මේවා ඔයාලගේ Code Editor එකේ Run කරලා බලන්න. පොඩි පොඩි Dictionaries හදලා Keys, Values, Items අරගෙන, get(), pop() වගේ Methods ටික පාවිච්චි කරලා බලන්න. KeyError එකක් එන විදියට හදලා, ඒක get() එකෙන් විසඳගන්න හැටිත් බලන්න.

ඔයාලගේ අදහස්, මේ ගැන තියෙන ප්‍රශ්න, නැත්නම් ඔයාලා Dictionaries පාවිච්චි කරපු interesting use cases තියෙනවා නම්, පහලින් comment එකක් දාගෙන යන්න. ඒක අනිත් අයටත් ගොඩක් වටිනවා. අපි තවත් මේ වගේ වැදගත් Blog Post එකකින් හමුවෙමු! Happy Coding!