Python සරලව සිංහලෙන් (Part 13) - Virtual Environments සහ Pythonic Coding 🐍💻

ආයුබෝවන් කට්ටියටම! 🙏 KP Tech Gear අපේ Python Self-Study Series එකේ 13 වෙනි කොටසට ඔන්න අපි ආවා. අම්මෝ... Parts 12 ක් පහුකරගෙන, Exceptions, Lambda, OOP ඔක්කොම කටපාඩම් කරගෙන මේ වෙනකම් ආපු උඹලට මුලින්ම ලොකු salute එකක් දෙන්න ඕනේ! 😎 ගොඩක් අයට coding එපා වෙන්නේ ඔය අතරමගදී. ඒත් උඹලා තාම මෙතන ඉන්නවා කියන්නේ, Software Engineer කෙනෙක් වෙන හීනේ ගොඩක් දුර නෑ මචං.

අද අපි කතා කරන්න යන්නේ කැම්පස් එකේ Assignment එකක් හදද්දි වගේම, Software Company එකක ලොකු ප්‍රොජෙක්ට් එකක් කරද්දිත් අනිවාර්යයෙන්ම පාවිච්චි වෙන පට්ටම concepts ටිකක්. ඉස්සරහට අපි Data Science (Pandas), Web Scraping (BeautifulSoup), සහ APIs වගේ ලොකු Real-world Projects වලට බහින්නයි යන්නේ. හැබැයි ඒවට යන්න කලින් ඔයා අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕනේ Virtual Environments කියන්නේ මොකක්ද සහ කෝඩ් එකක් "Pythonic" විදිහට (වෘත්තීය මට්ටමෙන්) ලස්සනට ලියන්නේ කොහොමද කියන එක.

අද Article එක ටිකක් දිගයි. ඒ නිසා කෝපි එකක් හරි ප්ලේන්ටියක් හරි හදාගෙනම සෙට් වෙමු. මේකෙන් ඔයාගේ Coding Life එකම වෙනස් වෙයි!

🌐 1. Dependency Hell (ඇයි අපිට Virtual Environments ඕනේ?)

හිතන්නකො මෙහෙම සීන් එකක්... ඔයා Python වලින් Project A සහ Project B කියලා වැඩ දෙකක් කරනවා. Project A එක කියන්නේ ඔයාගේ පරණ කැම්පස් assignment එකක්. ඒකට ඕනේ වෙනවා Django version 2.0. Project B එක කියන්නේ ඔයා දැන් අලුතින් හදන සුපිරි AI Web App එක. ඒකට ඕනේ වෙනවා අලුත්ම Django version 4.0.

ඔයා සාමාන්‍ය විදිහට CMD එකේ pip install django==4.0 දුන්නොත්, මේක Install වෙන්නේ ඔයාගේ PC එකේ තියෙන Main Python ෆෝල්ඩරයට (Global Environment එකට). එතකොට මොකද වෙන්නේ? අර පරණ Django 2.0 එක මැකිලා අලුත් එක overwrite වෙනවා! ඊට පස්සේ අර පරණ Project A එක Run කරද්දි ඒක වැඩ කරන්නේ නෑ, එක දිගට Errors ගහන්න ගන්නවා. 😭

PC එකේ තියෙන්න පුළුවන් එක පාරකට එක Library එකකින් එක Version එකයි. මේකට Software Engineering ලෝකෙ කියන්නේ "Dependency Hell" කියලා. හරියට නිකන් එකම කෑම පෙට්ටියේ සම්බලුයි, කිරිබතුයි, අයිස්ක්‍රීනුයි ඔක්කොම දාලා වගේ... ඔක්කොම mix වෙලා කන්න බැරි වෙනවා!

💡 විසඳුම: Virtual Environments (venv) කෑම පෙට්ටි ක්‍රමය!
මේකට තියෙන සුපිරිම විසඳුම තමයි Virtual Environments. මේකෙන් කරන්නේ ඔයා කරන හැම Project එකකටම, PC එකේ තියෙන Main Python එකෙන් කෑල්ලක් කඩලා අරන් "වෙනම කෘතිම කාමරයක්" (Virtual space එකක්) හදලා දෙන එක. එතකොට Project A එකේ කාමරේට වෙනම Django දාන්නත්, Project B එකේ කාමරේට වෙනම දාන්නත් පුළුවන්. එක කාමරේක වෙන දේ අනිත් කාමරේට බලපාන්නේ නෑ! පට්ට නේද?

