27: ഡീബഗ്ഗിംഗും കോഡ് ക്വാളിറ്റിയും
ഈ കോഴ്സിൽ പല തവണ പിശക് സന്ദേശങ്ങൾ (tracebacks) കണ്ടു. അവ ഭയപ്പെടുത്തുന്നതായി തോന്നാം, പക്ഷേ അവ വായിക്കാൻ പഠിച്ചാൽ, ഏത് പ്രശ്നവും വേഗത്തിൽ കണ്ടെത്താൻ കഴിയും. ഈ അധ്യായത്തിൽ ഡീബഗ്ഗിംഗും, മറ്റുള്ളവർക്ക് (ഭാവിയിലെ നിങ്ങൾക്കും!) വായിക്കാൻ എളുപ്പമുള്ള കോഡ് എഴുതാനുള്ള ശീലങ്ങളും പഠിക്കും.
ട്രെയ്സ്ബാക്ക് വായിക്കുന്നു
ഒരു ഫംഗ്ഷൻ മറ്റൊരു ഫംഗ്ഷനെ വിളിക്കുമ്പോൾ പിശക് വന്നാൽ, ട്രെയ്സ്ബാക്കിന് ഒന്നിലധികം വരികൾ ഉണ്ടാകും. താഴെയുള്ള കോഡ് റൺ ചെയ്ത് ട്രെയ്സ്ബാക്ക് ശ്രദ്ധിക്കൂ:
def get_price(product):
prices = {"pen": 10, "book": 50}
return prices[product]
def print_total(product, quantity):
price = get_price(product)
print(price * quantity)
print_total("pencil", 3)ട്രെയ്സ്ബാക്ക് വായിക്കേണ്ട ക്രമം:
- ഏറ്റവും താഴെയുള്ള വരി — യഥാർത്ഥ പിശകിന്റെ തരവും സന്ദേശവും (ഇവിടെ
KeyError: 'pencil') - അതിന് മുകളിലുള്ള വരികൾ — ഏത് ഫംഗ്ഷനിൽ നിന്ന് ഏത് ഫംഗ്ഷനിലേക്കാണ് വിളി പോയത് എന്ന കോൾ ചെയിൻ (താഴെ നിന്ന് മുകളിലേക്ക്:
get_price()-നുള്ളിൽ, അത്print_total()-ൽ നിന്ന് വിളിച്ചത്) - ഓരോ വരിയിലും ഏത് ഫയൽ, ഏത് വരി നമ്പർ എന്ന് കാണിക്കുന്നു — അതാണ് പ്രശ്നമുള്ള കൃത്യമായ സ്ഥലം
ഏറ്റവും താഴെയുള്ള വരി എപ്പോഴും ആദ്യം വായിക്കുക — അതാണ് "എന്താണ് തെറ്റായത്" എന്ന് കൃത്യമായി പറയുന്നത്.
ഡീബഗ്ഗിംഗ് ടെക്നിക്: `print()` ഉപയോഗിച്ച് പരിശോധിക്കുക
ഒരു പ്രോഗ്രാം പ്രതീക്ഷിച്ച ഫലം തരാതെ വരുമ്പോൾ, ഏറ്റവും ലളിതമായ ടെക്നിക് ഇതാണ്: സംശയമുള്ള സ്ഥലങ്ങളിൽ താൽക്കാലികമായി print() ചേർത്ത്, വേരിയബിളുകളുടെ മൂല്യവും ഡാറ്റാ തരവും പരിശോധിക്കുക.
def calculate_total(price, quantity):
print("DEBUG:", type(price), price, type(quantity), quantity) # താൽക്കാലിക ഡീബഗ് വരി
return price * quantity
total = calculate_total("50", 3)
print(total)ഇവിടെ price ഒരു സ്ട്രിംഗ് ആണ് ("50"), സംഖ്യയല്ല — അതുകൊണ്ട് price * quantity ഗുണനത്തിന് പകരം "50" മൂന്ന് തവണ ആവർത്തിക്കുന്നു. ഈ ഡീബഗ് print() ഇല്ലായിരുന്നെങ്കിൽ, എന്തുകൊണ്ടാണ് ഫലം തെറ്റായത് എന്ന് കണ്ടെത്താൻ പ്രയാസമായേനെ. പ്രശ്നം കണ്ടെത്തിക്കഴിഞ്ഞാൽ, ഡീബഗ് print() വരികൾ കോഡിൽ നിന്ന് നീക്കം ചെയ്യാൻ മറക്കരുത്.
PEP 8: പൈത്തൺ കോഡ് ശൈലി
PEP 8 പൈത്തൺ കമ്മ്യൂണിറ്റി അംഗീകരിച്ച ഔദ്യോഗിക കോഡ് ശൈലി മാർഗ്ഗരേഖയാണ്. ഇത് പിന്തുടർന്നാൽ, മറ്റ് പൈത്തൺ ഡെവലപ്പർമാർക്ക് നിങ്ങളുടെ കോഡ് വേഗത്തിൽ വായിക്കാൻ കഴിയും.
| നിയമം | ഉദാഹരണം |
|---|---|
വേരിയബിളും ഫംഗ്ഷനും snake_case-ൽ | user_age, calculate_total() |
| സ്ഥിരാങ്കങ്ങൾ (constants) വലിയക്ഷരത്തിൽ | MAX_USERS = 100 |
| ഇൻഡന്റേഷൻ സ്ഥിരമായി സൂക്ഷിക്കുക | ടാബോ 4 സ്പേസോ, ഒരു ഫയലിൽ ഒരു രീതി മാത്രം |
| ഒരു വരി വളരെ നീളമാകാതെ നോക്കുക | ~79-99 അക്ഷരത്തിനുള്ളിൽ |
| ഫംഗ്ഷനുകൾക്കിടയിൽ ഒരു ശൂന്യ വരി | വായനക്ഷമതയ്ക്ക് |
ഈ കോഴ്സിലെ കോഡ് ഉദാഹരണങ്ങൾ ഇൻഡന്റേഷനായി ടാബ് ഉപയോഗിക്കുന്നു. PEP 8 സാധാരണയായി 4 സ്പേസ് ശുപാർശ ചെയ്യുന്നു — രണ്ടും സാധുവാണ്, പ്രധാനം ഒരു പ്രോജക്റ്റിനുള്ളിൽ ഒരേ രീതി സ്ഥിരമായി ഉപയോഗിക്കുക എന്നതാണ്.
നല്ല വേരിയബിൾ പേരുകൾ
രണ്ട് പതിപ്പുകൾ താരതമ്യം ചെയ്യൂ — രണ്ടും ഒരേ കാര്യമാണ് ചെയ്യുന്നത്:
# മോശം പേരുകൾ — എന്താണ് ചെയ്യുന്നത് എന്ന് ഊഹിക്കണം def f(x, y): z = x * y * 0.18 return z print(f(500, 3))
# നല്ല പേരുകൾ — വായിച്ചാൽ തന്നെ മനസ്സിലാകും def calculate_tax(price, quantity): tax = price * quantity * 0.18 return tax print(calculate_tax(500, 3))
രണ്ട് ഫംഗ്ഷനുകളും കൃത്യമായി ഒരേ ഫലം തരുന്നു. പക്ഷേ ആറ് മാസത്തിന് ശേഷം ഈ കോഡ് തിരികെ വായിക്കുമ്പോൾ (അല്ലെങ്കിൽ മറ്റൊരാൾ വായിക്കുമ്പോൾ), രണ്ടാമത്തേത് എന്താണ് ചെയ്യുന്നത് എന്ന് ഉടനെ മനസ്സിലാകും — ആദ്യത്തേതിന് കോഡ് മുഴുവൻ വീണ്ടും വായിച്ച് ഊഹിക്കേണ്ടി വരും.
ചെറിയ കോഡ് ഓർഗനൈസേഷൻ നുറുങ്ങുകൾ
- ഓരോ ഫംഗ്ഷനും ഒരു ജോലി മാത്രം ചെയ്യട്ടെ — ഒരു ഫംഗ്ഷൻ വളരെ കൂടുതൽ കാര്യങ്ങൾ ചെയ്യുന്നെങ്കിൽ, അതിനെ ചെറിയ ഫംഗ്ഷനുകളാക്കി വിഭജിക്കുക
- ഒരേ കോഡ് പലയിടത്തും ആവർത്തിക്കുന്നെങ്കിൽ, അതിനെ ഒരു ഫംഗ്ഷനാക്കുക (DRY — Don't Repeat Yourself)
- കമന്റുകൾ എന്ത് ചെയ്യുന്നു എന്നല്ല, എന്തുകൊണ്ട് ചെയ്യുന്നു എന്ന് വിശദീകരിക്കട്ടെ — കോഡ് തന്നെ "എന്ത്" വ്യക്തമാക്കണം
സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ
- പിശക് സന്ദേശം പൂർണ്ണമായി വായിക്കാതെ, ഊഹിച്ച് കോഡ് ക്രമരഹിതമായി മാറ്റുന്നു
- ഏറ്റവും താഴെയുള്ള വരിക്ക് പകരം, ട്രെയ്സ്ബാക്കിന്റെ മുകൾഭാഗം മാത്രം നോക്കുന്നു
- ഡീബഗ് ചെയ്യാൻ ചേർത്ത
print()വരികൾ, പ്രശ്നം പരിഹരിച്ച ശേഷം നീക്കം ചെയ്യാൻ മറക്കുന്നു
ഈ അധ്യായത്തിന്റെ സംഗ്രഹം
- ഒരു മൾട്ടി-ലെവൽ ട്രെയ്സ്ബാക്ക് എങ്ങനെ വായിക്കാം എന്ന് പഠിച്ചു
print()ഉപയോഗിച്ചുള്ള ഡീബഗ്ഗിംഗ് ടെക്നിക് പരിശീലിച്ചു- PEP 8 കോഡ് ശൈലി മാർഗ്ഗരേഖ പരിചയപ്പെട്ടു
- നല്ല വേരിയബിൾ പേരുകൾ വായനക്ഷമതയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് നേരിട്ട് താരതമ്യം ചെയ്തു
- DRY തത്വവും ഫംഗ്ഷൻ ഓർഗനൈസേഷനും പഠിച്ചു
വ്യായാമങ്ങൾ
- മുൻ അധ്യായങ്ങളിലെ ഏതെങ്കിലും ഒരു കോഡ് എടുത്ത്, മോശം പേരുള്ള വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ അർത്ഥവത്തായ പേരുകളാക്കി മാറ്റുക
- മനഃപൂർവ്വം ഒരു
KeyErrorവരുത്തുന്ന ഒരു ചെറിയ പ്രോഗ്രാം എഴുതി, ട്രെയ്സ്ബാക്ക് വായിച്ച് ഏത് വരിയാണ് പ്രശ്നം എന്ന് കണ്ടെത്തുക - ഒരേ കണക്കുകൂട്ടൽ രണ്ട് സ്ഥലങ്ങളിൽ ആവർത്തിക്കുന്ന ഒരു ചെറിയ കോഡ് എഴുതി, അതിനെ ഒരു ഫംഗ്ഷനാക്കി മാറ്റി ആവർത്തനം ഒഴിവാക്കുക
Quiz & Self Assessment
അടുത്ത അധ്യായത്തിൽ, കോഡ് ശരിയായി പ്രവർത്തിക്കുന്നു എന്ന് ഉറപ്പാക്കാൻ സഹായിക്കുന്ന യൂണിറ്റ് ടെസ്റ്റിംഗ് എന്ന ആശയത്തിന്റെ ആമുഖം നിങ്ങൾ പഠിക്കും.