Data Structures: Sets ගැන මුල ඉදන්ම ඉගෙන ගමු | SC Guide

වැඩ කරනකොට ඕනම Programer කෙනෙක්ට එන ප්‍රශ්නයක් තමයි Data handle කරන එක. දත්ත ගබඩා කරන, හොයන, වෙනස් කරන එකට විවිධ ක්‍රමවේද තියෙනවා. ඒ අතරින් සමහර තැන් වලට Set කියන Data Structure එක නියම විසඳුමක්. අද අපි මේ ගැන මුල ඉඳන්ම කතා කරමු.

හිතන්න ඔයාට ගොඩක් දත්ත තියෙනවා කියලා. ඒ දත්ත ඇතුලේ එකම දේ දෙපාරක් තියෙන්න බෑ, ඒ වගේම ඒ දත්ත තියෙන පිළිවෙල වැදගත් වෙන්නෙත් නෑ. මෙන්න මේ වගේ වෙලාවට තමයි Sets වලට තියෙන වටිනාකම තේරෙන්නේ. උදාහරණයක් විදියට, වෙබ් අඩවියකට ආපු අමුත්තෝ කී දෙනෙක්ද කියලා බලන්න ඕනේ නම්, එකම පුද්ගලයා කීප වතාවක් ආවත්, අපි ගණන් ගන්නේ එක පාරයි. මේ වගේ අවස්ථාවල Sets කියන්නේ සුපිරිම tool එකක්.

අද මේ post එකෙන් අපි Sets කියන්නේ මොනවද, ඒවා කොහොමද පාවිච්චි කරන්නේ, වගේම අපේ දිනපතා Programming වැඩ වලට Sets කොහොමද ප්‍රයෝජනවත් වෙන්නේ කියලා පියවරෙන් පියවර බලමු. Python වල උදාහරණ එක්ක කතා කරන නිසා වැඩේ එලටම අල්ලගන්න පුළුවන් වෙයි. පටන් ගමු එහෙනම්!

Sets කියන්නේ මොනවද? (Theory)

සරලවම කියනවා නම්, Set එකක් කියන්නේ unique elements වලින් හැදුනු unordered collection එකක්. මේ වාක්‍යයේ තියෙන වචන දෙක ගොඩක් වැදගත්.

• Unique Elements (අද්විතීය දත්ත): Set එකක් ඇතුලේ එකම element එක දෙපාරක් තියෙන්න බෑ. ඔයා එකම element එක කීප වතාවක් Set එකකට එකතු කරන්න හැදුවත්, ඒක ගබඩා වෙන්නේ එක පාරයි. මේක තමයි Lists වගේ අනිත් Data Structures වලින් Set එකක් වෙනස් වෙන්නේ.
• Unordered Collection (පිළිවෙලක් නැති එකතුව): Set එකක elements වලට නිශ්චිත පිලිවෙලක් නෑ. ඒ කියන්නේ ඔයා Set එකක් හදනකොට elements දාන පිලිවෙලටම ඒවා ආපහු ලබාගන්න බෑ. Indexing (my_set[0] වගේ) Set වලට කරන්න බෑ.

Set එකක Elements immutable වෙන්න ඕනේ. ඒ කියන්නේ ඒවා වෙනස් කරන්න බැරි දත්ත වර්ග වෙන්න ඕනේ. Strings, numbers, tuples මේ වගේ දේවල් Set එකකට දාන්න පුළුවන්. හැබැයි Lists, dictionaries වගේ mutable elements Set එකකට දාන්න බෑ. (TypeError: unhashable type: 'list' වගේ error එකක් එයි).

Python වල Set එකක් හදන්නේ කොහොමද?

Python වල Set එකක් හදන්න curly braces {} පාවිච්චි කරන්න පුළුවන්. හැබැයි හිස් Set එකක් හදනකොට set() කියලා පාවිච්චි කරන්න ඕනේ, මොකද {} කියන්නේ හිස් Dictionary එකක් නියෝජනය කරන්නයි.