🛠️ 2. Virtual Environment එකක් සාදාගන්නා ආකාරය

Python වල 3.3 version එකේ ඉඳන් මේ venv කියන පහසුකම default එනවා. (වෙනම මුකුත් download කරන්න ඕනේ නෑ). ඔයාගේ Project එක තියෙන ෆෝල්ඩරයට ගිහින් Command Prompt (CMD) හෝ VS Code Terminal එක open කරගෙන මේ command එක ගහන්න.

# Windows / Mac / Linux සඳහා පොදු විධානය
C:\Projects\MyNewProject> python -m venv my_env

මෙතන python -m venv කියන්නේ Python වලට කියනවා "මචං මට Virtual Environment Module (-m venv) එක පාවිච්චි කරලා අලුත් environment එකක් හදලා දියන්" කියලා. අන්තිමට තියෙන my_env කියන්නේ ඒකට අපි දෙන නම. ඔයාට ඕනේ නම් ඕකට kavisha_env, super_env, නැත්නම් නිකන්ම venv කියලත් දෙන්න පුළුවන්.

මේ command එක ගැහුවම තත්පර කීපයක් යයි (පොඩ්ඩක් ඉවසපන්, PC එක හිරවුණා නෙවෙයි 😅). ඊට පස්සේ බලද්දි ඔයාගේ ෆෝල්ඩරේ ඇතුලේ ඒ නමින් අලුත් Folder එකක් හැදිලා තියෙයි. ඒක ඇතුලේ Include, Lib, Scripts කියලා ෆෝල්ඩර් සෙට් එකකුත් ඇති.

🚀 Environment එක Activate කිරීම (පණ ගැන්වීම)

Environment එක හැදුවට මදි, අපි PC එකට කියන්න ඕනේ "දැන් ඉඳන් මම install කරන දේවල් අර Global එකට දාන්න එපා, මේ අලුත් my_env එකට විතරක් දාපන්" කියලා. ඒකට මේක Activate කරන්න ඕනේ.

# Windows සඳහා (CMD හෝ VS Code හිදී):
C:\Projects\MyNewProject> my_env\Scripts\activate

# Mac / Linux සඳහා:
$ source my_env/bin/activate

මේක Activate වුණාම ඔයාගේ Command Line එකේ මුලින්ම කොළ පාටින් හරි සුදු පාටින් හරි වරහන් ඇතුලේ Environment එකේ නම වැටෙනවා. හරියට මෙන්න මේ වගේ:
(my_env) C:\Projects\MyNewProject>

ආන්න එහෙම වරහනක් වැටිලා තියෙනවා නම්, ඔයා ඉන්නේ Safe Zone එකේ! දැන් ඔයා pip install numpy ගැහුවත්, pip install django ගැහුවත් ඒ ඔක්කොම යන්නේ අර my_env ෆෝල්ඩරේ ඇතුළට විතරයි. ඔයාගේ main PC එකට කිසිම බලපෑමක් නෑ.

⚠️ බොක්ක, මේක නම් අමතක කරන්න එපා! (Deactivate කිරීම)
සමහර දවස් වලට අපි නිදිමරන් කෝඩ් කරලා, පහුවදා උදේ වෙන project එකක් open කරගෙන pip install ගහනවා. හැබැයි අර පරණ environment එක තාම activate වෙලා! අඬලා වැඩක් නෑ ඉතින් ඊට පස්සේ. ඒක නිසා වැඩේ ඉවර වුණාම Terminal එකේ නිකන්ම deactivate කියලා type කරලා Enter කරන්න. එතකොට අර වරහන අයින් වෙලා සාමාන්‍ය තත්වෙට එනවා.

📦 3. requirements.txt භාවිතය (Dependency Management)

හිතන්න ඔයා සුපිරි Project එකක් හැදුවා. ඒකෙදි ඔයා Requests, BeautifulSoup, Pandas, Flask වගේ Libraries 15ක් විතර පාවිච්චි කළා. දැන් ඔයා මේ Project එක ඔයාගේ යාලුවෙකුට දෙනවා (නැත්නම් GitHub එකට දානවා) "මචං මේක Run කරලා බලපන්කෝ" කියලා.

