මොඩියුල්ස් (Modules) සහ පැකේජ් (Packages): කෝඩිං ලෝකේ සිංහයා වගේ වැඩ කරන හැටි!

ආයුබෝවන් කට්ටියටම! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ කෝඩිං ලෝකේ වැඩ පහසු කරන, වැඩ වේගවත් කරන, එතකොට අපේ කෝඩ් එක මාරටම පිළිවෙළට තියාගන්න පුළුවන් වෙන සුපිරිම සංකල්ප දෙකක් ගැන. ඒ තමයි Modules සහ Packages. අපි ලංකාවේ අයනේ, වැඩක් කරනකොට වැඩේ පහසුවට කරගන්න බලනවා වගේම, ඒක පිළිවෙළට, පිරිසිදුවට තියාගන්නත් කැමතියිනේ. කෝඩිං වලදීත් එහෙම තමයි. මේ Modules සහ Packages කියන්නේ ඒකට තියෙන නියම විසඳුම් දෙකක්.

ඔයාලා දැන් Python කරන කෙනෙක් වෙන්න පුළුවන්, නැත්නම් අලුතින් පටන් ගත්ත කෙනෙක් වෙන්න පුළුවන්. ඕනම කෙනෙක්ට මේ සංකල්ප දෙක හොඳටම වැදගත් වෙනවා. අපි ගේමක් ගහමුද එහෙනම්? අද මේ Modules සහ Packages ගැන මුල ඉඳන්ම, හොඳට තේරෙන විදියට, Practical උදාහරණත් එක්ක කතා කරමු.

මොඩියුල්ස් (Modules) කියන්නේ මොනවද?

සරලවම කිව්වොත්, Module එකක් කියන්නේ Python code අඩංගු .py extension එකෙන් ඉවර වෙන file එකකට. ඒ file එක ඇතුලේ functions, classes, variables වගේ ඕනම දෙයක් තියෙන්න පුළුවන්. හිතන්නකෝ ඔයාලා ගෙදරක වැඩ කරනකොට, මුළු ගෙදරටම අදාල වැඩ එක තැනක තියලා, කුස්සියේ වැඩ කුස්සියේ තියලා, නාන කාමරේ වැඩ එහෙටම දාලා, කාමරේ වැඩ කාමරේටම සීමා කරලා තියනවා වගේ වැඩක් තමයි මේ Module එකක් කියන්නේ. ඒ කියන්නේ, අපේ code එක තව පොඩි පොඩි කොටස් වලට කඩලා, ඒ කොටස් එක file එකකට දාලා තියාගන්න එක.

මේකෙන් වෙන වාසි මොනවද? හිතන්න, ඔයාලා ලොකු Project එකක් කරනවා කියලා. ඒකේ හැම code ටිකම එක file එකකට ලිව්වොත් මොකද වෙන්නේ? ඒ file එක දිග වැඩිවෙලා කියවන්න අපහසු වෙනවා, එක තැනක වෙනසක් කරන්න ගියොත් මුළු Project එකටම බලපාන්න පුළුවන්, එකම code එක ආයෙ ආයෙ ලියන්න වෙනවා. ඒත් Modules පාවිච්චි කලොත්, මේ හැම ප්‍රශ්නයකටම විසඳුම් ලැබෙනවා. Code එක organize වෙනවා, reuse කරන්න පුළුවන් වෙනවා, maintain කරන්න ලේසි වෙනවා, එතකොට එක Team එකක වැඩ කරනකොටත් ගොඩක් පහසුයි. Module එකක තියෙන code වෙනත් project එකකදී පාවිච්චි කරන්න පුළුවන් නිසා, කාලය ඉතිරි වෙනවා වගේම, code එකේ තත්වෙත් හොඳයි.

මොඩියුල්ස් Import කරන හැටි

දැන් අපි බලමු මේ Modules අපේ Project එකකට ගන්නෙ කොහොමද කියලා. ඔයාලට වෙන Module එකක තියෙන functions, classes වගේ දේවල් පාවිච්චි කරන්න ඕන නම්, මුලින්ම ඒ Module එක import කරගන්න ඕනේ. Python වල Modules import කරන්න ප්‍රධාන ක්‍රම දෙකක් තියෙනවා.

