ஆசிரியர்: லிசா டாக்லியபெரி,

தமிழாக்கம்: முத்து அண்ணாமலை.

This article is a translation of tutorial article on PDB from DigitalOcean; இந்த கட்டுரை ஏற்கனவே வெளியீடான பயிற்சி கட்டுரை தமிழாக்கம் ஆகும்.

சுருக்கம்: பல சமயங்களில் நாம் எழுதிய நிரல்கள் நமது எண்ணம் போல இயங்குவதில்லை; இதை சரிசெய்ய திக்குத்தெரியாத காட்டில் தேவை ஒரு வழு நீக்கி என்ற செயலி; பைத்தான் மொழியில் இது pdb – இதன் செயல்பாடு சில சிறப்பம்சங்கள் பற்றி இங்கு பார்க்கலாம்.

கணினி துறையில் நிரலராக (programmer) செயல்படுவதில் ஒருவரி முக்கியாமாக பெற்றுக்கொள்ளும் திறமை வழுநீக்கம் – அதாவது debugging. விளையாட்டாக பேசுகையில் வழுநீக்கம் என்பதன் ஆங்கில சொல்லின் பகுதி-விகுதிகளை பிரித்துப்பார்த்தால், அது புழு/பூச்சி நீக்கம் என்றும் அசட்டுத்தனமாக இருக்கும். இதனை வேடிக்கையாக இப்படி ஒரு படத்தில் அந்தகாலத்து கணினியில் காட்டினார்கள்!

தொடர்வது லிசா எழுதிய https://www.digitalocean.com/community/tutorials/how-to-use-the-python-debugger இந்த 2017-ஆம் ஆண்டு கட்டுரையின் தமிழாக்கம்.

அறிமுகம்

கணினி உருவாக்கம் மற்றும் கட்டமைப்பில் வழுநீக்கம் என்பது கணினி செயலியின் தவறான/பிழையாக இயங்கும் இடங்களை மூல நிரலில் தேடிக் கண்டறிந்தும் பின் அவ்வகையான பிழைகளை நீக்கம் செய்யும் படிநிலை செயல்பாட்டிற்கு அளிக்கப்படும் பெயராகும்.

பைத்தான் மொழியில் pdb என்ற ஒரு வழு நீக்கி செயலி உள்ளது; இது python மொழியில் எழுதிய நிரல்களுக்கு ஒரு வழுநீக்கம் செய்யும் சூழலை அளிக்கிறது. pdb மூலம் நிபந்தனை நிறுத்தங்கள் (conditional breakpoints), வரிவரியான கண்காணிப்பு இயக்கம் (stepping through the source code one line at a time), அடுக்கு கண்கானிப்பு (stack inspection), என பல வைகயான உத்திகளைக்கொண்டு நிரலின் இயக்க நிலைகளை காணமுடிகிறது.

pdbஐ படிப்படியாக பயன்படுத்துதல்

பைத்தான் மொழியில் தரப்படுத்தப்பட்ட ஒரு நிரல்தொகுப்பு (module) வழியாக இந்த pdb வழுநீக்கி நமக்கு கிடைக்கிறது. இந்த Pdb வழுநீக்கியையே நீட்சி செய்து நாம் ஒரு நிரல்கூட எழுதலாம்க். pdb பற்றிய மூல ஆவணத்தை இங்கு படிக்கலாம்.

pdb பற்றி கற்றுக்கொள்ள நாம் ஒரு சின்ன நிரலின் வழுநீக்கம் வழியாக கற்றுக்கொள்ளலாம்; இந்த நிரலில் இரு பொதுவெளி மாறிகள் (global variables), ஒரு நிரல்பாக சார்பும் (function) அதனுள் உள்ள அடுக்கு மடக்கு வாக்கியமும் (loop), இவை அனைத்தையும் தொடங்கிவைக்கும் if __name__ == '__main__': என்ற நிரல்தொடக்க நிபந்தனையும் (அதாவது சார்பு nested_loop() என்பதை தொடக்கிவிடும்) வகையில் அமைந்தது இந்த நிரல் looping.py