# අංක වලින් Set එකක් හදන හැටි
numbers = {1, 2, 3, 4, 5}
print(numbers) # Output: {1, 2, 3, 4, 5}

# එකම අංක කීප වතාවක් දැම්මොත්
duplicate_numbers = {1, 2, 2, 3, 4, 4, 5}
print(duplicate_numbers) # Output: {1, 2, 3, 4, 5} - duplicates are automatically removed!

# Strings වලින් Set එකක් හදන හැටි
fruits = {"apple", "banana", "orange"}
print(fruits) # Output: {'banana', 'orange', 'apple'} (order can vary)

# List එකකින් Set එකක් හදන හැටි
my_list = [10, 20, 30, 20, 40]
set_from_list = set(my_list)
print(set_from_list) # Output: {40, 10, 20, 30} (order can vary)

# හිස් Set එකක් හදන හැටි (Important!)
empty_set = set()
print(empty_set) # Output: set()
print(type(empty_set)) # Output: <class 'set'>

# මේක හිස් dictionary එකක්
empty_dict = {}
print(type(empty_dict)) # Output: <class 'dict'>

දැන් ඔයාලට Sets වල මූලික අදහස තේරෙනවා ඇති කියලා හිතනවා. අපි දැන් බලමු Sets එක්ක කරන්න පුළුවන් ගණන් හදන වැඩ ටිකක්.

Set Operations - දත්ත වලට ගණන් හැදීම!

Sets වලට තියෙන තවත් ලොකු වාසියක් තමයි, ගණිතයේ තියෙන Set operations බොහොමයක් Programming වලටත් පාවිච්චි කරන්න පුළුවන් වීම. මේවා ගොඩක් ප්‍රයෝජනවත් වෙන්නේ දත්ත ගොඩවල් දෙකක් හෝ වැඩි ගණනක් අතර සම්බන්ධතා හොයනකොට.

1. Union (එකමුතුව)

දත්ත ගොඩවල් දෙකක හෝ වැඩි ගණනක තියෙන සියලුම unique elements එකතු කරලා අලුත් Set එකක් හදන එකට Union කියනවා. සංකේතය | නැත්නම් .union() method එක පාවිච්චි කරන්න පුළුවන්.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Using the | operator
union_result_op = set_a | set_b
print("Union (operator):", union_result_op) # Output: {1, 2, 3, 4, 5, 6}

# Using the .union() method
union_result_method = set_a.union(set_b)
print("Union (method):", union_result_method) # Output: {1, 2, 3, 4, 5, 6}

සෙට් දෙකේම තියෙන අංක 3, 4 එක පාරක් පමණක් union එකට ඇවිත් තියෙනවා කියලා හොඳට බලන්න. Sets වල unique elements වලට තියෙන වැදගත්කම මේකෙන් පැහැදිලි වෙනවා.

2. Intersection (ඡේදනය)

දත්ත ගොඩවල් දෙකක හෝ වැඩි ගණනක තියෙන පොදු elements විතරක් හොයන එකට Intersection කියනවා. සංකේතය & නැත්නම් .intersection() method එක පාවිච්චි කරන්න පුළුවන්.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Using the & operator
intersection_result_op = set_a & set_b
print("Intersection (operator):", intersection_result_op) # Output: {3, 4}

# Using the .intersection() method
intersection_result_method = set_a.intersection(set_b)
print("Intersection (method):", intersection_result_method) # Output: {3, 4}

set_a එකේයි set_b එකේයි පොදුවේ තියෙන්නේ 3 සහ 4 විතරයි. ඒක තමයි අපිට output එක විදියට ලැබිලා තියෙන්නේ.

3. Difference (වෙනස)

එක් Set එකක තියෙන, හැබැයි අනිත් Set එකේ නැති elements හොයන එකට Difference කියනවා. සංකේතය - නැත්නම් .difference() method එක පාවිච්චි කරන්න පුළුවන්. මේකේදී පිලිවෙල වැදගත්, මොකද A - B කියන්නේ B - A නෙවෙයි.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Elements in set_a but NOT in set_b
difference_ab_op = set_a - set_b
print("Difference (A - B operator):", difference_ab_op) # Output: {1, 2}