1. import statement එක

මෙන්න මේක තමයි Module එකක් import කරගන්න සාමාන්‍යයෙන් පාවිච්චි කරන ක්‍රමය. මේකෙන් කරන්නේ, අපි import කරන Module එකේ තියෙන හැමදේම අපේ current script එකට load කරන එක. ඊට පස්සේ, ඒ Module එකේ තියෙන දෙයක් පාවිච්චි කරනකොට, Module එකේ නමත් එක්කම පාවිච්චි කරන්න වෙනවා. උදාහරණයක් විදියට math Module එකේ sqrt() function එක පාවිච්චි කරනවා නම්, math.sqrt() කියලා ලියන්න ඕනේ.

# උදාහරණය: math Module එක import කරගැනීම
import math

# math Module එකේ තියෙන sqrt() function එක පාවිච්චි කරමු
result = math.sqrt(25)
print(f"25 හි වර්ගමූලය: {result}") # Output: 25 හි වර්ගමූලය: 5.0

# math Module එකේ තියෙන pi variable එක පාවිච්චි කරමු
print(f"pi අගය: {math.pi}") # Output: pi අගය: 3.141592653589793

import math as m වගේ as keyword එක පාවිච්චි කරලා Module එකට අලුත් කෙටි නමක් (alias) දෙන්නත් පුළුවන්. මේක ලොකු Module නම් වලදී, නැත්නම් එකම නමේ Modules කිහිපයක් import කරන වෙලාවට ගොඩක් ප්‍රයෝජනවත්.

import math as m

result = m.sqrt(16)
print(f"16 හි වර්ගමූලය (alias එක්ක): {result}") # Output: 16 හි වර්ගමූලය (alias එක්ක): 4.0

2. from ... import statement එක

සමහර වෙලාවට අපිට ඕන වෙන්නේ Module එකක තියෙන හැම දෙයක්ම නෙවෙයි, එකක් දෙකක් විතරයි. එහෙම වෙලාවට මේ from ... import statement එක පාවිච්චි කරන්න පුළුවන්. මේකෙන් කරන්නේ, Module එකේ තියෙන specific function එකක්, class එකක්, නැත්නම් variable එකක් විතරක් import කරගන්න එක. එතකොට, ඒ දේ පාවිච්චි කරනකොට Module එකේ නම දාන්න ඕන වෙන්නේ නෑ. direct call කරන්න පුළුවන්.

# උදාහරණය: random Module එකෙන් randint function එක විතරක් import කරගැනීම
from random import randint

# දැන් randint() direct පාවිච්චි කරන්න පුළුවන්
random_number = randint(1, 100)
print(f"සසම්භාවී අංකයක්: {random_number}") # Output: 1 ත් 100 ත් අතර සසම්භාවී අංකයක්

# එකම Module එකෙන් දේවල් කිහිපයක් import කරන්න පුළුවන්
from math import pi, sqrt

print(f"Pi: {pi}") # Output: Pi: 3.141592653589793
print(f"sqrt(81): {sqrt(81)}") # Output: sqrt(81): 9.0

from module_name import * වගේ * symbol එක පාවිච්චි කරලා Module එකේ තියෙන හැමදේම import කරන්නත් පුළුවන්. ඒත් මේක Best Practice එකක් විදියට නිර්දේශ කරන්නේ නෑ. මොකද, Module එකේ තියෙන නම් අපේ current script එකේ තියෙන නම් එක්ක ගැටෙන්න (name collision) පුළුවන්. ඒ වගේම, මොන functions ද import වුණේ කියලා තේරුම් ගන්නත් අමාරු වෙනවා, Debug කරන්නත් අමාරු වෙනවා. ඒ නිසා, මේක පුළුවන් තරම් භාවිතා නොකර සිටින්න.

අපේම මොඩියුල්ස් හදමු! (Creating Your Own Modules)

දැන් අපි බලමු අපිටම Module එකක් හදාගන්නෙ කොහොමද කියලා. මේක මාරම ලේසියි. ඔයාට ඕන කරන functions, classes, variables ටික අරගෙන, ඒ ටික .py extension එකකින් save කරන්න. එච්චරයි! ඒක දැන් Module එකක්. මේකෙන් ඔයාගේ code එක categorize කරන්න පුළුවන්, උදාහරණයක් විදියට database operations ටික එක module එකක, web scraping ටික තව module එකක වගේ.