num_list = [500, 600, 700]
alpha_list = ['x', 'y', 'z']

def nested_loop():
    for number in num_list:
        print(number)
        for letter in alpha_list:
            print(letter)

if __name__ == '__main__':
    nested_loop()

பைத்தான் வழுநீக்கம் என்பதை நமது நிரலில் தொடங்க இவ்வாறு கட்டளை அளிக்க வேண்டும்:

python -m pdb looping.py

இந்த -m என்ற flag பைத்தான் moduleஐ ஒரு நிரலாக இயக்க வழிசெய்யும். மேல் கண்டபடி கட்டளையிட்டால் நமது நிரல் (looping.py) பைத்தான் வழு நீக்கியான pdb-யினைக்கொண்டு அதன் கண்காணிப்பில் இயங்கும்.

மேல்கண்ட கட்டளை இயங்கியதும் இவ்வறு வெளியீடை காணலாம்:

Output> /Users/sammy/looping.py(1)<module>()
-> num_list = [500, 600, 700]
(Pdb) 

இதில், முதல் வரியில் (அதாவது <module> என்ற வரி) நிரல் கோப்பின் இருப்பிடம், மற்றும் நிரலின் இயங்கும் வரி (இங்கு முதல் வரி இயங்குகிறது). ‘->’ என்ற குறியிடின் அடுத்து வரும் வரி நிரலின் தற்சமயம் உள்ள இயக்கப்புள்ளியைச் சேர்ந்த வரியாகும். வழு நீக்கியின் திறன்கள் மற்றும் கட்டளைகளை பற்றி கற்றுக்கொள்ள  help <கட்டளை>  என்று கட்டளையின் பெயரை pdb shell-இல் இட்டு அந்த கட்டளையினைப்பற்றி குறிப்பாக கற்றுக்கொள்ளலாம். pdb கட்டளை திறை என்பதும் பைத்தான் console என்பதும் வெவ்வேரான விஷயங்கள் என்பதை கருத்தில் கொள்ள வேண்டும்.

pdb வழு நீக்கி நிரலின் இருதியில் மீண்டும் தொடங்கும் வகை கட்டமைக்கப்பட்டது; இதில் இருந்து வெளியேர quit அல்லது exit என்று கட்டளையிடவேண்டும். மேலும் நிரலின் ஏதேனும் குறிப்பிட்ட வரியில் இருந்து இயக்கத்தை தொடர வேண்டும் என்றால் run என்ற கட்டளையை pdb வழுநீக்கியால் செலுத்தலாம்.

வழு நீக்கியில் நிரல் இயக்கத்தை கண்கானித்தல்

pdb கட்டளைகளான list, step, மற்றும் next உங்களது நிரல் இயக்கத்தை கண்கானிக்கலாம். இந்த கட்டளைகளைப்பற்றி விரிவாக இந்த பத்தியில் பார்க்கலாம்.

pdb shell அதனில் list என்ற கட்டளையை இட்டால் தற்சமயம் இயங்கும் புள்ளியின் வரியின் சுற்றத்தில் உள்ள வரிகளை பார்க்கலாம்.  உதாரணமாக looping.py நிரலின் முதல் வரியின் சுற்றத்தில் — num_list = [500, 600, 700] — இப்படி வெளியீடு அளிக்கும்:

(Pdb) list
  1  -> num_list = [500, 600, 700]
  2     alpha_list = ['x', 'y', 'z']
  3     
  4     
  5     def nested_loop():
  6         for number in num_list:
  7             print(number)
  8             for letter in alpha_list:
  9                 print(letter)
 10     
 11     if __name__ == '__main__':
(Pdb) 

‘->’ என்ற குறியிடின் அடுத்து வரும் வரி நிரலின் தற்சமயம் உள்ள இயக்கப்புள்ளியைச் சேர்ந்த வரியாகும்.