difference_ab_method = set_a.difference(set_b)
print("Difference (A - B method):", difference_ab_method) # Output: {1, 2}

# Elements in set_b but NOT in set_a
difference_ba_op = set_b - set_a
print("Difference (B - A operator):", difference_ba_op) # Output: {5, 6}

පළවෙනි එකෙන් set_a එකේ තියෙන set_b එකේ නැති 1, 2 කියන අංක ආවා. දෙවෙනි එකෙන් set_b එකේ තියෙන set_a එකේ නැති 5, 6 කියන අංක ආවා.

4. Symmetric Difference (සමමිතික වෙනස)

මේකෙන් හොයන්නේ Sets දෙකෙන් එකක විතරක් තියෙන elements ටික. ඒ කියන්නේ දෙකේම පොදුවේ තියෙන ඒවා හැර අනිත් ඔක්කොම. සංකේතය ^ නැත්නම් .symmetric_difference() method එක පාවිච්චි කරන්න පුළුවන්.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Using the ^ operator
sym_diff_result_op = set_a ^ set_b
print("Symmetric Difference (operator):", sym_diff_result_op) # Output: {1, 2, 5, 6}

# Using the .symmetric_difference() method
sym_diff_result_method = set_a.symmetric_difference(set_b)
print("Symmetric Difference (method):", sym_diff_result_method) # Output: {1, 2, 5, 6}

දැන් set_a සහ set_b කියන දෙකේම නැති (common නැති) elements ටික තමයි අපිට ලැබිලා තියෙන්නේ.

තවත් වැදගත් Set Methods: add(), remove(), discard(), pop(), clear()

Set එකක Elements වෙනස් කරන්නත් අපිට පුළුවන්. Set එකක් Mutable Data Structure එකක් නිසා මේක කරන්න පුළුවන්.

• .add(element): Set එකට අලුත් element එකක් එකතු කරනවා. ඒක කලින්ම තිබ්බා නම්, කිසිම වෙනසක් වෙන්නේ නෑ.
• .remove(element): Set එකෙන් element එකක් අයින් කරනවා. ඒ element එක Set එකේ නැත්නම් KeyError එකක් එනවා.
• .discard(element): Set එකෙන් element එකක් අයින් කරනවා. .remove() වගේමයි, හැබැයි element එක Set එකේ නැත්නම් error එකක් දෙන්නේ නෑ.
• .pop(): Set එකෙන් random element එකක් අයින් කරලා ඒක return කරනවා. Set එක හිස් නම් KeyError එකක් එනවා. (පිළිවෙලක් නැති නිසා random කියන එක වැදගත්.)
• .clear(): Set එකේ තියෙන හැම element එකක්ම අයින් කරනවා. Set එක හිස් කරනවා.

my_set = {10, 20, 30}
print("Original set:", my_set) # Output: {10, 20, 30}

my_set.add(40)
print("After add(40):", my_set) # Output: {10, 20, 30, 40}

my_set.add(20) # 20 is already there, no change
print("After add(20):", my_set) # Output: {10, 20, 30, 40}

my_set.remove(10)
print("After remove(10):", my_set) # Output: {20, 30, 40}

# my_set.remove(99) # This would raise a KeyError: 99

my_set.discard(30)
print("After discard(30):", my_set) # Output: {20, 40}

my_set.discard(99) # No error, because 99 is not in the set
print("After discard(99):", my_set) # Output: {20, 40}

popped_element = my_set.pop()
print("Popped element:", popped_element)
print("Set after pop():", my_set) # Output: {40} or {20} depending on which was popped

my_set.clear()
print("Set after clear():", my_set) # Output: set()

Practical Use Cases - දිනපතා වැඩ වලට Sets!

දැන් අපි බලමු මේ Sets අපිට දිනපතා Programming වැඩ වලට කොහොමද පාවිච්චි කරන්න පුළුවන් කියලා.