උදාහරණයක්: my_utils.py කියන Module එක

හිතන්නකෝ ඔයාලට පොඩි calculations ටිකක් කරන්න functions ටිකක් ඕන කියලා. අපි ඒ ටික my_utils.py කියන file එකට දාමු. මේ file එක ඔයාගේ project folder එකේ තියෙන්න ඕනේ.

# my_utils.py file එකේ කෝඩ් එක

def add(a, b):
    """දෙකක් එකතු කරයි."""
    return a + b

def subtract(a, b):
    """දෙකක් අඩු කරයි."""
    return a - b

def multiply(a, b):
    """දෙකක් ගුණ කරයි."""
    return a * b

def divide(a, b):
    """
    පළමු අංකය දෙවන අංකයෙන් බෙදයි.
    බිංදුවෙන් බෙදීම වලක්වයි.
    """
    if b == 0:
        return "Error: Cannot divide by zero!"
    return a / b

PI_VALUE = 3.14159

print("my_utils.py module එක load වුනා!") # මේක run වෙන්නේ import කරනකොට විතරයි

my_app.py කියන script එකෙන් my_utils Module එක පාවිච්චි කරන හැටි

දැන් ඔය my_utils.py file එකම තියෙන folder එකේම my_app.py කියලා තව file එකක් හදලා, ඒකෙන් අපි හදාගත්ත my_utils Module එක import කරලා පාවිච්චි කරමු. වැදගත් දේ තමයි, මේ files දෙකම එකම directory එකේ තියෙන්න ඕනේ. නැත්නම් Python ට my_utils.py හොයාගන්න බැරිවෙන්න පුළුවන්.

# my_app.py file එකේ කෝඩ් එක

import my_utils

# my_utils module එකේ functions පාවිච්චි කරමු
sum_result = my_utils.add(10, 5)
print(f"එකතුව: {sum_result}") # Output: එකතුව: 15

diff_result = my_utils.subtract(10, 5)
print(f"වෙනස: {diff_result}") # Output: වෙනස: 5

prod_result = my_utils.multiply(10, 5)
print(f"ගුණිතය: {prod_result}") # Output: ගුණිතය: 50

div_result = my_utils.divide(10, 2)
print(f"බෙදීම: {div_result}") # Output: බෙදීම: 5.0

zero_div_result = my_utils.divide(10, 0)
print(f"බිංදුවෙන් බෙදීම: {zero_div_result}") # Output: බිංදුවෙන් බෙදීම: Error: Cannot divide by zero!

print(f"PI අගය: {my_utils.PI_VALUE}") # Output: PI අගය: 3.14159

මේ my_app.py script එක run කරනකොට, my_utils.py file එක load වෙලා, ඒකේ තියෙන print("my_utils.py module එක load වුනා!") කියන line එක print වෙනවා. ඊට පස්සේ තමයි my_app.py එකේ අනිත් code ටික run වෙන්නේ. මේකෙන් තේරෙන්නේ Module එකක් import කරනකොට, ඒකේ තියෙන code execute වෙනවා කියන එක. මේ නිසා, Module එක ඇතුලේ direct execute වෙන්න ඕන නැති code (e.g. Test code) දාන එකෙන් වැලකිලා ඉන්න.

පැකේජ් (Packages): මොඩියුල්ස් ලොකු කරන හැටි

දැන් අපි Modules ගැන කතා කළානේ. Packages කියන්නේ Modules වල ඊළඟ මට්ටම. හිතන්නකෝ ඔයාලට Modules ගොඩක් තියෙනවා, ඒ ටික එකම වර්ගයේ වැඩ වලට අදාල නම්, ඒ ටික එක තැනකට එකතු කරලා තියාගන්න පුළුවන්නේ. ඒකට තමයි Packages කියන්නේ. Package එකක් කියන්නේ Modules වලට වඩා විශාල සහ සංකීර්ණ ව්‍යුහයක්. ලොකු project එකක් කරනකොට code organize කරන්න Packages නැතුවම බැරි වෙනවා.