நமது இந்த நிரல் சற்று சிறிதாக உள்ளதால் முழு நிரலையும் list கட்டளை இங்கு அளித்துவிடுகிறது. சராசரியான பயன்பாட்டில் list கட்டளை 11 வரிகளையும் முழுதாக வெளியிடுகிரது; ஆனால் list 3, 7 வரிகள் 3-இல் இருந்து 7-வரை மட்டும் வெளியிட வேண்டுமெனில் கீழ்கண்டபடி கட்டளையிடவும்: list 3, 7

(Pdb) list 3, 7
  3     
  4     
  5     def nested_loop():
  6         for number in num_list:
  7             print(number)
(Pdb) 

செயலியின் இயக்கத்தை நிரல் வரிகளில் ஒவ்வொரு வரியாக அலசுவதற்கு step அல்லது next கட்டளைகளை பயன்படுத்தலாம்; உதாரணம்:

(Pdb) step
> /Users/sammy/looping.py(2)<module>()
-> alpha_list = ['x', 'y', 'z']
(Pdb) 

(Pdb) next
> /Users/sammy/looping.py(2)<module>()
-> alpha_list = ['x', 'y', 'z']
(Pdb) 

step என்ற கட்டளைக்கும் next என்ற கட்டளைக்கும்  வித்தியாசமானது step என்பது சார்புகள், நிரல்துண்டுகளை கடக்கும்பொழுது அது நிறுத்தம் அடையும், ஆனால் next கட்டளை சார்புகளை முழுதாக இயகிய பின்னரே அதனை அடுத்த வரியில் சென்று நிற்கும்.

step கட்டளை மடக்கு வாக்கியங்களில் படிபடியாக ஒவ்வொரு வரியிலும் நிறுத்தி இயக்கத்தைக் காட்டும்; இதனைக்கொண்டு மாறிகளின் மதிப்புகள், மாறிகளை அச்சிடுவது, print(number), என்றும் letter என்றதை அச்சிடுவதும் print(letter), return number என்ற வரியை செயல்படுத்துவதையும் பார்க்கலாம்.

(Pdb) step
> /Users/sammy/looping.py(5)<module>()
-> def nested_loop():
(Pdb) step
> /Users/sammy/looping.py(11)<module>()
-> if __name__ == '__main__':
(Pdb) step
> /Users/sammy/looping.py(12)<module>()
-> nested_loop()
(Pdb) step
--Call--
> /Users/sammy/looping.py(5)nested_loop()
-> def nested_loop():
(Pdb) step
> /Users/sammy/looping.py(6)nested_loop()
-> for number in num_list:
(Pdb) step
> /Users/sammy/looping.py(7)nested_loop()
-> print(number)
(Pdb) step
500
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb) step
> /Users/sammy/looping.py(9)nested_loop()
-> print(letter)
(Pdb) step
x
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb) step
> /Users/sammy/looping.py(9)nested_loop()
-> print(letter)
(Pdb) step
y
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb)

ஒரு முழு சார்பு/நிரல்பாத்தினை next கட்டளை வழியாக செயல்படுத்தலாம் – இது படிநிலை இயக்கம் இல்லாமல் குறிப்பிட்ட சார்பினை முழுதாக கடந்து செல்லும். வழு நீக்கியை விட்டு வெளியேற exit கட்டளையிடவும். அதன்பின் மீண்டும் வழுநீக்கியை தொடங்கவும்:

python -m pdb looping.py

இப்பொழுது next கட்டளையின் செயல்பாடை காணலாம்:

(Pdb) next
> /Users/sammy/looping.py(5)<module>()
-> def nested_loop():
(Pdb) next
> /Users/sammy/looping.py(11)<module>()
-> if __name__ == '__main__':
(Pdb) next
> /Users/sammy/looping.py(12)<module>()
-> nested_loop()
(Pdb) next
500
x
y
z
600
x
y
z
700
x
y
z
--Return--
> /Users/sammy/looping.py(12)<module>()->None
-> nested_loop()
(Pdb)  

