පයිතන් කොම්ප්‍රිහෙන්ෂන්ස්: ඔබේ කෝඩ් එකට සුපිරි බලයක්! (SC Guide)

හලෝ යාළුවනේ! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ Python වල තියෙන සුපිරිම ෆීචර් එකක් ගැන – ඒ තමයි Comprehensions! කෝඩ් කරනකොට සමහර වෙලාවට අපිට එකම විදිහේ දේවල් ගොඩක් කරන්න වෙනවා නේද? උදාහරණයක් විදිහට, ලිස්ට් එකක තියෙන හැම අයිටම් එකක්ම වෙනස් කරලා අලුත් ලිස්ට් එකක් හදන්න, නැත්නම් යම් කොන්දේසියකට අනුව දත්ත ෆිල්ටර් කරන්න. සාමාන්‍යයෙන් ඔයාලා මේකට for ලූප් පාවිච්චි කරනවා ඇති. ඒත්, for ලූප් එකක් පාවිච්චි කරනවට වඩා ලස්සනට, කොටින්, ඉක්මනින් මේ වගේ වැඩ කරන්න පුළුවන් ක්‍රමයක් තමයි Comprehensions කියන්නේ.

මේවා අපි ප්‍රධාන වශයෙන් කොටස් තුනකට කඩාගෙන බලමු:

1. List Comprehensions
2. Dictionary Comprehensions
3. Set Comprehensions

මොනවද මේවායින් වෙන්නේ? කෙටියෙන් කියනවා නම්, List Comprehension එකකින් List එකක් හදනවා, Dictionary Comprehension එකකින් Dictionary එකක් හදනවා, Set Comprehension එකකින් Set එකක් හදනවා. මේ ඔක්කොම කරන්නේ එකම කෝඩ් ලයින් එකකින්! ආ, තව දෙයක්, මේවාට Conditional Logic එහෙමත් දාන්න පුළුවන්. එහෙනම් අපි බලමු මේවා කොහොමද වැඩ කරන්නේ කියලා.

1. ලිස්ට් කොම්ප්‍රිහෙන්ෂන්ස් (List Comprehensions) - කෝඩ් එකට සුපිරි බලයක්!

List Comprehension කියන්නේ Python වල List හදන්න තියෙන විප්ලවීය ක්‍රමයක්. සාමාන්‍ය for ලූප් එකක් පාවිච්චි කරලා List එකක් හදනවට වඩා මේක ගොඩක් සරලයි, පැහැදිලියි, වගේම වේගවත්. මේක 'Pythonic' කෝඩ් ලියන්න ගොඩක් උදව් වෙනවා.

සාමාන්‍ය for ලූප් එක සහ List Comprehension එක

අපි හිතමු 1 ඉඳන් 10ට යනකල් තියෙන ඉලක්කම් වල වර්ග (squares) අලුත් List එකකට ගන්න ඕන කියලා. සාමාන්‍ය for ලූප් එකක් පාවිච්චි කරනවා නම්, අපි මෙහෙම ලියනවා නේද?

squares = []
for i in range(1, 11):
    squares.append(i**2)
print(squares)
# Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

මේකම List Comprehension එකකින් ලියන්න පුළුවන් එකම කෝඩ් ලයින් එකකින්:

squares = [i**2 for i in range(1, 11)]
print(squares)
# Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

දැක්කනේ වෙනස? කෝඩ් එක කොච්චර කෙටිද, පැහැදිලිද කියලා! Syntax එක මතක තියාගන්න ලේසියි: [expression for item in iterable].

• expression: List එකට add කරන්න ඕන value එක.
• item: Iterable එකේ තියෙන එකින් එක item එක.
• iterable: List, Tuple, Range වගේ දත්ත එකතුවක්.

කොන්දේසි සහිත List Comprehensions (Conditional List Comprehensions)