සරලවම කිව්වොත්, Package එකක් කියන්නේ Modules එකතුවක් තියෙන folder එකකට. හැබැයි මේ folder එක Python Package එකක් කියලා හඳුනාගන්න, ඒක ඇතුලේ __init__.py කියලා file එකක් අනිවාර්යයෙන්ම තියෙන්න ඕනේ. (Python 3.3 ට පස්සේ මේ file එක නැති වුණත් folder එක Package එකක් විදියට recognize වෙනවා, ඒත් best practice එක තමයි මේක තියන එක. මේ file එක හිස් වුණත් කමක් නෑ, ඒත් ඒක Python ට කියනවා මේ folder එක package එකක් කියලා.)

Package එකක් හදන හැටි

අපි හදමු my_project කියලා folder එකක්. ඒක ඇතුලේ calculations කියලා Package එකක් හදමු. මේකෙන් අපේ calculations වලට අදාල Modules එක තැනකට organize කරගන්න පුළුවන්.

my_project/
├── main.py
└── calculations/
    ├── __init__.py
    ├── basic_ops.py
    └── advanced_ops.py

calculations/basic_ops.py file එකේ කෝඩ් එක:

# basic_ops.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

calculations/advanced_ops.py file එකේ කෝඩ් එක:

# advanced_ops.py
def power(base, exp):
    return base ** exp

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

calculations/__init__.py file එක හිස් වුණත් කමක් නෑ. ඒත් ඒක තියෙන්න ඕනේ calculations කියන්නේ Package එකක් කියලා Python ට කියන්න. __init__.py file එකට Package එක load වෙනකොට run වෙන්න ඕන code එකක් දාන්නත් පුළුවන්. උදාහරණයක් විදියට, Package එකේ commonly used functions කිහිපයක් direct Package එකෙන් import කරන්න පුළුවන් විදියට set කරන්න මේ file එක පාවිච්චි කරන්න පුළුවන්.

Package එකක් Import කරන හැටි

දැන් අපි main.py file එකෙන් මේ Package එකේ Modules පාවිච්චි කරමු. main.py file එක my_project folder එකේ root එකේ තියෙන්න ඕනේ.

# main.py

# Package එකක් ඇතුලේ තියෙන Module එකක් import කරන හැටි
from calculations import basic_ops
from calculations.advanced_ops import power, factorial

print(f"Add (10, 5): {basic_ops.add(10, 5)}") # Output: Add (10, 5): 15
print(f"Subtract (10, 5): {basic_ops.subtract(10, 5)}") # Output: Subtract (10, 5): 5

print(f"Power (2, 3): {power(2, 3)}") # Output: Power (2, 3): 8 (2^3 = 8)
print(f"Factorial (5): {factorial(5)}") # Output: Factorial (5): 120 (5! = 120)

මේකෙන් තේරෙනවා Package එකක තියෙන Module එකක් import කරද්දී package_name.module_name වගේ dot notation එකක් පාවිච්චි කරනවා කියලා. from statement එකත් එක්ක package_name.module_name import function_name වගේ දෙයක් කරන්නත් පුළුවන්. මේ ක්‍රමයෙන් code එක ගොඩක් කියවන්න පහසු වෙනවා වගේම, code එකේ structure එක ගැන හොඳ අවබෝධයක් ලැබෙනවා.

පොදු ගැටළු සහ විසඳුම් (Troubleshooting)

Modules සහ Packages එක්ක වැඩ කරනකොට එන පොදුම ගැටළු කිහිපයක් සහ ඒවා විසඳගන්න හැටි ගැනත් කතා කරමු. මොකද වැඩ කරනකොට error එන එක සාමාන්‍ය දෙයක්නේ. ඒවට විසඳුම් දන්න එක තමයි වටින්නේ.

ModuleNotFoundError

මේක තමයි Modules එක්ක වැඩ කරනකොට එන ප්‍රධානම error එක. මේක එන්නේ Python ට ඔයා import කරන්න හදන Module එක හොයාගන්න බැරි වුණාම. හේතු කිහිපයක් තියෙන්න පුළුවන්:

• Module එකේ නම වැරදියි: ඔයා import my_utiles කියලා ලිව්වොත්, ඒත් file එකේ නම my_utils.py නම්, Python ට ඒක හොයාගන්න බෑ. අකුරු හරියටම තියෙනවද කියලා බලන්න. Python files case-sensitive (කැපිටල්/සිම්පල් අකුරු) නිසා ඒවත් හරියටම බලන්න ඕනේ.
• Module එක Python Path එකේ නෑ: Python Modules හොයන්නේ තමන්ගේ sys.path එකේ තියෙන locations වල විතරයි. ඔයා හදපු Module එක ඒ locations වල නැත්නම්, මේ error එක එනවා.
• Folder Structure එක වැරදියි: Package එකක් import කරනකොට folder structure එක හරියටම හදලා නැත්නම්, __init__.py file එක නැත්නම්, මේ error එක එන්න පුළුවන්.

ModuleNotFoundError විසඳගන්න හැටි

ඔයා හදපු Module එක, ඔයා run කරන script එකත් එක්ක එකම Folder එකේ තියෙනවා නම්, සාමාන්‍යයෙන් මේ error එක එන්නේ නෑ. ඒත් වෙන Folder එකක තියෙන Module එකක් import කරන්න ඕන වුණොත්, ඒ Folder එක Python sys.path එකට add කරන්න වෙනවා. මේක තාවකාලික විසඳුමක්, හැබැයි ප්‍රයෝජනවත් වෙන්න පුළුවන්.

import sys
import os

# අපි හදන Module එක තියෙන Folder එකේ Path එක
# මේකෙන් කරන්නේ current script එකේ parent directory එකේ තියෙන 'my_custom_modules' folder එකට path එක set කරන එක.
module_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'my_custom_modules'))

# Path එක sys.path එකේ නැත්නම් add කරන්න
if module_path not in sys.path:
    sys.path.append(module_path)

# දැන් import කරන්න පුළුවන්
# උදාහරණයක් ලෙස, my_custom_modules folder එකේ custom_module_name.py කියලා file එකක් තියෙනවා නම්
import custom_module_name

print("Custom module imported successfully!")

මේක තාවකාලික ක්‍රමයක්. Project එකක් කරනකොට Folder Structure එක පිළිවෙළට හදලා Package විදියට වැඩ කරන එක තමයි හොඳම විසඳුම. නැත්නම් PYTHONPATH environment variable එක set කරන්නත් පුළුවන්. ඒකෙන් Python ට කියනවා අමතර modules හොයන්න ඕන locations මොනවද කියලා. (මේක OS එක අනුව වෙනස් වෙනවා).

Path Issues (ගොනු මාර්ග ගැටළු)

ඔය sys.path එක තමයි මෙතන ප්‍රධානම දේ. Python Interpreter එක module එකක් හොයනකොට බලන තැන් ටික තමයි ඒකේ තියෙන්නේ. මේවාට Python standard library paths, site-packages paths (pip වලින් install කරන packages තියෙන තැන්) සහ current working directory එක ඇතුලත් වෙනවා.

ඔයාලා Python interactive shell එකක import sys කරලා print(sys.path) ගහලා බැලුවොත්, Python modules හොයන locations ටික බලාගන්න පුළුවන්. ඔයාගේ custom module එක ඒ list එකේ තියෙන Folder එකක තියන්න පුළුවන් නම්, Python ට ඒක හොයාගන්න පුළුවන්. Virtual environments (venv) භාවිතා කරන එකත් මේ path issues අවම කරගන්න හොඳ විසඳුමක්. මොකද ඒකෙන් project එකටම වෙනම environment එකක් හදාගන්න පුළුවන්.

හොඳම පුරුදු (Best Practices)

අපි හැමෝම හොඳට වැඩ කරන, පිළිවෙළට code ලියන programmers ලා වෙන්න ඕනනේ. මේ Modules සහ Packages එක්ක වැඩ කරනකොට මේ දේවල් මතක තියාගන්න. මේවා අත්දැකීම් බහුල programmers ලා අනුගමනය කරන දේවල්.