உங்கள் நிரலை வழு நீக்கி  மூலம் ஆராய்ச்சி செய்யும் பொழுது ஒரு மாறியின் மதிப்பை கண்டுபிடிக்க pp என்ற கட்டளையை கையாளவேண்டும்; இது pretty-print, அழுபடித்து அச்சிடு என்ற செயலின் ஆங்கில சொற்றொடரின் சுறுக்கமாக pp என்றபடி அமைத்தது; இதன் செயல்பாட்டின் வழியாக மாறியின் மதிப்பை ஒரு pprint  மோட்யூல் வழியாக அச்சிடும். உதாரணம் நமது தற்சமயமாக கையாளும் நிரலின் வழி இதைக்காணலாம்.

(Pdb) pp num_list
[500, 600, 700]
(Pdb) 

pdb இல் உள்ள பல கட்டளைகளுக்கும் முழு கட்டளை பெயரை இடாமல் சற்று குறுகிய வடிவில் (shortcut) தட்டச்சு செய்யலாம்; break என்பதற்கு b, step என்பதற்கு s, next என்றால் n என்றும் எழுதலாம். இதற்குமுன் இட்ட கட்டளை மருஇயக்கம் செய்ய ENTER என்ற விசை தட்டினால் போதும்.

நிறுத்தங்கள் (Breakpoints)

பல நூறு எண்கள் கொண்ட ஒரு நிரலினை வரிவரியாக இயக்கியும் ஆலோசனைசெய்யலாம் ஆனால் அதற்கு ஒரு முழு நாள் போய்விடும்; இதனை தவிற்க்கவும், நிரலினில் உள்ள சுவாரசியமான புள்ளிகளை மட்டுமே அலசுவதற்கு break என்ற கட்டளையைக்கொண்டு நிறுத்தப்புள்ளிகளை செயல்படுத்தலாம். அதாவது அவ்வபோது குறிப்பிட்ட நிறுத்தப்புள்ளிகளின்வரை இயக்கம் தொடர்ந்து செல்லும்.

நிறுத்தப்புள்ளிகளுக்கு pdb 1-இல் தொடங்கியவாரு முழு எண்களை (கூடும் வரிசையில்) குறியீடாக வைத்திருக்கும்; ஆகையால் நிறுத்தப்புள்ளிகளை முழு எண்கள் கொண்டும் குறிப்பிடலாம்.

நிறுத்தப்புள்ளிகளைக் குறிப்பிட <நிரல் கோப்பு>:<வரி எண்> என்றபடி குறிப்பிடலாம்:

(Pdb) break looping.py:5
Breakpoint 1 at /Users/sammy/looping.py:5
(Pdb)

கட்டளை clear என்று அளித்து அதன் கேள்விக்கு y என்றும் அடுத்து உள்ளீடு செய்தால் வழு நீக்கியில் அனைத்து நிறுத்தங்களும் அழிக்கப்படும். அடுத்து எங்கு வேண்டுமானாலும், தற்போது ஒரு சார்பின் தொடக்கத்தில் நிறுத்தம் இடலாம்:

(Pdb) break looping.nested_loop
Breakpoint 1 at /Users/sammy/looping.py:5
(Pdb) 

வழு நீக்கியில் அனைத்து நிறுத்தங்களும் அழிக்க கட்டளை clear என்று அளித்து அதன் கேள்விக்கு y என்றும் அடுத்து உள்ளீடு செய்தால் . நிறுத்தம் என்பது நிபந்தனைக்கு இனங்க செயல்படவும் செயற்படுத்தலாம் – உதாரணம்:

(Pdb) break looping.py:7, number > 500
Breakpoint 1 at /Users/sammy/looping.py:7
(Pdb)     