අපිට List එකක් හදනකොට යම් කොන්දේසියක් අනුව දත්ත ෆිල්ටර් කරන්නත් පුළුවන්. ඒකට අපි if statement එකක් පාවිච්චි කරනවා. Syntax එක [expression for item in iterable if condition].

උදාහරණයක් විදිහට, 1 ඉඳන් 20ට යනකල් තියෙන ඉලක්කම් වලින් ඉරට්ටේ සංඛ්‍යා (even numbers) විතරක් ගන්න ඕන නම්:

even_numbers = [num for num in range(1, 21) if num % 2 == 0]
print(even_numbers)
# Output: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

තව දුරටත් if-else කොන්දේසි දාලාත් මේක පාවිච්චි කරන්න පුළුවන්. හැබැයි එතකොට syntax එක ටිකක් වෙනස් වෙනවා: [expression if condition else another_expression for item in iterable].

උදාහරණයක් විදිහට, ඉලක්කම් ඉරට්ටේද ඔත්තේ (odd)ද කියලා ලිස්ට් කරන්න:

even_odd_list = ["Even" if num % 2 == 0 else "Odd" for num in range(1, 6)]
print(even_odd_list)
# Output: ['Odd', 'Even', 'Odd', 'Even', 'Odd']

2. ඩික්ෂනරි කොම්ප්‍රිහෙන්ෂන්ස් (Dictionary Comprehensions) - දත්ත සංවිධානයට අලුත් ක්‍රමයක්!

List Comprehensions වගේම, Dictionary Comprehensions වලින් අපිට කෙටියෙන්, පැහැදිලිව Dictionaries හදන්න පුළුවන්. Dictionaries කියන්නේ Key-Value Pairs තියෙන Data Structure එකක්නේ. මේ ක්‍රමය ගොඩක් ප්‍රයෝජනවත් වෙන්නේ අපිට පවතින දත්ත එකතුවකින් අලුත් Dictionary එකක් හදාගන්න අවශ්‍ය වුණාමයි.

සාමාන්‍ය for ලූප් එක සහ Dictionary Comprehension එක

අපි හිතමු වචන List එකක තියෙන වචන සහ ඒ වචන වල දිග (length) පාවිච්චි කරලා Dictionary එකක් හදන්න ඕන කියලා:

words = ["apple", "banana", "cherry", "date"]
word_lengths = {}
for word in words:
    word_lengths[word] = len(word)
print(word_lengths)
# Output: {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}

මේකම Dictionary Comprehension එකකින් මෙහෙම ලියන්න පුළුවන්:

words = ["apple", "banana", "cherry", "date"]
word_lengths = {word: len(word) for word in words}
print(word_lengths)
# Output: {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}

Syntax එක මෙහෙමයි: {key_expression: value_expression for item in iterable}.

• key_expression: Dictionary එකේ Key එක වෙන්න ඕන value එක.
• value_expression: Dictionary එකේ Value එක වෙන්න ඕන value එක.
• item: Iterable එකේ තියෙන item එක.
• iterable: List, Tuple, Range, හෝ වෙනත් Iterable එකක්.

කොන්දේසි සහිත Dictionary Comprehensions

Dictionary Comprehensions වලටත් අපිට if කොන්දේසි දාන්න පුළුවන්. උදාහරණයක් විදිහට, උඩ තියෙන words List එකෙන් අකුරු 5ට වඩා දිග වචන විතරක් Dictionary එකට ගන්න ඕන නම්:

words = ["apple", "banana", "cherry", "date"]
long_word_lengths = {word: len(word) for word in words if len(word) > 5}
print(long_word_lengths)
# Output: {'banana': 6, 'cherry': 6}

දැන් ඔයාලට පේනවා ඇති මේවා කොච්චර powerful ද කියලා නේද? Dictionary එකක් හදන එකත් දැන් කෙලින්ම එක ලයින් එකකින් කරගන්න පුළුවන්.