• Modules focused වෙන්න ඕනේ: Module එකක් හැමතිස්සෙම එකම වගේ වැඩ ටිකකට අදාල functions, classes විතරක් තියාගන්න ඕනේ. උදාහරණයක් විදියට, database operations කරන functions ටික database_utils.py කියන module එකේ තියන්න. මේකෙන් code එක organize වෙනවා, කියවන්න ලේසි වෙනවා, maintain කරන්නත් පහසුයි. Single Responsibility Principle (SRP) එකට ගොඩක් දුරට සමානයි.
• පැහැදිලි නම් දෙන්න: Modules වලට, functions වලට තේරුමක් තියෙන නම් දෙන්න. උදාහරණයක් විදියට utils.py කියන එකට වඩා string_utils.py හෝ math_operations.py වගේ නමක් ගොඩක් පැහැදිලියි. මේකෙන් code එක කියවන කෙනෙක්ට (ඔයාටම වුණත් මාස කීපයකට පස්සේ) ඒ module එකේ තියෙන්නේ මොනවාද කියලා එක පාරටම තේරෙනවා.
• from module import * වලින් වළකින්න: මේකෙන් name collision වෙන්න තියෙන ඉඩ වැඩියි. හැමතිස්සෙම specific දේවල් import කරන්න from module import function වගේ. මේකෙන් ඔයාගේ code එකේ dependencies මොනවද කියලා පැහැදිලිව පේනවා වගේම, debugging පහසු වෙනවා.
• Docstrings පාවිච්චි කරන්න: ඔයාගේ functions, classes, modules වලට Docstrings (Documentation Strings) ලියන්න. මේකෙන් ඔයාට හෝ වෙන කෙනෙක්ට Module එක පාවිච්චි කරනකොට පහසුවෙන් තේරුම් ගන්න පුළුවන්. help() function එකෙන් මේ Docstrings access කරන්න පුළුවන්.
• Version Control පාවිච්චි කරන්න: Git වගේ Version Control system එකක් පාවිච්චි කරන එක මේ වගේ Projects වලදී අත්‍යවශ්‍යයි. Modules සහ Packages වගේ ව්‍යුහගත code base එකක වැඩ කරනකොට code changes manage කරන්න, team එකේ අනිත් අයත් එක්ක collaborate කරන්න මේක ගොඩක් වැදගත්.
• Virtual Environments (venv) භාවිතා කරන්න: සෑම project එකකටම වෙනම virtual environment එකක් භාවිතා කරන්න පුරුදු වෙන්න. මේකෙන් dependency conflicts වළක්වාගන්න පුළුවන්.

අවසන් වශයෙන්

අද අපි Module සහ Package කියන Python වල මාරම වැදගත් සංකල්ප දෙක ගැන මුල ඉඳලා අගටම කතා කළා. මේවා අපේ code organize කරන්න, reuse කරන්න, maintenance පහසු කරන්න, එතකොට ලොකු Projects වලදී Team එකක් විදියට වැඩ කරන්නත් කොයි තරම් උදව් වෙනවද කියලා ඔයාලට දැන් තේරෙනවා ඇති.

කෝඩිං කරනකොට මේවා හරියට පාවිච්චි කරන එක, හොඳ programmer කෙනෙක්ට අත්‍යවශ්‍ය දෙයක්. දැන් ඔයාලත් මේවා ගැන හොඳට තේරුම් ගත්තානේ. නිකම් කියවලා හරියන්නේ නෑ, අතට වැඩේ කරලා බලන්න. පොඩි Modules ටිකක් හදලා, ඒ ටික import කරලා බලන්න. Project එකක් හදද්දි මේ Concepts apply කරන්න පුරුදු වෙන්න. ගැටළුවක් ආවොත්, කලබල නොවී Google කරලා, Stack Overflow වගේ තැන් බලලා විසඳුම් හොයාගන්න පුරුදු වෙන්න.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න, නැත්නම් ඔයාලා දන්න තව tips තියෙනවා නම් පහලින් Comment section එකේ දාන්න. හැමදාම වගේ කියන්නේ, කෝඩිං කියන්නේ පුරුද්දක්. හැමදාම අලුත් දෙයක් ඉගෙන ගන්න, අත්හදා බලන්න! එහෙනම්, තවත් ලිපියකින් හමුවෙමු! කෝඩිං වැඩ සාර්ථක වේවා!