යාලුවා එයාගේ PC එකේ Run කරපු ගමන් ModuleNotFoundError: No module named 'pandas' කියලා ලොකුවට Error එකක් ගහනවා. ඇයි? එයාගේ PC එකේ ඒ libraries නෑනෙ! ඊට පස්සේ ඌ කෝල් කරලා අහනවා "මොනවද බං මේකට install කරන්න ඕනේ?" කියලා. ඔයාට අර 15ම මතකෙන් කියන්න පුළුවන්ද? බෑනෙ.

අන්න ඒ වගේ කට්ටක් කන්නේ නැතුව, ලස්සනට වැඩේ ගොඩදාගන්න තමයි අපි requirements.txt ෆයිල් එක පාවිච්චි කරන්නේ.

📝 අවශ්‍යතා ලැයිස්තුගත කිරීම (Pip Freeze)

ඔයාගේ Virtual Environment එක Activate කරලා තියෙද්දි, පහත Command එක ගහන්න.

(my_env) C:\Projects> pip freeze > requirements.txt

pip freeze කියන්නේ අයිස් කරනවා වගේ වැඩක්. මේකෙන් කරන්නේ ඔයාගේ Environment එකේ Install කරලා තියෙන හැම Library එකක්ම සහ ඒවගේ Versions හරියටම Text File එකකට ලියලා save කරන එක. මේ text ෆයිල් එක open කරලා බැලුවොත් තියෙන්නේ මෙන්න මේ වගේ ලිස්ට් එකක්:

beautifulsoup4==4.12.2
numpy==1.25.0
pandas==2.0.3
requests==2.31.0
    

දැන් ඔයා Project එක යාලුවට යවද්දි, අර my_env ෆෝල්ඩරේ යවන්න ඕනේ නෑ (ඒක MB ගාණක් ලොකුයි). ඔයා යවන්නේ ඔයාගේ කෝඩ් එකයි, මේ requirements.txt ෆයිල් එකයි විතරයි.

⬇️ එකවර Install කිරීම (The Magic Trick!)

යාලුවා එයාගේ PC එකේ අලුත් Virtual environment එකක් හදාගෙන, Terminal එකේ මේ Command එක ගැහුවම ඇති. අර ෆයිල් එකේ තියෙන Libraries 15ම එක පාර Auto Install වෙනවා! බලපන්කො ඒකෙ තියෙන ගැම්ම 😎

(friend_env) C:\Projects> pip install -r requirements.txt

⚡ 4. The "Pythonic" Way - List Comprehensions

හරි, දැන් අපි Environment පැත්ත හදාගෙන PC එක පිළිවෙලක් කරගත්තා. දැන් යමු Coding පැත්තට. Python කියන්නේ මාරම ලස්සන, කියවන්න ලේසි (Readable) භාෂාවක්. Java, C++ කරලා Python වලට ආපු අය සාමාන්‍යයෙන් කෝඩ් කරන්නේ අර පරණ විදිහටමයි. හැබැයි Python වල තියෙනවා "Pythonic" කියලා කෝඩ් ලියන වෙනම කලාවක්.

Industry එකේ වැඩ කරද්දි Senior Developer කෙනෙක් ඔයාගේ කෝඩ් එක දිහා බලලා "ආ මේකා නම් Python දන්න එකෙක්" කියලා තේරුම් ගන්නේ මේ Pythonic ලක්ෂණ දැක්කමයි. ඒකෙ ප්‍රධානම එකක් තමයි List Comprehensions.

හිතන්න අපිට 1 ඉඳන් 10ට තියෙන ඉලක්කම් වල වර්ගය (Square - ඒ කියන්නේ 2න් ගුණ කරපු අගය නෙවෙයි, ඒකෙන්ම ගුණ කරපු අගය: 2x2, 3x3) අරගෙන අලුත් List එකක් හදන්න ඕනේ කියලා. සාමාන්‍යයෙන් Noob විදිහට අපි මේක ලියන්නේ මෙහෙමයි:

# ❌ සාමාන්‍ය ක්‍රමය (Non-Pythonic / The Noob Way)
squares = []
for i in range(1, 11):
    squares.append(i ** 2)