1. List එකකින් Duplicates අයින් කිරීම

මේක Sets වල තියෙන සුපිරිම feature එකක්. List එකක තියෙන duplicate elements අයින් කරලා unique elements විතරක් ගන්න Sets ගොඩක් ලේසියෙන් පාවිච්චි කරන්න පුළුවන්.

my_shopping_list = ["apple", "banana", "orange", "apple", "grape", "banana"]
print("Original List:", my_shopping_list)

# Convert to a set to remove duplicates, then convert back to a list
unique_items_set = set(my_shopping_list)
unique_shopping_list = list(unique_items_set)

print("Unique Items (as Set):", unique_items_set)
print("Unique Items (as List, order not guaranteed):", unique_shopping_list)

# Output:
# Original List: ['apple', 'banana', 'orange', 'apple', 'grape', 'banana']
# Unique Items (as Set): {'banana', 'grape', 'apple', 'orange'}
# Unique Items (as List, order not guaranteed): ['banana', 'grape', 'apple', 'orange']

හරිම ලේසියි නේද? මේක ගොඩක් Programming Problems වලට විසඳුමක් විදියට පාවිච්චි කරන්න පුළුවන්.

2. Membership Testing (ඉක්මන් සෙවීම්)

Set එකක යම්කිසි element එකක් තියෙනවද නැද්ද කියලා බලන එක (element in my_set) ගොඩක් වේගවත්. මේකට හේතුව Sets හදලා තියෙන්නේ Hash Table කියන සංකල්පය පාවිච්චි කරලා නිසා. ඒක නිසා විශාල දත්ත ගොඩවල් වල Quick Lookups වලට Sets ගොඩක් කාර්යක්ෂමයි (Efficiency එක O(1) average case).

# විශාල Set එකක් හදමු
large_data_set = set(range(1000000)) # 0 ඉඳන් 999999 වෙනකම් numbers

# යම්කිසි number එකක් තියෙනවද කියලා බලමු
print("Is 500000 in the set?", 500000 in large_data_set) # Output: True
print("Is 1000000 in the set?", 1000000 in large_data_set) # Output: False

# List එකක මෙහෙම බලනවා නම් ගොඩක් වෙලා යනවා (O(n) average case)
# large_data_list = list(range(1000000))
# print("Is 500000 in the list?", 500000 in large_data_list)

ඔයාලට විශාල දත්ත ගොඩක යම්කිසි අගයක් තියෙනවද කියලා ඉක්මනට හොයන්න අවශ්‍ය නම් Sets කියන්නේ හොඳම විසඳුම. උදාහරණයක් විදියට, දවසකට වෙබ් අඩවියකට එන IP addresses ලක්ෂ ගණනක් අතරින් මේ IP address එක කලින් ඇවිත් තියෙනවද නැද්ද කියලා බලන්න මේක පාවිච්චි කරන්න පුළුවන්.

3. Data Comparison (දත්ත සංසන්දනය)

දත්ත ගොඩවල් දෙකක් අතර වෙනස්කම්, පොදු දේවල් හොයන්න Set operations (Union, Intersection, Difference) ගොඩක් ප්‍රයෝජනවත්. උදාහරණයක් විදියට, Project එකක Dependencies දෙකක් අතර පොදු library, නැත්නම් එකක විතරක් තියෙන dependencies හොයන්න මේවා පාවිච්චි කරන්න පුළුවන්.

# Requirement lists for two projects
project_a_deps = {"numpy", "pandas", "matplotlib", "scikit-learn"}
project_b_deps = {"pandas", "django", "flask", "numpy"}

# Common dependencies (Intersection)
common_deps = project_a_deps.intersection(project_b_deps)
print("Common Dependencies:", common_deps) # Output: {'numpy', 'pandas'}

# Dependencies unique to Project A (Difference)
unique_to_a = project_a_deps.difference(project_b_deps)
print("Dependencies unique to Project A:", unique_to_a) # Output: {'matplotlib', 'scikit-learn'}