ஒரு நிறுத்தப்புள்ளியில் இருக்கும் பொழுது continue (தொடர்) என்ற கட்டளையை கொடுத்தால், நிபந்தனை மெய்யாகும் வரை அந்த நிறுத்தப்புள்ளி செயல்தவிர்க்கப்படும் – அதாவது இங்கு number என்ற மாறி 500-க்கும் கூடுதலான வகையில் இயங்கும் வரை அது செயல்படாமல் இருக்கும் (வேறு வகையில் சொல்லவேண்டுமானால் number என்ற மாறி 600 என்ற மதிப்பை வெளி மடக்கின் இரண்டாம் சுற்றில் பெரும் பொழுது இந்த நிறுத்தப்புள்ளி செயல்படும்):

(Pdb) continue
500
x
y
z
> /Users/sammy/looping.py(7)nested_loop()
-> print(number)
(Pdb) 

pdb-இல் உள்ள நிறுவப்பட்ட நிறுத்தப்புள்ளிகளை பார்க்க ‘break’ என்ற கட்டளையை அளிக்கவும்:

(Pdb) break
Num Type         Disp Enb   Where
1   breakpoint   keep yes   at /Users/sammy/looping.py:7
    stop only if number > 500
    breakpoint already hit 2 times
(Pdb) 

disable என்ற கட்டளையைக்கொண்டு ஒரு நிறுத்தப்புள்ளியை செயல்தவிர்க்கலாம்:

(Pdb) break looping.py:11
Breakpoint 2 at /Users/sammy/looping.py:11
(Pdb) disable 1
Disabled breakpoint 1 at /Users/sammy/looping.py:7
(Pdb) break
Num Type         Disp Enb   Where
1   breakpoint   keep no    at /Users/sammy/looping.py:7
    stop only if number > 500
    breakpoint already hit 2 times
2   breakpoint   keep yes   at /Users/sammy/looping.py:11
(Pdb) 

enable என்ற கட்டளையைக்கொண்டு ஒரு நிறுத்தப்புள்ளியை செயல்பாட்டிற்கு கொண்டுவரலாம்; clear என்ற கட்டளையினால் நிறுத்தப்புள்ளியை அழித்துவிடலாம்.

(Pdb) enable 1
Enabled breakpoint 1 at /Users/sammy/looping.py:7
(Pdb) clear 2
Deleted breakpoint 2 at /Users/sammy/looping.py:11
(Pdb) 

pdbயின் நிறுத்தப்புள்ளிகள் வழியாக நிரல் இயத்தின் மீது அதிகளவு கட்டுப்பாடு கிடைக்கிறது. நிறுத்தப்புள்ளிகளில் கூடுதல் செயல்பாடுகளானவை, ignore என்ற கட்டளை – இது நிறுத்தப்புள்ளியினுடன் இணைக்கப்பட்ட இணைசெயல்கள்/நிரல்துண்டுகளை அழித்துவிடு; அதேபோல் command என்ற கட்டளை நிறுத்தப்புள்ளியினுடன் சேர்ந்த இணைசெயல்கள்/நிரல்துண்டுகளை குறிப்பிட உதவும் – எ.கா. ‘command 1’ என்று தொடங்கி இணைசெயல்களைக் குறிப்பிட்டு முடிந்தபின் ‘end’ என்று முடிக்கலாம். மேலும் ‘tbreak’ என்ற கட்டளை ‘temporary break’ என்றதன் சுருக்கமாக முதன்முறை மட்டும் நிறுத்தப்புள்ளியை செயல்படுத்தி இரு இயக்கத்தில் பிடிபட்டபின் ‘clear’ என்ற கட்டளையை இதே நிறுத்தப்புள்ளிக்கு தானாக செலுத்திவிடும் தன்மை உடையது; ‘tbreak 3’ என்பது நிரலின் மேலே இயக்கப்பட்டது.

உங்கள் நிரல்களில் pdb-ஐ இணைப்பது

உங்கள் நிரல்களில் வழுநீக்கம் தானாக நிரல் செயல்பாட்டின் இடையேயும் தொட்டவைக்கலா; இதனைச்செய்ய pdb module-ஐ இணைத்தும் pdb சார்பான pdb.set_trace() என்ற நிரல்பாகம் குறிப்பிட்டிருக்க வேண்டும்; இயக்கம் இந்த நிரல் வரிக்கு வரும்பொழுது உங்கள் நிரலின் இயக்கத்தினிடையே வழு நீக்கி தொடக்கமாகிவிடும்.

