Python Debugging Techniques Sinhala Guide | දෝෂ සොයන හැටි ඉගෙන ගනිමු

ආයුබෝවන් යාළුවනේ!

මෘදුකාංග සංවර්ධනයේදී අපිට අනිවාර්යයෙන්ම මුණගැහෙන දෙයක් තමයි 'bugs' නැත්නම් 'දෝෂ'. කේත ලියන හැමෝටම මේවා එනවා, ඒක සාමාන්‍ය දෙයක්. වැදගත් වෙන්නේ මේ දෝෂ ඉක්මනින් හොයාගෙන, ඒවා නිවැරදි කරගන්න පුළුවන් වෙන එක. අන්න ඒකට තමයි Debugging Techniques අපිට උදව් කරන්නේ. මේ ලිපියෙන් අපි Python වලදී මේ දෝෂ හොයන සහ නිවැරදි කරන ක්‍රම ගැන කතා කරමු, සරලව තේරෙන විදිහට, අපේම භාෂාවෙන්.

ඔබ Python වලට අලුත් කෙනෙක් වුණත්, නැත්නම් ටිකක් කේත ලියලා තියෙන කෙනෙක් වුණත්, මේ Debugging Techniques ගැන හොඳ අවබෝධයක් තියෙන එක ඔබේ වැඩේ ගොඩක් පහසු කරයි, ඒ වගේම ඔබව හොඳ programmer කෙනෙක් බවට පත් කරයි. එහෙනම් අපි පටන් ගමුද?

print() Statements - ත්‍යාගශීලී මිතුරා

Debugging වලදී අපි මුලින්ම පාවිච්චි කරන සරලම ක්‍රමය තමයි print() statements පාවිච්චි කරන එක. මේක පුංචි පුංචි දෝෂ හොයාගන්නත්, variable එකක අගය මොකක්ද කියලා බලන්නත්, code එකේ flow එක කොහොමද යන්නේ කියලා දැනගන්නත් ගොඩක් ප්‍රයෝජනවත්. විශේෂයෙන්ම, ඔබ ඉක්මනින්ම මොකක් හරි අගයක් බලන්න ඕනේ නම්, හෝ code එකේ යම් තැනකට වැඩසටහන එනවද කියලා බලන්න නම් print() එකක් දාන එක ගොඩක් පහසුයි.

හිතන්නකෝ, ඔබ ලියපු code එකේදී variable එකක අගය ඔබ බලාපොරොත්තු වෙන දේ නෙවෙයි කියලා. එතකොට ඒ අගය මොකක්ද කියලා බලන්න print() එකක් දාන්න පුළුවන්. මේකෙන් ඔබට ක්ෂණිකව තොරතුරු ලබාගන්න පුළුවන්.

උදාහරණයක්:

def calculate_total(price, quantity):
    print(f"DEBUG: Function entered with price = {price}, quantity = {quantity}") # Debugging line
    if not isinstance(price, (int, float)) or not isinstance(quantity, int):
        print("DEBUG: Invalid input types detected!") # Another debugging line
        return None
    total = price * quantity
    print(f"DEBUG: Calculated total = {total}") # Debugging line to see the result
    return total

item_price = 100
item_quantity = 5

print("DEBUG: Calling calculate_total...")
final_bill = calculate_total(item_price, item_quantity)
print(f"Final bill: {final_bill}")

print("\nDEBUG: Testing with an invalid input...")
# වැරදි ගණනය කිරීමක් සිදුවන අවස්ථාවක්: quantity එක string එකක් ලෙස දෙන විට
final_bill_invalid = calculate_total(item_price, "හතර") 
print(f"Final bill (invalid input): {final_bill_invalid}")