print(squares)
# Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

පේළි 3ක් ගියා, variable එකක් හිස්ව හදන්නත් වුණා නේද? දැන් බලන්න මේක Pythonic විදිහට, එක පේළියකින් ලියන Pro විදිහ!

# ✅ Pythonic ක්‍රමය (List Comprehension / The Pro Way)
squares = [i ** 2 for i in range(1, 11)]
print(squares)

🎯 Syntax එක හරියටම තේරුම් ගනිමු:
[ ඔබට අවශ්‍ය ප්‍රතිඵලය (expression) for item in iterable ]
මුලින්ම තියෙන්නේ අපිට List එක ඇතුළට දාන්න ඕන දේ (එනම් i ** 2). ඊට පස්සේ සාමාන්‍ය For loop කෑල්ල. මේකෙන් කෝඩ් එක ලස්සන වෙනවා වගේම, සාමාන්‍ය Loop එකකට වඩා Run වෙන වේගයත් (Performance) ගොඩක් වැඩියි! C වලින් ලියවුණු underlying code එකක් පාවිච්චි වෙන නිසයි ඒ.

🔍 List Comprehension සමග If Condition භාවිතය (Filtering)

හිතන්න අපිට අර ඉලක්කම් 10න්, ඉරට්ටේ සංඛ්‍යා (Even numbers) වල වර්ගය විතරක් ගන්න ඕනේ කියලා. මේකට අපි List Comprehension එක අගටම if කෑල්ලක් සෙට් කරනවා.

# ඉරට්ටේ සංඛ්‍යා පමණක් තෝරා ගැනීම
even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_squares)
# Output: [4, 16, 36, 64, 100]

මෙතන වෙන්නේ, loop එක කැරකෙද්දි ඉස්සෙල්ලාම if i % 2 == 0 එක check කරනවා. ඒක True වුණොත් විතරක් මුලින් තියෙන i ** 2 එක වැඩ කරලා List එකට ඇඩ් වෙනවා. පට්ට සිම්පල්!

🔀 List Comprehension සමග If-Else භාවිතය (Ternary Operation)

හැබැයි ඔයාට If-Else දෙකම පාවිච්චි කරන්න ඕනේ නම් (උදාහරණයක් විදිහට: ඉරට්ටේ නම් ඒ ඉලක්කමම ලියනවා, ඔත්තේ නම් ඒ වෙනුවට 0 ලියනවා), ඒක ලියන්නේ Loop එකට කලින්!. මේක ටිකක් පටලවගන්න තැනක්, ඒ නිසා හොඳට බලන්න.

# If-Else සමග (Syntax එකේ වෙනස හොඳට බලන්න)
numbers = [i if i % 2 == 0 else 0 for i in range(1, 11)]
print(numbers)
# Output: [0, 2, 0, 4, 0, 6, 0, 8, 0, 10]

🌟 5. Dictionary Comprehensions (තවත් ගැඹුරට ඩිග් කරමු)

List වලට විතරක් නෙවෙයි මචං, Dictionaries වලටත් මේ Comprehension ක්‍රමය පාවිච්චි කරන්න පුළුවන්. ඒකට පාවිච්චි කරන්නේ කොටු වරහන් [] වෙනුවට සඟල වරහන් {}. හැබැයි අමතක කරන්න එපා Dictionary එකක Key: Value (යතුර සහ අගය) යුගලයක් තියෙන්න ඕනේ.

හිතන්න අපිට භාණ්ඩ වගයක පරණ මිල (Prices) දීලා තියෙනවා. අපිට ඕනේ ඒ හැම එකටම 20% ක Discount එකක් දාලා අලුත් Dictionary එකක් හදාගන්න. බලමු ඒක කරන විදිහ:

# 20% ක වට්ටමක් සහිතව නව මිල ගණන් සැකසීම
old_prices = {'Laptop': 1000, 'Mouse': 50, 'Keyboard': 100}

# Dictionary Comprehension භාවිතය
new_prices = {item: price * 0.8 for (item, price) in old_prices.items()}

print(new_prices)
# Output: {'Laptop': 800.0, 'Mouse': 40.0, 'Keyboard': 80.0}