உதாரணமாக, நமது மாதிரி நிரலில் (கீழே கொடுக்கப்பட்டது) import வாக்கியத்தின் மூலம் pdb-யின் set_trace சார்பினை அழைக்கவும். நமது உதாரணத்தில், இந்த வழு நீக்கம் சார்பை அடுக்கு மடக்கு வாக்கியதின் (nested loop) முன் சேர்த்துப் பரிசோதனை செய்யலாம்.

# Import pdb module
import pdb

num_list = [500, 600, 700]
alpha_list = ['x', 'y', 'z']

def nested_loop():
    for number in num_list:
        print(number)

        # வழு நீக்கி இங்கு தொடங்கும்
        pdb.set_trace()
        for letter in alpha_list:
            print(letter)

if __name__ == '__main__':
    nested_loop()

இந்த பத்தியில் காட்டியபடி உங்கள் நிரலில் இருந்தபடியே வழு நீக்கியை இணைத்தால் தனிப்பட்டபடி pdb-ஐ இணைக்கவும் வேண்டாம், நிறுத்தப்புள்ளிகளும் தேவையில்லை.

அதாவது pdb module வழியாக அழைக்கப்பட்ட pdb.set_trace() சார்பு உங்கள் நிரலில் எங்கு இங்குகிறதோ அதே இடத்தில் அந்த நிரல் வழு நீக்கியினில் செயல்படும்.

நிரல் இயக்கத்தை மாற்றுவது

Python pdb கட்டளை jump வழியாக இயங்கும் நேரத்தில் ஒரு நிரலின் இயக்கத்தை திசைமாற்றலாம். இதன் மூலம் ஒரு நிரலில் உள்ள சில நிரல்பாகங்களை முன் – பின் வரிசை மாற்றியும் செயல்படுத்தலாம்.

இந்த பகுதியில் sammy (நிரலில் "sammy") என்ற சரத்தில் உள்ள எழுத்துக்களை ஒரு பட்டியலாக பெருவதற்கு நிரல் எழுதுவோம்: letter_list.py

def print_sammy():
    sammy_list = []
    sammy = "sammy"
    for letter in sammy:
        sammy_list.append(letter)
        print(sammy_list)

if __name__ == "__main__":
    print_sammy()

python letter_list.py என்று இயக்கினால், இந்த வெளியீடை பார்க்கலாம் (இது நேர்கோட்டான இயக்கம் – எதுவும் மாற்றங்கள் இல்லாமல் இயக்கப்படுகிறது):

Output['s']
['s', 'a']
['s', 'a', 'm']
['s', 'a', 'm', 'm']
['s', 'a', 'm', 'm', 'y']

அடுத்த முறை இதே நிரலை pdb-யின் மூலம் for மடக்கு வாக்கியதின் இரண்டாம் சுற்றை நீக்கி (நேர்கோட்டற்ற இயக்கத்தின் வழி) இயக்கி பார்க்கலாம்:

python -m pdb letter_list.py

> /Users/sammy/letter_list.py(1)<module>()
-> def print_sammy():
(Pdb) list
  1  -> def print_sammy():
  2         sammy_list = []
  3         sammy = "sammy"
  4         for letter in sammy:
  5             sammy_list.append(letter)
  6             print(sammy_list)
  7     
  8     if __name__ == "__main__":
  9         print_sammy()
 10     
 11     