මේ print() statements වලින් අපිට පේනවා price එකයි, quantity එකයි හරියට එනවද කියලා, ඊට පස්සේ calculate කරපු total එකත් බලාගන්න පුළුවන්. එතකොට "හතර" වගේ string එකක් දුන්නම මොකද වෙන්නේ කියලත් අපිට DEBUG output එකෙන් පැහැදිලිව පේනවා. හැබැයි, මේක ලොකු project එකකදී, විශේෂයෙන්ම සංකීර්ණ දෝෂ හොයද්දී ටිකක් අමාරු වෙනවා. Code එක පුරාම print() statements දාන්න වෙනවා, ඒවා පස්සේ අයින් කරන්නත් අමතක වෙන්න පුළුවන්, නැත්නම් ඒවා production code එකට ගිහින් అనවශ්‍ය output පෙන්වන්න පුළුවන්. අන්න එතකොට තමයි අපිට IDE Debuggers වලට යන්න වෙන්නේ.

IDE Debuggers - ඔබේ බලගතු ආයුධය

IDE (Integrated Development Environment) Debugger එකක් කියන්නේ දෝෂ හොයන්න තියෙන බලගතුම මෙවලම. Visual Studio Code (VS Code) වගේම PyCharm වගේ IDE වලට තමන්ගේම Debuggers තියෙනවා. මේවායින් අපිට පුළුවන් code එක පියවරෙන් පියවර run කරන්න, variables වල අගයන් බලන්න, code එකේ flow එක නිවැරදිද කියලා චෙක් කරන්න. මේක හරියට, ඔබගේ code එක run වෙද්දී, ඒක ඇතුළත මොකද වෙන්නේ කියලා live බලනවා වගේ දෙයක්.

ප්‍රධාන Concepts:

• Breakpoints: මේක තමයි Debugger එකේ හදවත. Breakpoint එකක් කියන්නේ ඔබ code එකේ නවත්වන්න ඕන තැනක්. Debugger එක run වෙද්දී Breakpoint එකක් තියෙන තැනට ආවම, ඒක නවතිනවා. දැන් ඔබට පුළුවන් ඒ මොහොතේ code එකේ තත්වය නිරීක්ෂණය කරන්න. Breakpoint එකක් දාන්න පුළුවන් code line එකේ වම් පැත්තේ click කරලා. මේවා ඕනෑම වෙලාවක දාන්නත්, අයින් කරන්නත්, disable කරන්නත් පුළුවන්.
• Stepping: Debugger එක නැවතුනාට පස්සේ, ඔබට පුළුවන් code එක පියවරෙන් පියවර ඉස්සරහට යවන්න. මේකට ක්‍රම කීපයක් තියෙනවා. මේවායින් program flow එක හොඳින් අවබෝධ කරගන්න පුළුවන්:
  • Step Over (F10 / N): මේකෙන් කරන්නේ වර්තමාන line එක execute කරලා ඊළඟ line එකට යන එක. Function calls තියෙනවා නම්, ඒ function එක ඇතුලට නොගිහින්, ඒක සම්පූර්ණයෙන්ම run කරලා, ඒ function call එකෙන් පස්සේ තියෙන line එකට යනවා. මේක සාමාන්‍යයෙන් භාවිතා වෙන්නේ function එකක් හරියට වැඩ කරනවා කියලා විශ්වාස නම්.
  • Step Into (F11 / I): මේකත් වර්තමාන line එක execute කරලා ඊළඟ line එකට යනවා. හැබැයි, වර්තමාන line එකේ function call එකක් තියෙනවා නම්, මේකෙන් ඒ function එක ඇතුලට යනවා. ඒ function එකේ පළවෙනි line එකේ ඉඳන් ඔබට step කරන්න පුළුවන්. මේක ගොඩක් වැදගත් වෙන්නේ ඔබ සැක කරන function එකක ඇතුළත දෝෂයක් තියෙනවා කියලා හිතනවා නම්.
  • Step Out (Shift+F11 / O): ඔබ function එකක් ඇතුලට ගිහින් ඉන්න වෙලාවක, ඒ function එකේ ඉතුරු ටික run කරලා, ඒ function call එකෙන් එළියට ආවම තියෙන line එකට යන්න මේක පාවිච්චි කරන්න පුළුවන්. මේකෙන් කාලය ඉතිරි කරගන්න පුළුවන්.
  • Continue (F5 / C): මේකෙන් කරන්නේ ඊළඟ breakpoint එකට යනකම් නැත්නම් program එක ඉවර වෙනකම් run කරන එක.