# All unique dependencies across both projects (Union)
all_deps = project_a_deps.union(project_b_deps)
print("All Unique Dependencies:", all_deps) # Output: {'django', 'flask', 'matplotlib', 'pandas', 'scikit-learn', 'numpy'}

මේ වගේ දේවල් වලට Sets වලින් ලැබෙන පහසුව අති විශාලයි.

Sets ගැන මතක තියාගන්න ඕන දේවල් (Review & Best Practices)

Sets වල වාසි වගේම, සමහර විශේෂතාත් මතක තියාගන්න ඕනේ.

• No Order, No Indexing: අපි කලින් කතා කරා වගේ Sets වලට නිශ්චිත පිලිවෙලක් නෑ. ඒ නිසා my_set[0] වගේ Indexing කරන්න බෑ. ඔයාට Elements වලට access වෙන්න ඕනේ නම් for loop එකක් පාවිච්චි කරන්න පුළුවන්.
• Mutable Elements Cannot Be Stored: Lists, Dictionaries, සහ අනිත් Sets (frozenset හැර) වගේ වෙනස් කරන්න පුළුවන් (mutable) elements Set එකක් ඇතුලේ ගබඩා කරන්න බෑ. මොකද Set එකේ elements hashable වෙන්න ඕනේ, හැබැයි mutable objects hashable නෑ.
• Performance: Duplicate remove කරන්න, membership test කරන්න වගේම Set operations වලට Sets ගොඩක් වේගවත්. ඒත් Order එකක් අවශ්‍ය නම්, නැත්නම් duplicate elements තියාගන්න ඕනේ නම් Lists පාවිච්චි කරන එක වඩා හොඳයි.

කවදාද Sets පාවිච්චි කරන්නේ?

• Unique elements collection එකක් අවශ්‍ය නම්.
• යම්කිසි element එකක් collection එකක තියෙනවද නැද්ද කියලා ගොඩක් ඉක්මනට බලන්න අවශ්‍ය නම්.
• ගණිතමය Set operations (Union, Intersection, Difference) කරන්න අවශ්‍ය නම්.

කවදාද Sets පාවිච්චි නොකරන්නේ?

• Elements වල order එක වැදගත් නම්.
• Duplicate elements තියාගන්න අවශ්‍ය නම්.
• Elements වලට Indexing හරහා access වෙන්න අවශ්‍ය නම්.

නිගමනය (Conclusion)

ඉතින් යාලුවනේ, Sets කියන්නේ Programming වලදී අපිට ගොඩක් ප්‍රයෝජනවත් වෙන Data Structure එකක්. විශේෂයෙන්ම Unique Data Manage කරන්නයි, දත්ත ගොඩවල් අතර තියෙන සම්බන්ධතා හොයන්නයි Sets වලට තියෙන හැකියාව අති විශාලයි. Lists, Tuples, Dictionaries වගේම Sets වලටත් තමන්ගේම කියලා විශේෂ තැනක් තියෙනවා.

මේ Concepts තේරුම් ගන්න විතරක් මදි, අතේ හුරුපුරුදු වෙන්නත් ඕනේ. ඒ නිසා ඔයාලත් මේ concepts ටික පාවිච්චි කරලා පොඩි program එකක් ලියලා බලන්න. උදාහරණයක් විදියට, email addresses list එකකින් unique email addresses ටික විතරක් filter කරන්න, නැත්නම් යාළුවෝ group දෙකක ඉන්න common friends ලා හොයන්න වගේ දේවල් කරලා බලන්න.

මේ post එක ඔයාලට Sets ගැන හොඳ අවබෝධයක් ලබා දෙන්න ඇති කියලා මම විශ්වාස කරනවා. මොනවා හරි ප්‍රශ්න තියෙනවා නම් නැත්නම් අලුත් අදහසක් තියෙනවා නම්, අනිවාර්යයෙන්ම comment section එකේ කියන්න. ඔයාලගේ අදහස් දැනගන්න මම ගොඩක් කැමතියි. සුභ දවසක්!