(Pdb) break 5
Breakpoint 1 at /Users/sammy/letter_list.py:5
(Pdb) continue
> /Users/sammy/letter_list.py(5)print_sammy()
-> sammy_list.append(letter)
(Pdb) pp letter
's'
(Pdb) continue
['s']
> /Users/sammy/letter_list.py(5)print_sammy()
-> sammy_list.append(letter)
(Pdb) jump 6
> /Users/sammy/letter_list.py(6)print_sammy()
-> print(sammy_list)
(Pdb) pp letter
'a'
(Pdb) disable 1
Disabled breakpoint 1 at /Users/sammy/letter_list.py:5
(Pdb) continue
['s']
['s', 'm']
['s', 'm', 'm']
['s', 'm', 'm', 'y']

மேல்கண்டதில் வழுநீக்கி வரி 5-இல் ஒரு நிறுத்தப்புள்ளியை இடுகிறது; இதனை அடைந்த பின் letter என்ற மாறியின் சேமிக்கப்பட்ட மதிப்பை அச்சிடுகிறது. அடுத்தபடியாக, pdb கருவியில், jump கட்டளையைக்கொண்டு வரி 6-இல் நேர்கோட்டுக்கு மாறாக இயக்கத்தை வரி 5-ஐ கடந்து செல்கிறோம். அதாவது மாறி letter-ஐ 'a' என்ற மதிப்பு கொண்டுள்ளது ஆனால் இது பட்டியலில் சேர்க்காமல் வரி 5-ஐ தாவி வரி 6-இல் இயக்கம் தொடர்ந்து செல்கிறது.

இதன்பின் வரி 5-இல் உள்ள நிறுத்தப்புள்ளியை செயல்தவிர்த்து பழையபடியே நிரல் உள்ளவடிவில் இயக்கம் முடிவடைகிறது.

அடுத்து நாம் நிரலில் இயக்கம் முடிந்த ஒருவரிக்கு மீண்டும் இயக்கத்தை திருப்பிச் செல்ல jump  கட்டளையைக் கொண்டு முயற்சிக்கலாம். இந்தமுறை for வாக்கியத்தின் முதல் சுற்றை மீண்டும் pdb-யில் இயக்கிப்பார்க்கலாம்.

> /Users/sammy/letter_list.py(1)<module>()
-> def print_sammy():
(Pdb) list
  1  -> def print_sammy():
  2         sammy_list = []
  3         sammy = "sammy"
  4         for letter in sammy:
  5             sammy_list.append(letter)
  6             print(sammy_list)
  7     
  8     if __name__ == "__main__":
  9         print_sammy()
 10     
 11     
(Pdb) break 6
Breakpoint 1 at /Users/sammy/letter_list.py:6
(Pdb) continue
> /Users/sammy/letter_list.py(6)print_sammy()
-> print(sammy_list)
(Pdb) pp letter
's'
(Pdb) jump 5
> /Users/sammy/letter_list.py(5)print_sammy()
-> sammy_list.append(letter)
(Pdb) continue
> /Users/sammy/letter_list.py(6)print_sammy()
-> print(sammy_list)
(Pdb) pp letter
's'
(Pdb) disable 1
Disabled breakpoint 1 at /Users/sammy/letter_list.py:6
(Pdb) continue
['s', 's']
['s', 's', 'a']
['s', 's', 'a', 'm']
['s', 's', 'a', 'm', 'm']
['s', 's', 'a', 'm', 'm', 'y']

இந்த மேல் காட்டப்பட்ட வழுநீக்கத்தில் வரி-6 இல் முதல் நிறுத்தப்புள்ளி இருக்கிறது; இது வரி 5-ஐ கடந்து செல்கிறது. ஆனாலும் வரி 5-ஐ மீண்டும் நாம் இயக்கச்செய்கின்றோம். இதனால் மாறி ‘letter’ இல் உள்ள மதிப்பான 's' இரண்டு முறை பட்டியலில் இணைக்கப்படுகிறது.

pdb-இல் அனைத்து வரிகளுக்கும் jump கட்டளையைக்கொண்டு நகர்த்திச்செல்ல முடியாது; குறிப்பாக, try:except வாக்கியங்கள், finally வாக்கியங்கள் போன்றவற்றின் இடையிலும், இயக்கத்தை தாவிச்செல்ல முடியாது.