• Inspecting Variables: Debugger එක නැවතිලා තියෙන වෙලාවේ, ඔබට පුළුවන් ඒ මොහොතේ active වෙලා තියෙන variables වල අගයන් මොනවද කියලා බලන්න. IDE එකේ Debugger pane එකේ මේවා පෙන්නනවා. ඔබට පුළුවන් මේ variable values live update වෙන හැටි බලන්න. සමහර IDE වලට පුළුවන් code එකේ hover කරලා වුණත් variable අගයන් බලන්න, මේක ගොඩක් පහසුයි.
• Call Stack: Call Stack එකෙන් පෙන්නනවා ඔබගේ program එක මේ මොහොතට ආවේ මොන functions හරහාද කියලා. මේකෙන් code එකේ flow එක තේරුම් ගන්න ගොඩක් උදව් වෙනවා, විශේෂයෙන්ම ගැඹුරට ගිය function calls තියෙනකොට. මේකෙන් program එකේ execution path එක තේරුම් ගන්න පුළුවන්.
• Watch Expressions: මේකෙන් ඔබට ඕන කරන variables වල අගයන් හෝ complex expressions වල අගයන්, code එක run වෙද්දී update වෙන හැටි නිරීක්ෂණය කරන්න පුළුවන්. මේකෙන් focus කරන්න ඕන දත්ත පැහැදිලිව දැකගන්න පුළුවන්.

Practical Debugging - දෝෂයක් හඹා යමු!

දැන් අපි පොඩි program එකක් අරගෙන, ඒකේ තියෙන දෝෂයක් IDE Debugger එකක් පාවිච්චි කරලා හොයමු. අපි VS Code පාවිච්චි කරමු, මොකද ඒක ගොඩක් ජනප්‍රියයි සහ භාවිතා කරන්න පහසුයි. මේ උදාහරණය හොඳින් අවබෝධ කරගන්න, ඔබත් VS Code එකේ මේ දේම උත්සාහ කරන්න.

වැරදි සහිත Python Program එක: buggy_program.py

# buggy_program.py

def calculate_discounted_price(original_price, discount_percentage):
    # This function is supposed to calculate the discounted price
    # if discount_percentage is 20, then 20% discount
    print(f"Inside calculate_discounted_price: original={original_price}, discount={discount_percentage}")
    discount_amount = original_price * (discount_percentage / 100)
    final_price = original_price - discount_amount
    print(f"Discounted price calculated as: {final_price}")
    return final_price

def apply_tax(price, tax_rate):
    # This function applies tax to the price
    print(f"Inside apply_tax: price={price}, tax_rate={tax_rate}")
    tax_amount = price * tax_rate
    final_price_with_tax = price + tax_amount
    print(f"Price after tax: {final_price_with_tax}")
    return final_price_with_tax

product_price = 2000
discount = 10 # 10% discount
tax = 0.05 # 5% tax

# Expected Logic:
# 1. Apply discount to original price
#    2000 - (2000 * 0.10) = 2000 - 200 = 1800
# 2. Apply tax to the discounted price
#    1800 + (1800 * 0.05) = 1800 + 90 = 1890
# So, the final expected price is 1890.

discounted_price = calculate_discounted_price(product_price, discount)
# Potential logic error: We intend to apply tax on the discounted price, 
# but what if we accidentally pass the original price?
final_price_with_tax = apply_tax(product_price, tax) # <-- This is our suspected faulty line!

print(f"\nOriginal Price: {product_price}")
print(f"Discount: {discount}%")
print(f"Tax Rate: {tax*100}%")
print(f"Calculated Final Price: {final_price_with_tax}")

# If you run this, you'll see the 'Calculated Final Price' is NOT 1890.
# Let's use the debugger to find out why!

VS Code වලින් Debug කරන ආකාරය:

1. VS Code විවෘත කරන්න: buggy_program.py file එක VS Code එකේ විවෘත කරන්න.
2. Breakpoint එකක් දාන්න: final_price_with_tax = apply_tax(product_price, tax) කියන line එකේ වම් පැත්තේ click කරලා Breakpoint එකක් දාන්න. එතකොට රතු පාට තිතක් පේයි. මේ Breakpoint එකෙන් අපි Debugger එකට කියන්නේ, මේ line එකට ආවම වැඩසටහන නවත්වන්න කියලා.
3. Debugging පටන් ගන්න: VS Code එකේ වම් පැත්තේ තියෙන 'Run and Debug' icon එක click කරන්න (bug icon එක). ඊට පස්සේ 'Run and Debug' button එක click කරන්න, නැත්නම් F5 ඔබන්න.
4. Debugger එක නවතිනවා: Program එක run වෙලා, ඔබ දාපු Breakpoint එකේ හරියටම නවතිනවා. දැන් ඔබට Debugger Controls toolbar එක සහ Variables, Watch, Call Stack වගේ panels පේනවා ඇති.
5. Variables Inspect කරන්න: 'Variables' panel එකේ බලන්න. ඔබට පේයි product_price, discount, tax, සහ discounted_price කියන variables වල අගයන්. මෙහිදී ඔබට discounted_price එක 1800.0 ලෙස පෙනෙනු ඇත. මේ අගය අපිට බලාපොරොත්තු වූ විදියටම තිබෙනවා.
6. Step Over කරන්න: දැන් Debugger Controls toolbar එකේ තියෙන 'Step Over' (F10) button එක click කරන්න. එතකොට final_price_with_tax = apply_tax(product_price, tax) කියන line එක execute වෙලා ඊළඟ line එකට යනවා. මේ function call එක ඇතුලට යන්නේ නැතුව, එහි ප්‍රතිඵලය ලබාගෙන ඊළඟට යනවා.
7. දෝෂය හඳුනා ගන්න: final_price_with_tax variable එකේ අගය දැන් 'Variables' panel එකේ බලන්න. ඔබට පේයි ඒක 2100.0 කියලා. හැබැයි අපි බලාපොරොත්තු වුණේ 1890.0 නේ? මේ වෙනස තමයි අපේ දෝෂය.
   දැන් apply_tax function call එක දිහා හොඳට බලන්න: apply_tax(product_price, tax). මෙතනට අපි දීලා තියෙන්නේ product_price එක මිසක්, discounted_price එක නෙවෙයි. අන්න එතන තමයි දෝෂය! අපිට අවශ්‍ය වෙන්නේ discount එක අඩු කරපු අගයට tax එක එකතු කරන්නයි.
8. දෝෂය නිවැරදි කරන්න: Debugger එක නවත්වලා (Stop button), buggy_program.py file එකේ final_price_with_tax = apply_tax(product_price, tax) කියන line එක final_price_with_tax = apply_tax(discounted_price, tax) කියලා වෙනස් කරන්න.
9. නැවත Run කරන්න: දැන් නැවත program එක run කරලා බලන්න. Output එක Calculated Final Price: 1890.0 කියලා එනවා නම්, ඔබ දෝෂය සාර්ථකව නිවැරදි කරලා!

මේ විදිහට පියවරෙන් පියවර ගිහින්, variables වල අගයන් නිරීක්ෂණය කරලා, code එකේ flow එක තේරුම් අරගෙන දෝෂ හොයන්න Debuggers ගොඩක් උදව් වෙනවා. ඒක හරියට X-ray scan එකක් වගේ, code එක ඇතුලේ මොකද වෙන්නේ කියලා බලාගන්න පුළුවන්.

Debugger Tips & Best Practices - දක්ෂයෙකු වීමට

Debugger එකක් පාවිච්චි කරන එක කලාවක්. ඒකෙන් උපරිම ප්‍රයෝජන ගන්න නම්, මේ කරුණු ටික මතක තියාගන්න.