🤝 6. Professional Tips: Enumerate සහ Zip

List Comprehension ගැන ඉගෙන ගත්ත ඔයාට තව බෝනස් කෑලි දෙකක් දෙන්නම්. මේ දෙකත් Professional කෝඩර්ස්ලා නිතරම පාවිච්චි කරන සුපිරි Functions දෙකක්. අදින් පස්සේ මේවා පාවිච්චි කරන්න පුරුදු වෙන්න.

🔢 Enumerate() භාවිතය (අංක කිරීම)

අපි සාමාන්‍යයෙන් Loop එකක් කරකවද්දි, අපිට List එකේ තියෙන Item එක (Value) විතරක් නෙවෙයි, ඒක තියෙන ස්ථානය (Index / 0,1,2,3...) එකත් ඕනේ වෙන වෙලාවල් තියෙනවා. ගොඩක් අය මේකට වෙනම count = 0 කියලා Variable එකක් හදාගෙන ඒක ඇතුලෙදි count += 1 කර කර යනවා. ඒත් Python වල එහෙම ගල් යුගේ වැඩ කරලා නෝන්ඩි වෙන්න ඕනේ නෑ!

# Enumerate මගින් Index එක සහ අගය එකවර ලබා ගැනීම
games = ["GTA V", "Cyberpunk 2077", "Valorant"]

# අපි 1 න් පටන් ගන්න start=1 කියලා දෙනවා
for index, game in enumerate(games, start=1):
    print(f"{index}: {game}")

# Output:
# 1: GTA V
# 2: Cyberpunk 2077
# 3: Valorant

🔗 Zip() භාවිතය (Lists එකට මැසීම)

ඔයාට Lists දෙකක් හෝ තුනක් තියෙනවා නම්, ඒවගේ එකම ස්ථානයේ තියෙන දේවල් එකට ගළපන්න (Pair කරන්න) ඕන නම් zip() පාවිච්චි කරන්න පුළුවන්. හරියට ජැකට් එකක zip එකක් වහනවා වගේ, දෙපැත්තේ තියෙන දත් එකට සෙට් වෙනවා!

# Lists දෙකක් Zip කිරීම
players = ["Kaweesha", "Kasun", "Dasun"]
scores = [850, 920, 780]

for player, score in zip(players, scores):
    print(f"{player} ගේ ලකුණු: {score}")

දැන් හිතන්න මේ Lists දෙකේ දිග සමාන නෑ කියලා (එකක items 3යි, අනිකේ 2යි). එතකොට Zip එක වැඩ කරන්නේ අර දිග අඩුම List එකේ ගාණට විතරයි. ඉතුරු ටික අතෑරලා දානවා. ඒකත් මතක තියාගන්න.

🎯 අවසාන නිගමනය

අද අපි ඉගෙන ගත්ත Virtual Environments, requirements.txt, List Comprehensions, Enumerate, සහ Zip කියන්නේ ඔයාව Beginner කෙනෙක්ගෙන් Advanced/Professional කෙනෙක් කරා අරන් යන රොකට් එකක් වගේ දේවල්. මීළඟට අපි KP Tech Gear එකෙන් අරන් එන Web Scraping, APIs සහ Data Analysis වගේ සුපිරි Project Series එකට බහින්න දැන් ඔයාගේ Foundation එක 100% ක් ලෑස්තියි.

ඔය ඉගෙන ගත්ත දේවල් නිකන් කියවලා විතරක් තියන්න එපා. දැන්ම ඔයාගේ PC එකේ අලුත් ෆෝල්ඩරයක් හදලා, අලුත් Virtual Environment එකක් හදලා මේ කෝඩ් ටික Run කරලා බලන්න. තනියම කෝඩ් කරනකොට එන Errors වලට බය වෙන්න එපා, ඒවා තමයි අපිට ගොඩක් දේවල් කියලා දෙන්නේ!

මොනවා හරි ප්‍රශ්නයක් තියෙනව නම්, හරි ගියේ නැත්නම් පල්ලෙහායින් Comment එකක් දාන්න. මම reply කරන්නම්. එහෙනම් මීළඟ කොටසින් සුපිරිම ප්‍රොජෙක්ට් එකක් එක්ක හමුවෙමු! Happy Coding මචංලා! 🚀