அதாவது jump கட்டளையானது pdb என்பதினைக்கொண்டு ஒரு நிரலின் இயக்கத்தினை திசைமாற்றியும் அதனில் உள்ள வழுக்களை முன்னுக்குப்பின் அலசி ஆராய்ந்து புரிதல் செய்ய உதவும்.

பொதுவான pdb கட்டளைகள்

கீழ்கண்டதாவது பொதுவான pdb கட்டளைகள், அவற்றின் சுறுக்கமான வடிவங்கள், மற்றும் கட்டளை செயல்பாட்டினைப்பற்றிய விளக்கங்கள்.  மேலும் விரிவான pdb பற்றிய தகவல்களுக்கு pdb மூல ஆவணத்தை இங்கு படிக்கலாம்.

கட்டளை	சுறுக்கம்	விளக்கம்
args	a	நிரல்பாகம் சார்பின் உள்ளீடுகளை (function arguments) அச்சிடும்
break	b	இயங்கும் செயலியில் ஒரு நிறுத்தப்புள்ளியை உறுவாக்கும்
continue	c or cont	நிரல் இயக்கத்தை நிறுத்தப்புள்ளியில் இருந்து மீண்டும் தொடங்கச்செய்யும்
help	h	pdb இல் உள்ள அனைத்து கட்டளைகளையும் உதவிக்குறிப்புகளுடன் காட்டும்
jump	j	அடுத்த நிரல் வரி எடு என்பதை நாம் குறிப்பிட உதவும் கட்டளை
list	l	இயக்கப்புள்ளியைச்சுற்றி அமைந்துள்ள நிரல் வரிகளை காட்டும்
next	n	நிரல் இயக்கத்தை நிறுத்தப்புள்ளியில் இருந்து சார்பின் அடுத்த வரிக்கு அல்லது அதன் முடிவடையும் வரை நகர்த்திச்செல்லும்.
step	s	நிரல் இயக்கத்தை நிறுத்தப்புள்ளியில் இருந்து தொடங்கி அடுத்த நெருக்கமான இடத்தின் வரையில் நிறுத்தம் செய்யும்
pp	pp	நிரலின் ஏதேனும் மாறியின் மதிப்பினை அழகாக அச்சிடும்
quit or exit	q	நிரல் இயக்கத்தை திடீர் என நிறுத்திதம் செய்யும் அல்லது வெளியேரும்
return	r	நிரல் இயக்கத்தை நிறுத்தப்புள்ளியில் இருந்து வெளியேறும்

முடிவுரை

வழுநீக்கம் என்பது எந்த ஒரு கணினி நிரலாக்க திட்டத்திற்கும் முக்கியமானது. பைத்தான் மொழியில் pdb என்ற ஒரு வழு நீக்கி செயலி மூலம் பைத்தான் மொழியில் எழுதிய நிரல்களுக்கு ஒரு வழுநீக்கம் செய்யும் சூழலை அளிக்கிறது.

வழுநீக்கி அம்சங்கள் வழியாக இயங்கிக்கொண்டிருக்கும் நிரல்களை நிறுத்தி பரிசோதிக்கலாம், மாறிலிகளின் (variables) மதிப்புகளை பார்க்கலாம், மூல நிரலின் வரிகளில் படிப்படியாக செயலியின் இயக்கத்தை பார்க்கலாம், செயலியின் முழு செயல்பாட்டை புரிந்து கொள்ளலாம், இயக்கத்தில் தர்க்கரீதியான பிழைகள் இருப்பதை கண்டுபிடிக்கலாம் அல்லது முன்கூட்டியே அறிந்த வழுக்களை நீக்கம்செய்ய விசாரணைகள் நடத்தலாம்.

அடிக்குறிப்பு: வழு நீக்கம் சம்பந்தமான தொழில்நுட்பத்தினை தமிழில் எழுதும் முதல் கட்டுரைகளில் இந்த கட்டுரை இடம் பெர வேண்டும் என்பது எனது குறிக்கோள்.