• ඔබේ Debugger එක හොඳින් ඉගෙන ගන්න: ඔබ පාවිච්චි කරන IDE (VS Code, PyCharm) එකේ Debugger එකේ සියලු features ගැන ඉගෙන ගන්න. Conditional breakpoints (යම් condition එකක් meet වුණොත් විතරක් නවතින breakpoints), log points (නවතින්නේ නැතුව message එකක් print කරනවා), watch expressions වගේ advanced features තියෙනවා. මේවා දන්න තරමට ඔබේ Debugging වැඩේ පහසු වෙනවා. YouTube tutorials බලන්න, official documentation කියවන්න.
• Systematic Approach එකක් ගන්න: දෝෂයක් ආවම කලබල නොවී, systematic විදිහට හොයන්න. මුලින්ම error message එක හොඳට කියවන්න (traceback). ඊට පස්සේ, code එකේදී ඒ error එක එන්න පුළුවන් තැන් ගැන හිතන්න. Debugger එක දාගෙන පියවරෙන් පියවර ගිහින් හොයන්න. print() statements වලින් හිතුවක්කාර විදියට code එක පුරවන්න එපා.
• Minimizing Test Case: ලොකු code එකක දෝෂයක් ආවම, ඒ දෝෂය එන පුංචිම code කෑල්ලක් හදාගන්න උත්සාහ කරන්න. මේක Minimal Reproducible Example (MRE) එකක් කියලා හඳුන්වනවා. එතකොට දෝෂය හොයන එක ගොඩක් පහසු වෙනවා, ඒ වගේම අනිත් අයගෙන් උදව් ඉල්ලන්නත් පහසුයි.
• Rubber Duck Debugging: මේක නම් ටිකක් විහිලු වගේ තේරුණාට, ගොඩක් ප්‍රයෝජනවත් ක්‍රමයක්. ඔබ ලියපු code එක අනිත් කෙනෙකුට (හෝ රබර් තාරාවෙකුට, අනිවාර්යයෙන්ම මිනිසෙකුට අවශ්‍ය නැහැ!) පැහැදිලි කරන්න උත්සාහ කරන්න. ඔබ අනිත් කෙනෙකුට code එකේ logic එක පැහැදිලි කරද්දී, ඔබගේම හිතට code එකේ flow එක ගැන, වැරදි තියෙන්න පුළුවන් තැන් ගැන අදහසක් එනවා.
• Version Control පාවිච්චි කරන්න: Git වගේ Version Control System එකක් පාවිච්චි කරන එක දෝෂ හොයද්දී ගොඩක් උදව් වෙනවා. ඔබට පුළුවන් වෙනස්කම් revert කරන්න, කලින් තිබ්බ good state එකට යන්න, වෙනස්කම් බලන්න. යම් commit එකකින් පස්සේ තමයි error එක ආවේ කියලා තේරෙනවා නම්, git bisect වගේ commands පාවිච්චි කරන්න පුළුවන්.

නිගමනය

ඉතින් යාළුවනේ, Python වලදී දෝෂ හොයන Debugging Techniques ගැන ඔබට හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා. print() statements වලින් පටන් අරගෙන, IDE Debuggers වල බලය පාවිච්චි කරනකම් අපි ගොඩක් දේවල් කතා කළා. මතක තියාගන්න, දෝෂ එන එක සාමාන්‍යයි, හැබැයි ඒ දෝෂ ඉක්මනින් සහ කාර්යක්ෂමව නිවැරදි කරගන්න පුළුවන් වෙන එක තමයි දක්ෂ programmer කෙනෙක්ගේ ලක්ෂණය.

මේ Debugging techniques ඔබේ next project එකේදී apply කරලා බලන්න. මුලින් අමාරු වුණත්, පුරුදු වෙද්දී මේක ගොඩක් පහසු වේවි. ඔබට මේ ගැන තවත් ප්‍රශ්න තියෙනවා නම්, නැත්නම් ඔබේම Debugging tips තියෙනවා නම්, පහතින් comment එකක් දාන්න! අපි කතා කරමු, අත්දැකීම් බෙදා හදා ගනිමු.

ඔබට සුභ දවසක්, සහ happy debugging!