3. සෙට් කොම්ප්‍රිහෙන්ෂන්ස් (Set Comprehensions) - අද්විතීය දත්ත වලට කෙටි මගක්!

Sets කියන්නේ Python වල තියෙන තව එක දත්ත ව්‍යුහයක්. මේවායේ විශේෂත්වය තමයි duplicates (ආවර්තන) තියෙන්න බැරි වීම. Set Comprehensions වලින් අපිට ඉක්මනින් Sets හදාගන්න පුළුවන්, ඒ වගේම duplicate values automatically අයින් වෙනවා.

සාමාන්‍ය for ලූප් එක සහ Set Comprehension එක

අපි හිතමු string එකක තියෙන අකුරු Set එකකට ගන්න ඕන කියලා. ඒකෙන් duplicate අකුරු අයින් වෙලා යනවා:

my_string = "hello world"
unique_chars = set()
for char in my_string:
    unique_chars.add(char)
print(unique_chars)
# Output: {'l', 'r', 'd', ' ', 'o', 'e', 'h', 'w'}

මේකම Set Comprehension එකකින් ලියන්න පුළුවන්:

my_string = "hello world"
unique_chars = {char for char in my_string}
print(unique_chars)
# Output: {'l', 'r', 'd', ' ', 'o', 'e', 'h', 'w'}

Syntax එක List Comprehensions වලට ගොඩක් සමානයි, හැබැයි මෙතන අපි curly braces {} පාවිච්චි කරනවා: {expression for item in iterable}.

කොන්දේසි සහිත Set Comprehensions

Set Comprehensions වලටත් if කොන්දේසි එකතු කරන්න පුළුවන්. උදාහරණයක් විදිහට, ඉලක්කම් List එකක තියෙන ඉරට්ටේ සංඛ්‍යා වල වර්ග Set එකකට ගන්න:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares_set = {num**2 for num in numbers if num % 2 == 0}
print(even_squares_set)
# Output: {64, 4, 36, 100, 16}

දැන් ඔයාලට List, Dictionary, Set Comprehensions කියන්නේ මොනවද, ඒවා කොහොමද පාවිච්චි කරන්නේ කියලා හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා.

4. ප්‍රායෝගික උදාහරණ සහ හොඳම පුරුදු (Practical Examples & Best Practices)

පවතින ලූප් නැවත ලිවීම (Rewriting Existing Loops)

අපි පොඩි scenario එකක් අරන් බලමු. අපිට users කියන List එකක් තියෙනවා, ඒකේ හැම user කෙනෙක්ම Dictionary එකක් විදිහට තියෙනවා. අපිට ඕන වයස 30ට වැඩි user ලාගේ නම් (names) විතරක් List එකකට ගන්න.

සාමාන්‍ය for ලූප් එකෙන්:

users = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 32},
    {"name": "Charlie", "age": 28},
    {"name": "David", "age": 35}
]

older_users = []
for user in users:
    if user["age"] > 30:
        older_users.append(user["name"])

print(older_users)
# Output: ['Bob', 'David']

List Comprehension එකෙන්:

users = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 32},
    {"name": "Charlie", "age": 28},
    {"name": "David", "age": 35}
]

older_users = [user["name"] for user in users if user["age"] > 30]

print(older_users)
# Output: ['Bob', 'David']

දැන් පේනවා නේද, කෝඩ් එක කොච්චර clean ද කියලා? මේක 'Pythonic way' කියලා කියන්නේ මේ වගේ දේවල් වලට තමයි.

කීයටවත් කරන්න එපා! (Readability vs. Conciseness)

Comprehensions පාවිච්චි කිරීමෙන් කෝඩ් එක ලස්සන වෙනවා තමයි. ඒත් ඕනෑවට වඩා Complex Comprehensions හදන්න ගියොත් වැඩේ අවුල් වෙන්න පුළුවන්. විශේෂයෙන්ම Nested Comprehensions (එකක් ඇතුලේ තව එකක්) ලියනකොට කෝඩ් එක කියවන්න (read) අමාරු වෙන්න පුළුවන්. ඒ වගේ වෙලාවට සාමාන්‍ය for ලූප් එකක් පාවිච්චි කරන එක වඩා හොඳයි. හැම විටම readability එක ගැන හිතන්න. කෝඩ් එක අනිත් කෙනෙකුට කියවන්න ලේසි වෙන්න ඕන.

නරක උදාහරණයක් (Avoid this!):

# Don't do this unless you absolutely know what you're doing and it's simple
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row if num % 2 == 0]
print(flattened)
# Output: [2, 4, 6, 8]

මේක වැඩ කරනවා, නමුත් num for row in matrix for num in row කියන කොටස කියවන්න ටිකක් අමාරුයි නේද? තව කොන්දේසි දැම්මොත් නම් කෝඩ් එක අවුල් වෙන්න පුළුවන්.

දෝෂ නිවැරදි කිරීම (Debugging Complex Comprehensions)

සමහර වෙලාවට Complex Comprehensions වල දෝෂ ඇති වුණොත් ඒවා හොයාගන්න ටිකක් අමාරු වෙන්න පුළුවන්. ඒ වගේ වෙලාවට, මුලින්ම Comprehension එක සාමාන්‍ය for ලූප් එකකට කඩාගෙන, step-by-step debug කරලා, දෝෂය හදාගෙන ආයෙත් Comprehension එකට convert කරන එක හොඳ පුරුද්දක්.

කාර්ය සාධනය (Performance)

සාමාන්‍යයෙන් Comprehensions for ලූප් වලට වඩා වේගවත්. ඒකට හේතුව තමයි Python interpreter එක මේවා C level එකේදී optimize කරන නිසා. පොඩි දත්ත ප්‍රමාණයක් එක්ක වැඩ කරනකොට මේ වෙනස එච්චර දැනෙන්නේ නැති වුණාට, විශාල දත්ත ප්‍රමාණයක් එක්ක වැඩ කරනකොට මේ වේගය ගොඩක් වැදගත් වෙනවා.

අවසාන වශයෙන් (Conclusion)

ඔන්න එහෙනම් යාළුවනේ, Python වල Comprehensions ගැන සම්පූර්ණ විස්තරයක් අරගෙන ආවා. මේ List, Dictionary, Set Comprehensions කියන්නේ ඔයාගේ Python කෝඩ් එක ගොඩක් clean, efficient, වගේම 'Pythonic' කරන්න පුළුවන් සුපිරිම tools ටිකක්. මුලින් ටිකක් අමාරු වගේ පෙනුනත්, මේවා පුරුදු වුණාම ඔයාට කෝඩ් කරන්න තියෙන පහසුව ගැන පුදුම වෙයි.

මතක තියාගන්න, හැම දේම Comprehensions වලින් කරන්න ඕන කියලා නීතියක් නෑ. සමහර වෙලාවට සාමාන්‍ය for ලූප් එකක් වඩා පැහැදිලි වෙන්න පුළුවන්. හැබැයි, දත්ත transformation සහ filtering වලට නම් Comprehensions තමයි කෝඩ් එක ලස්සනට තියාගන්න හොඳම ක්‍රමය.

අදම මේක ඔයාගේ කෝඩ් එකට ට්‍රයි කරලා බලන්න! ඔබේ අත්දැකීම් කොහොමද? මොනවා හරි ගැටලු ආවද? පහළ comments section එකේ ඔබේ අදහස් සහ ප්‍රශ්න අනිවාර්යයෙන්ම කියන් යන්න. අපි උත්තර දෙන්න ලෑස්තියි!

තවත් මේ වගේ වැදගත් Python tips එක්ක ඊලඟ ලිපියෙන් හම්බවෙමු! ඔබට ජය!