पीडीबी - इंटरएक्टिव डिबगर

पीडीबी - इंटरएक्टिव डिबगर

पायथन संस्करण: 1.4 और इसके बाद के संस्करण



pdb पायथन कार्यक्रमों के लिए एक इंटरैक्टिव डिबगिंग वातावरण है। इसमें प्रोग्राम के निष्पादन को रोकने, परिवर्तनीय मूल्यों को देखने, लाइन-बाय-लाइन कोड निष्पादित करने की क्षमता शामिल है ताकि आप समझ सकें कि आपका प्रोग्राम वास्तव में क्या कर रहा है, और तार्किक त्रुटियां ढूंढें।

डिबगर लॉन्च

Pdb का उपयोग शुरू करने के लिए , आपको दुभाषिया को यह बताना होगा कि हम कब और कैसे डिबगर देखना चाहते हैं। इसे लॉन्च करने की शर्तों और साथ ही डिबगिंग आवश्यकताओं के आधार पर ऐसा करने के कई तरीके हैं।

कमांड लाइन से

डिबगर का उपयोग करने का सबसे स्पष्ट तरीका यह है कि इसे कमांड लाइन से चलाया जाए, अपने प्रोग्राम को एक पैरामीटर पास किया जाए ताकि यह पता चले कि क्या चलना है।

# encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .

1. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
2. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
3. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
4. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
6. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
8. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
9. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
   
   
   
   
11. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    
12. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    
13. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    
14. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    
16. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    
17. # encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .
    
    
    
    

# encoding: utf-8 # # Copyright (c) 2010 Doug Hellmann. All rights reserved. # class MyObj( object ): def __init__(self, num_loops): self.count = num_loops def go(self): for i in range(self.count): print i return if __name__ == '__main__' : MyObj(5).go() * This source code was highlighted with Source Code Highlighter .

जब आप कमांड लाइन से डीबगर शुरू करते हैं, तो यह आपके स्रोत को लोड करता है और पहले प्राप्त अभिव्यक्ति पर निष्पादन को रोकता है। हमारे मामले में, यह सातवीं पंक्ति पर MyObj वर्ग परिभाषा को निष्पादित करने से पहले बंद हो जाएगा।



$ python -m pdb pdb_script.py

> .../pdb_script.py(7)<module>()

-> class MyObj(object):

(Pdb)



ध्यान दें:

आमतौर पर पीडीबी में फ़ाइल पथ को आउटपुट करते समय प्रत्येक मॉड्यूल के लिए पूर्ण पथ शामिल होता है। डिबगर आउटपुट में उदाहरणों को संक्षिप्त रखने के लिए, इन रास्तों को बदल दिया गया है ...

दुभाषिया से

कई डेवलपर्स मॉड्यूल विकास के प्रारंभिक चरण में एक इंटरएक्टिव इंटरप्रेटर के साथ काम करते हैं, क्योंकि इससे उन्हें स्टैंड-अलोन स्क्रिप्ट बनाने के लिए आवश्यक सेव / रन / रिपीट चक्र को दोहराने के बिना अधिक पुनरावृत्त प्रयोग करने की अनुमति मिलती है। एक इंटरैक्टिव सत्र से डीबगर को चलाने के लिए, रन () या रनवैल () का उपयोग करें।



$ python

Python 2.7 (r27:82508, Jul 3 2010, 21:12:11)

[GCC 4.0.1 (Apple Inc. build 5493)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>> import pdb_script

>>> import pdb

>>> pdb.run('pdb_script.MyObj(5).go()')

> <string>(1)<module>()

(Pdb)







चलाने का तर्क () एक स्ट्रिंग अभिव्यक्ति है जिसे पायथन दुभाषिया द्वारा निष्पादित किया जा सकता है। डीबगर इसे पहली अभिव्यक्ति शुरू होने से ठीक पहले निष्पादित करना बंद कर देता है। आप नेविगेट करने और निष्पादन को नियंत्रित करने के लिए नीचे वर्णित आदेशों का उपयोग कर सकते हैं।

अपने कार्यक्रम से

पिछले उदाहरण दोनों इस तथ्य पर आधारित थे कि आप डिबगर को अपने कार्यक्रम की शुरुआत में शुरू करना चाहते हैं। अधिक जटिल प्रक्रियाओं के लिए, जिसमें समस्या बहुत बाद में होती है, रन टाइम के दौरान, सेट_ट्रेस () का उपयोग करके प्रोग्राम के भीतर डीबगर को चलाना अधिक सुविधाजनक होता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात pdb
9. वर्ग MyObj ( ऑब्जेक्ट ):
11. def __init __ (स्वयं, num_loops):
12. self.count = num_loops
14. डिफ गो (सेल्फ):
15. मैं सीमा में (self.count):
16. pdb.set_trace ()
17. प्रिंट करो
18. वापसी
20. अगर __name__ == '__main__' :
21. MyObj (5) .go ()

लाइन 16 पर, टेस्ट स्क्रिप्ट डिबगर कहलाती है।



$ python ./pdb_set_trace.py

> .../pdb_set_trace.py(17)go()

-> print i

(Pdb)







set_trace () केवल पायथन में एक फ़ंक्शन है, इसलिए आप इसे प्रोग्राम निष्पादन के दौरान किसी भी समय कॉल कर सकते हैं। यह आपको डिबग मोड में जाने की अनुमति देता है, यह कार्यक्रम के अंदर मौजूद स्थितियों पर निर्भर करता है, उदाहरण के लिए, जब अपवादों को संभालते हुए, या कुछ नियंत्रण अभिव्यक्ति की एक विशेष शाखा में।

असफलता के बाद

किसी प्रोग्राम को पूरा होने के बाद डिबग करना, पोस्टमार्टम डीबगिंग कहलाता है। pdb pm () और post_mortem () फ़ंक्शंस का उपयोग करके ऐसे डिबगिंग का समर्थन करता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. वर्ग MyObj ( ऑब्जेक्ट ):
9. def __init __ (स्वयं, num_loops):
10. self.count = num_loops
12. डिफ गो (सेल्फ):
13. मैं सीमा में (self.num_loops):
14. प्रिंट करो
15. वापसी

यहां, लाइन 13 पर, एक अमान्य फ़ील्ड नाम एक विशेषता गुण अपवाद को फेंक देगा, इससे निष्पादन बंद हो जाएगा। pm () इंटरैक्टिव ट्रेसबैक को देखता है और स्टैक फ्रेम में डीबगर शुरू करता है जिसमें अपवाद हुआ।



$ python

Python 2.7 (r27:82508, Jul 3 2010, 21:12:11)

[GCC 4.0.1 (Apple Inc. build 5493)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>> from pdb_post_mortem import MyObj

>>> MyObj(5).go()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

File "pdb_post_mortem.py", line 13, in go

for i in range(self.num_loops):

AttributeError: 'MyObj' object has no attribute 'num_loops'

>>> import pdb

>>> pdb.pm()

> .../pdb_post_mortem.py(13)go()

-> for i in range(self.num_loops):

(Pdb)

डिबगर प्रबंधन

डीबगर के साथ सहभागिता एक छोटी कमांड भाषा के लिए उबलती है जो आपको स्टैक को नेविगेट करने, चर के मूल्यों को देखने और बदलने की अनुमति देती है, और नियंत्रित करती है कि डीबगर आपके प्रोग्राम को कैसे निष्पादित करेगा। डीबगर कमांड पढ़ने के लिए रीडलाइन का उपयोग करता है। स्रोत को देखने के अलावा, एक खाली लाइन दर्ज करने से पिछली कमांड दोहराई जाती है।

स्टैक नेविगेशन को कॉल करें

डिबगर के काम के दौरान किसी भी समय, आप यह निर्दिष्ट करने के लिए कि वर्तमान में कहां चल रहे हैं और आप कॉल स्टैक में कहां हैं (या सिर्फ w ) का उपयोग कर सकते हैं। इस स्थिति में, pdb_set_trace.py मॉड्यूल लाइन 17 गो () विधि में।



$ python pdb_set_trace.py

> .../pdb_set_trace.py(17)go()

-> print i

(Pdb) where

.../pdb_set_trace.py(21)<module>()

-> MyObj(5).go()

> .../pdb_set_trace.py(17)go()

-> print i







वर्तमान स्थान का संदर्भ देखने के लिए, सूची ( एल ) का उपयोग करें।



(Pdb) list

12 self.count = num_loops

13

14 def go(self):

15 for i in range(self.count):

16 pdb.set_trace()

17 -> print i

18 return

19

20 if __name__ == '__main__':

21 MyObj(5).go()

[EOF]

(Pdb)







डिफ़ॉल्ट रूप से, 11 लाइनें वर्तमान एक (5 ऊपर और 5 नीचे) के आसपास प्रदर्शित होती हैं। जब सूची को एक तर्क के साथ कहा जाता है, तो यह वर्तमान के बजाय दिए गए एक से सटे हुए 11 लाइनों को प्रदर्शित करेगा।



(Pdb) list 14

9 class MyObj(object):

10

11 def __init__(self, num_loops):

12 self.count = num_loops

13

14 def go(self):

15 for i in range(self.count):

16 pdb.set_trace()

17 -> print i

18 return

19







यदि आप दो तर्कों को पास करते हैं, तो उन्हें पहली और अंतिम पंक्तियों के रूप में संसाधित किया जाएगा।



(Pdb) list 5, 19

5 #

6

7 import pdb

8

9 class MyObj(object):

10

11 def __init__(self, num_loops):

12 self.count = num_loops

13

14 def go(self):

15 for i in range(self.count):

16 pdb.set_trace()

17 -> print i

18 return

19







ऊपर और नीचे का उपयोग करके कॉल स्टैक को नेविगेट करें। स्टैक पर पहले कॉल करने के लिए ऊपर (छोटा यू ) चलता है। नीचे (या डी ) गहरी चुनौतियों को वहन करता है।



(Pdb) up

> .../pdb_set_trace.py(21)<module>()

-> MyObj(5).go()



(Pdb) down

> .../pdb_set_trace.py(17)go()

-> print i







जब भी आप स्टैक के साथ आगे बढ़ते हैं, डिबगर वर्तमान स्थान को उसी प्रारूप में प्रदर्शित करता है, जहां पर।

स्टैक पर चर देखें

वैरिएबल का एक सेट स्टैक के प्रत्येक फ्रेम से जुड़ा होता है, जिसमें निष्पादन योग्य फ़ंक्शन के लिए मान और वैश्विक स्थिति की जानकारी शामिल होती है। पीडीबी इन चर की सामग्री को देखने के कई तरीके प्रदान करता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात pdb
9. def पुनरावर्ती_फंक्शन (n = 5, आउटपुट = 'मुद्रित किया जाना है' ):
10. यदि n> 0:
11. recursive_function (n-1)
12. और :
13. pdb.set_trace ()
14. प्रिंट आउटपुट
15. वापसी
17. अगर __name__ == '__main__' :
18. recursive_function ()

आर्ग्स कमांड (उर्फ a ) फ़ंक्शन के सभी तर्कों को प्रदर्शित करता है जो वर्तमान फ्रेम में सक्रिय है। यह उदाहरण यह प्रदर्शित करने के लिए एक पुनरावर्ती फ़ंक्शन का भी उपयोग करता है कि आउटपुट में गहरे स्टैक कैसा दिखता है।



$ python pdb_function_arguments.py

> .../pdb_function_arguments.py(14)recursive_function()

-> return

(Pdb) where

.../pdb_function_arguments.py(17)<module>()

-> recursive_function()

.../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)

.../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)

.../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)

.../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)

.../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)

> .../pdb_function_arguments.py(14)recursive_function()

-> return



(Pdb) args

n = 0

output = to be printed



(Pdb) up

> .../pdb_function_arguments.py(11)recursive_function()

-> recursive_function(n-1)



(Pdb) args

n = 1

output = to be printed



(Pdb)







पी कमांड तर्क द्वारा पारित अभिव्यक्ति को निष्पादित करता है और परिणाम को प्रिंट करता है। आप प्रिंट स्टेटमेंट का भी उपयोग कर सकते हैं, लेकिन यह डिबगिंग कमांड के रूप में निष्पादन के बजाय, निष्पादन के लिए पायथन दुभाषिया के पास जाता है।



(Pdb) pn

1



(Pdb) print n

1







इसी तरह, अभिव्यक्ति की शुरुआत ! आप तुरंत इसे निष्पादन के लिए पायथन दुभाषिया को भेजें। इस सुविधा का उपयोग परिवर्तनशील चर सहित मनमाने पाइथन कमांड को निष्पादित करने के लिए किया जा सकता है। इस उदाहरण में, डिबगर को प्रोग्राम को जारी रखने के लिए अनुमति देने से पहले आउटपुट के मूल्य को बदल दिया जाता है। अगली कॉल, set_trace () के बाद, आउटपुट को आउटपुट करता है, परिवर्तित मूल्य प्रदर्शित करता है।



$ python pdb_function_arguments.py

> .../pdb_function_arguments.py(14)recursive_function()

-> print output



(Pdb) !output

'to be printed'



(Pdb) !output='changed value'



(Pdb) continue

changed value







अधिक जटिल मानों के लिए, जैसे नेस्टेड या बड़े डेटा संरचना, "सुंदर" आउटपुट के लिए पीपी (सुंदर प्रिंट) का उपयोग करें। यह प्रोग्राम एक फ़ाइल से पाठ की कई पंक्तियों को पढ़ता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात pdb
9. खुले ( 'lorem.txt' , 'rt' ) के रूप में f:
10. लाइनें = f.readlines ()
12. pdb.set_trace ()

पी के साथ लाइनों का आउटपुट पढ़ना मुश्किल है, क्योंकि उसे अस्वाभाविक रूप से सहन किया जाता है। पीपी आउटपुट से पहले मूल्यों को प्रारूपित करने के लिए pprint का उपयोग करता है।



$ python pdb_pp.py

--Return--

> .../pdb_pp.py(12)<module>()->None

-> pdb.set_trace()

(Pdb) p lines

['Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\n', 'egestas, enim

et consectetuer ullamcorper, lectus ligula rutrum leo, a\n', 'elementum elit tortor

eu quam.\n']



(Pdb) pp lines

['Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\n',

'egestas, enim et consectetuer ullamcorper, lectus ligula rutrum leo, a\n',

'elementum elit tortor eu quam.\n']



(Pdb)

कार्यक्रम कदम

कार्यक्रम को रोकने के दौरान स्टैक ऊपर और नीचे नेविगेट करने के अलावा, आप उन चरणों में भी निष्पादित करना जारी रख सकते हैं जहां से डिबगर कहा जाता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात pdb
9. डी एफ (एन):
10. i for रेंज (n):
11. j = i * n
12. प्रिंट आई, जे
13. वापसी
15. अगर __name__ == '__main__' :
16. pdb.set_trace ()
17. च (5)

वर्तमान लाइन को निष्पादित करने के लिए कदम का उपयोग करें और अगले निष्पादन योग्य बिंदु से पहले रोकें - या तो फ़ंक्शन में पहली अभिव्यक्ति, या वर्तमान फ़ंक्शन में अगली पंक्ति।



$ python pdb_step.py

> /Users/dhellmann/Documents/PyMOTW/src.pdb/PyMOTW/pdb/pdb_step.py(17)<module>()

-> f(5)







इंटरप्रिटर सेट_ट्रेस () कहकर बंद हो जाता है और डिबगर पर नियंत्रण स्थानांतरित करता है। पहला कॉल टू स्टेप कॉल f ()।



(Pdb) step

--Call--

> .../pdb_step.py(9)f()

-> def f(n):







एक बार फिर, चरण, और f () फ़ंक्शन में पहली पंक्ति वर्तमान लाइन बन जाती है और लूप चलना शुरू हो जाता है।



(Pdb) step

> .../pdb_step.py(10)f()

-> for i in range(n):







फिर से कदम रखने पर, हम लूप के अंदर पहली पंक्ति में पहुंच जाते हैं, जहां j निर्धारित होता है।



(Pdb) step

> /Users/dhellmann/Documents/PyMOTW/src.pdb/PyMOTW/pdb/pdb_step.py(11)f()

-> j = i * n

(Pdb) pi

0







I का मान 0 है, इसलिए इस चरण के बाद j का मान भी 0 होना चाहिए।



(Pdb) step

> /Users/dhellmann/Documents/PyMOTW/src.pdb/PyMOTW/pdb/pdb_step.py(12)f()

-> print i, j



(Pdb) pj

0



(Pdb)







यदि आपको बार-बार त्रुटि के लिए बहुत सारे कोड से गुजरना पड़ता है, या यदि फ़ंक्शन को बार-बार कहा जाता है, तो बार-बार चलना थकाऊ हो सकता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात pdb
9. डीईएफ़ कैल्क (i, n):
10. j = i * n
11. वापस ज
13. डी एफ (एन):
14. i for रेंज (n):
15. j = calc (i, n)
16. प्रिंट आई, जे
17. वापसी
19. अगर __name__ == '__main__' :
20. pdb.set_trace ()
21. च (5)

इस उदाहरण में, कैल्क () के साथ कोई समस्या नहीं है, इसलिए इसकी सभी लाइनों के माध्यम से पुनरावृत्ति, हर बार इसे f () में लूप में कहा जाता है, केवल उपयोगी आउटपुट को दबाता है, सभी कैल्क () लाइनों को प्रदर्शित करता है जैसा कि वे निष्पादित होते हैं।



$ python pdb_next.py

> .../pdb_next.py(21)<module>()

-> f(5)

(Pdb) step

--Call--

> .../pdb_next.py(13)f()

-> def f(n):



(Pdb) step

> .../pdb_next.py(14)f()

-> for i in range(n):



(Pdb) step

> .../pdb_next.py(15)f()

-> j = calc(i, n)



(Pdb) step

--Call--

> .../pdb_next.py(9)calc()

-> def calc(i, n):



(Pdb) step

> .../pdb_next.py(10)calc()

-> j = i * n



(Pdb) step

> .../pdb_next.py(11)calc()

-> return j



(Pdb) step

--Return--

> .../pdb_next.py(11)calc()->0

-> return j



(Pdb) step

> .../pdb_next.py(16)f()

-> print i, j



(Pdb) step

0 0







अगला कमांड चरण के समान है, लेकिन वर्तमान अभिव्यक्ति द्वारा बुलाए गए कार्यों का हिस्सा नहीं है। परिणामस्वरूप, इस कमांड को निष्पादित करने के बाद, डिबगर वर्तमान फ़ंक्शन की अगली अभिव्यक्ति के लिए आगे बढ़ता है।



> .../pdb_next.py(14)f()

-> for i in range(n):

(Pdb) step

> .../pdb_next.py(15)f()

-> j = calc(i, n)



(Pdb) next

> .../pdb_next.py(16)f()

-> print i, j



(Pdb)







यू एनटीआईएल कमांड अगले की तरह है, केवल यह तब तक निष्पादन जारी रखता है जब तक कि यह निम्न स्थित वर्तमान फ़ंक्शन की पंक्ति तक नहीं पहुंचता है (वर्तमान एक से अधिक संख्या के साथ)। इसका मतलब है कि, उदाहरण के लिए, जब तक कि छोरों से बाहर निकलने के लिए उपयोग नहीं किया जा सकता है।



$ python pdb_next.py

> .../pdb_next.py(21)<module>()

-> f(5)

(Pdb) step

--Call--

> .../pdb_next.py(13)f()

-> def f(n):



(Pdb) step

> .../pdb_next.py(14)f()

-> for i in range(n):



(Pdb) step

> .../pdb_next.py(15)f()

-> j = calc(i, n)



(Pdb) next

> .../pdb_next.py(16)f()

-> print i, j



(Pdb) until

0 0

1 5

2 10

3 15

4 20

> .../pdb_next.py(17)f()

-> return



(Pdb)







जब तक करने से पहले, वर्तमान रेखा 16 थी - लूप की अंतिम पंक्ति। जब तक चलने के बाद, निष्पादन 17 वीं पंक्ति तक पहुंच गया और चक्र पूरा हो गया।



वापसी एक फ़ंक्शन के कुछ हिस्सों को छोड़ने का एक और तरीका है। यह उस समय तक निष्पादन जारी रखता है जब वर्तमान फ़ंक्शन से वापसी का प्रदर्शन किया जाना है, और कार्यक्रम को रोक देता है। यह फ़ंक्शन से लौटने से पहले वापसी मूल्य को देखने का समय देता है।



$ python pdb_next.py

> .../pdb_next.py(21)<module>()

-> f(5)

(Pdb) step

--Call--

> .../pdb_next.py(13)f()

-> def f(n):



(Pdb) step

> .../pdb_next.py(14)f()

-> for i in range(n):



(Pdb) return

0 0

1 5

2 10

3 15

4 20

--Return--

> .../pdb_next.py(17)f()->None

-> return



(Pdb)

रोक बिंदु

जब कार्यक्रम और भी बड़े हो जाते हैं, तब भी जब तक कि अगले का उपयोग करना धीमा और उबाऊ नहीं हो जाता। लाइन द्वारा प्रोग्राम लाइन के माध्यम से कदम रखने के बजाय, एक बेहतर समाधान है - इसे सामान्य रूप से उस क्षण तक निष्पादित करने की अनुमति देने के लिए जब यह उस बिंदु तक पहुंचता है जिस पर आपको इसे बाधित करने की आवश्यकता होती है। आप डिबगर शुरू करने के लिए set_trace () का उपयोग कर सकते हैं, लेकिन यह केवल तभी काम करता है जब आप प्रोग्राम को एक स्थान पर रोकना चाहते हैं। एक अधिक सुविधाजनक समाधान डिबगर में पूरे कार्यक्रम को चलाने के लिए है, लेकिन इसे पहले से बताएं कि ब्रेकपॉइंट का उपयोग करना कहां रोकना है। डीबगर प्रोग्राम के निष्पादन की निगरानी करता है, और जब यह ब्रेकपॉइंट द्वारा वर्णित जगह पर पहुंचता है, तो यह संकेतित रेखा के सामने निष्पादन को रोक देता है।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. डीईएफ़ कैल्क (i, n):
8. j = i * n
9. प्रिंट 'जे =' , जे
10. अगर j> 0:
11. प्रिंट 'सकारात्मक!'
12. वापस ज
14. डी एफ (एन):
15. i for रेंज (n):
16. प्रिंट 'i =' , i
17. j = calc (i, n)
18. वापसी
20. अगर __name__ == '__main__' :
21. च (5)

ब्रेक कमांड ब्रेकपॉइंट सेट करने के लिए कई विकल्पों को स्वीकार करता है। आप पंक्ति संख्या, फ़ाइल या फ़ंक्शन निर्दिष्ट कर सकते हैं जहां निष्पादन बंद होना चाहिए। वर्तमान फ़ाइल में एक विशिष्ट लाइन पर एक ब्रेकपॉइंट सेट करने के लिए, ब्रेक लिनोनो का उपयोग करें:



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 11

Breakpoint 1 at .../pdb_break.py:11



(Pdb) continue

i = 0

j = 0

i = 1

j = 5

> .../pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb)





जारी आदेश डिबगर को अगले ब्रेकपॉइंट तक कार्यक्रम जारी रखने के लिए कहता है। इस मामले में, च में लूप का पहला पुनरावृत्ति () पास होगा, और दूसरी पुनरावृत्ति पर कैल्क () में बंद हो जाएगा।



ब्रेकप्वाइंट को किसी फ़ंक्शन की पहली पंक्ति पर लाइन नंबर के बजाय उसका नाम निर्दिष्ट करके भी सेट किया जा सकता है। निम्न उदाहरण दिखाएगा कि यदि आप कैल्क () फ़ंक्शन में एक ब्रेकप्वाइंट जोड़ते हैं तो क्या होता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break calc

Breakpoint 1 at .../pdb_break.py:7



(Pdb) continue

i = 0

> .../pdb_break.py(8)calc()

-> j = i * n



(Pdb) where

.../pdb_break.py(21)<module>()

-> f(5)

.../pdb_break.py(17)f()

-> j = calc(i, n)

> .../pdb_break.py(8)calc()

-> j = i * n



(Pdb)







किसी अन्य फ़ाइल में एक ब्रेकपॉइंट निर्दिष्ट करने के लिए, फ़ाइल नाम के साथ लाइन नंबर या फ़ंक्शन नाम से पहले।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. pdb_break से आयात f
9. च (5)

यहां हम मुख्य प्रोग्राम pdb_break_remote.py शुरू करने के बाद pdb_break.py की 11 वीं पंक्ति पर ब्रेकपॉइंट सेट करते हैं।



$ python -m pdb pdb_break_remote.py

> .../pdb_break_remote.py(7)<module>()

-> from pdb_break import f

(Pdb) break pdb_break.py:11

Breakpoint 1 at .../pdb_break.py:11



(Pdb) continue

i = 0

j = 0

i = 1

j = 5

> .../pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb)







फ़ाइल का नाम स्रोत का पूर्ण पथ या sys.path में उपलब्ध फ़ाइल के सापेक्ष पथ हो सकता है।



वर्तमान में सेट किए गए ब्रेकप्वाइंट को देखने के लिए, बिना किसी तर्क के ब्रेक का उपयोग करें। आउटपुट में फ़ाइल और प्रत्येक ब्रेकपॉइंट की लाइन संख्या, साथ ही साथ यह कितनी बार हिट हुई, इसकी जानकारी शामिल है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 11

Breakpoint 1 at .../pdb_break.py:11



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:11



(Pdb) continue

i = 0

j = 0

i = 1

j = 5

> .../pdb/pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb) continue

Positive!

i = 2

j = 10

> .../pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:11

breakpoint already hit 2 times



(Pdb)

ब्रेकपॉइंट प्रबंधन

प्रत्येक जोड़ा ब्रेकप्वाइंट को एक संख्यात्मक पहचानकर्ता सौंपा गया है। इन पहचानकर्ताओं का उपयोग अंतःक्रियात्मक रूप से सक्षम करने, अक्षम करने और ब्रेकपॉइंट निकालने के लिए किया जाता है।



अक्षमता के साथ एक ब्रेकपॉइंट को बंद करना डिबगर को बताता है कि इस लाइन तक पहुंचने पर रोकने की कोई आवश्यकता नहीं है। ब्रेकपाइंट को याद किया जाता है लेकिन अनदेखा किया जाता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break calc

Breakpoint 1 at .../pdb_break.py:7



(Pdb) break 11

Breakpoint 2 at .../pdb_break.py:11



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:7

2 breakpoint keep yes at .../pdb_break.py:11



(Pdb) disable 1



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep no at .../pdb_break.py:7

2 breakpoint keep yes at .../pdb_break.py:11



(Pdb) continue

i = 0

j = 0

i = 1

j = 5

> .../pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb)







निम्न उदाहरण से डीबगिंग सत्र प्रोग्राम में दो ब्रेकपॉइंट सेट करता है, फिर उनमें से एक को अक्षम करता है। कार्यक्रम तब तक चलता है जब तक कि शेष ब्रेकपॉइंट नहीं पहुंच जाता है, फिर एक और ब्रेकपॉइंट चालू होता है और निष्पादन जारी रहता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break calc

Breakpoint 1 at .../pdb_break.py:7



(Pdb) break 16

Breakpoint 2 at .../pdb_break.py:16



(Pdb) disable 1



(Pdb) continue

> .../pdb_break.py(16)f()

-> print 'i =', i



(Pdb) list

11 print 'Positive!'

12 return j

13

14 def f(n):

15 for i in range(n):

16 B-> print 'i =', i

17 j = calc(i, n)

18 return

19

20 if __name__ == '__main__':

21 f(5)



(Pdb) continue

i = 0

j = 0

> .../pdb_break.py(16)f()

-> print 'i =', i



(Pdb) list

11 print 'Positive!'

12 return j

13

14 def f(n):

15 for i in range(n):

16 B-> print 'i =', i

17 j = calc(i, n)

18 return

19

20 if __name__ == '__main__':

21 f(5)



(Pdb) pi

1



(Pdb) enable 1



(Pdb) continue

i = 1

> .../pdb_break.py(8)calc()

-> j = i * n



(Pdb) list

3 #

4 # Copyright (c) 2010 Doug Hellmann. All rights reserved.

5 #

6

7 B def calc(i, n):

8 -> j = i * n

9 print 'j =', j

10 if j > 0:

11 print 'Positive!'

12 return j

13



(Pdb)







सूची आउटपुट में B को इंगित करने से पहले की लाइनें प्रोग्राम के उन स्थानों को दिखाती हैं जहां ब्रेकपॉइंट्स स्थापित किए गए हैं (लाइनें 9 और 18)।



ब्रेकपॉइंट को पूरी तरह से हटाने के लिए स्पष्ट का उपयोग करें।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break calc

Breakpoint 1 at .../pdb_break.py:7



(Pdb) break 11

Breakpoint 2 at .../pdb_break.py:11



(Pdb) break 16

Breakpoint 3 at .../pdb_break.py:16



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:7

2 breakpoint keep yes at .../pdb_break.py:11

3 breakpoint keep yes at .../pdb_break.py:16



(Pdb) clear 2

Deleted breakpoint 2



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:7

3 breakpoint keep yes at .../pdb_break.py:16



(Pdb)







शेष ब्रेकप्वाइंट उनके पहचानकर्ता को बनाए रखेंगे और फिर से बनाए नहीं जाएंगे।

अस्थायी ब्रेकप्वाइंट

पहली हिट के बाद अस्थायी ब्रेकप्वाइंट स्वचालित रूप से साफ़ हो जाते हैं। एक अस्थायी ब्रेकपॉइंट का उपयोग करके, आप पारंपरिक ब्रेकपॉइंट के साथ, हालांकि, प्रोग्राम निष्पादन के एक निश्चित बिंदु तक पहुंच सकते हैं, हालांकि, क्योंकि यह तुरंत साफ हो जाता है, यह आगे के काम में हस्तक्षेप नहीं करता है यदि कार्यक्रम के इस टुकड़े को बार-बार निष्पादित किया जाता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) tbreak 11

Breakpoint 1 at .../pdb_break.py:11



(Pdb) continue

i = 0

j = 0

i = 1

j = 5

Deleted breakpoint 1

> .../pdb_break.py(11)calc()

-> print 'Positive!'



(Pdb) break



(Pdb) continue

Positive!

i = 2

j = 10

Positive!

i = 3

j = 15

Positive!

i = 4

j = 20

Positive!

The program finished and will be restarted

> .../pdb_break.py(7)<module>()

-> def calc(i, n):



(Pdb)







निष्पादन पहली बार 11 वीं पंक्ति तक पहुंचने के बाद, ब्रेकपॉइंट हटा दिया जाता है और कार्यक्रम अंत तक नॉन-स्टॉप चलता है।

शर्त के साथ ब्रेकप्वाइंट

नियम ब्रेकपॉइंट्स पर भी लागू किए जा सकते हैं ताकि प्रोग्राम निष्पादन केवल तभी बंद हो जाए जब स्थितियां पूरी हो जाएं। सशर्त ब्रेकप्वाइंट का उपयोग मैन्युअल रूप से ब्रेकपॉइंट को चालू और बंद करने की तुलना में अधिक सूक्ष्म नियंत्रण स्टॉप के लिए संभव बनाता है।



सशर्त विराम बिंदु दो तरीकों में से एक में सेट किए जा सकते हैं। पहला ब्रेक का उपयोग करके ब्रेकपॉइंट बनाने के समय स्थिति को निर्दिष्ट करना है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 9, j>0

Breakpoint 1 at .../pdb_break.py:9



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:9

stop only if j>0



(Pdb) continue

i = 0

j = 0

i = 1

> .../pdb_break.py(9)calc()

-> print 'j =', j



(Pdb)







स्थिति तर्क में स्टैक के फ्रेम में दिखाई देने वाले चर नामों का उपयोग करके एक अभिव्यक्ति होना चाहिए जिसमें ब्रेकपाइंट को परिभाषित किया गया है। यदि अभिव्यक्ति सही मान पर कम हो जाती है, तो प्रोग्राम ब्रेकपॉइंट पर रुक जाता है।



किसी शर्त को मौजूदा ब्रेकपॉइंट पर लागू किया जा सकता है। तर्क - ब्रेकपॉइंट आईडी और अभिव्यक्ति।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 9

Breakpoint 1 at .../pdb_break.py:9



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:9



(Pdb) condition 1 j>0



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:9

stop only if j>0



(Pdb)

ब्रेकप्वाइंट्स को नजरअंदाज करना

बड़ी संख्या में चक्र या पुनरावर्ती कॉल वाले कार्यक्रम अक्सर प्रत्येक कॉल और ब्रेकपॉइंट को देखने के बजाय, प्रोग्राम निष्पादन के कुछ चरणों को "स्क्रॉल" द्वारा डीबग करना अधिक आसान होता है। अनदेखा कमांड डिबगर को कुछ ब्रेकपॉइंट छोड़ने के लिए कहता है। हर बार जब आप ब्रेकपॉइंट से गुजरते हैं, तो यह अनदेखा काउंटर कम हो जाता है। जब यह 0 तक पहुंचता है, तो ब्रेकपॉइंट फिर से सक्रिय हो जाता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 17

Breakpoint 1 at .../pdb_break.py:17



(Pdb) continue

i = 0

> .../pdb_break.py(17)f()

-> j = calc(i, n)



(Pdb) next

j = 0

> .../pdb_break.py(15)f()

-> for i in range(n):



(Pdb) ignore 1 2

Will ignore next 2 crossings of breakpoint 1.



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:17

ignore next 2 hits

breakpoint already hit 1 time



(Pdb) continue

i = 1

j = 5

Positive!

i = 2

j = 10

Positive!

i = 3

> .../pdb_break.py(17)f()

-> j = calc(i, n)



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:17

breakpoint already hit 4 times







स्पष्ट रूप से काउंटर को शून्य पर सेट करने से तुरंत ब्रेकपॉइंट सक्रिय हो जाता है।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 17

Breakpoint 1 at .../pdb_break.py:17



(Pdb) ignore 1 2

Will ignore next 2 crossings of breakpoint 1.



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:17

ignore next 2 hits



(Pdb) ignore 1 0

Will stop next time breakpoint 1 is reached.



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_break.py:17

ब्रेकपॉइंट कार्रवाई शुरू करना

इंटरैक्टिव मोड के अलावा, पीडीबी सरल स्क्रिप्टिंग का समर्थन करता है। आदेशों का उपयोग करके, आप पायथन अभिव्यक्ति सहित दुभाषिया के कार्यों के अनुक्रम को निर्धारित कर सकते हैं, जो कि जब वे एक ब्रेकपॉइंट मारते हैं तो निष्पादित किया जाएगा। लाइन तर्क संख्या के साथ कमांड निष्पादित करने के बाद, डिबगर प्रॉम्प्ट (कॉम) में बदल जाएगा। एक समय में एक कमांड दर्ज करें, और अंत में स्क्रिप्ट को बचाने के लिए अंत में प्रवेश करें और डीबगर मुख्य मोड पर लौटें।



$ python -m pdb pdb_break.py

> .../pdb_break.py(7)<module>()

-> def calc(i, n):

(Pdb) break 9

Breakpoint 1 at .../pdb_break.py:9



(Pdb) commands 1

(com) print 'debug i =', i

(com) print 'debug j =', j

(com) print 'debug n =', n

(com) end



(Pdb) continue

i = 0

debug i = 0

debug j = 0

debug n = 5

> .../pdb_break.py(9)calc()

-> print 'j =', j



(Pdb) continue

j = 0

i = 1

debug i = 1

debug j = 5

debug n = 5

> .../pdb_break.py(9)calc()

-> print 'j =', j



(Pdb)







यह फ़ंक्शन डिबगिंग कोड के लिए विशेष रूप से उपयोगी है जो कई डेटा संरचनाओं, चर का उपयोग करता है, क्योंकि आपको प्रत्येक ब्रेकपॉइंट पर मैन्युअल रूप से करने के बजाय सभी मानों को स्वचालित रूप से प्रदर्शित करने की अनुमति देता है।

प्रगति नियंत्रण

जंप कमांड आपको स्रोत कोड को बदलने के बिना मक्खी पर प्रोग्राम निष्पादन को नियंत्रित करने की अनुमति देता है। आप कुछ कोड, या पिछड़े को फिर से निष्पादित करने के लिए, प्रोग्राम के हिस्से को आगे बढ़ा सकते हैं। संख्याओं की सूची तैयार करने का एक सरल कार्यक्रम।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. डी एफ (एन):
8. परिणाम = []
9. ज = ०
10. i for रेंज (n):
11. j = i * n + j
12. जे + = एन
13. result.append (j)
14. वापसी परिणाम
16. अगर __name__ == '__main__' :
17. प्रिंट एफ (5)

जब हस्तक्षेप के बिना चलाया जाता है, तो आउटपुट 5 से विभाज्य संख्याओं का बढ़ता क्रम है।



$ python pdb_jump.py



[5, 15, 30, 50, 75]

आगे बढ़ो

आगे जाना एक बिंदु पर निष्पादन को स्थानांतरित करता है, वर्तमान रेखा से आगे, इसके पहले स्थित आदेशों को निष्पादित किए बिना। नीचे दिए गए उदाहरण में 13 वीं पंक्ति को छोड़ते हुए, j का मान नहीं बढ़ाया जाता है और बाद के सभी मान जो इस पर निर्भर करते हैं वे थोड़े छोटे हो जाते हैं।



$ python -m pdb pdb_jump.py

> .../pdb_jump.py(7)<module>()

-> def f(n):

(Pdb) break 12

Breakpoint 1 at .../pdb_jump.py:12



(Pdb) continue

> .../pdb_jump.py(12)f()

-> j += n



(Pdb) pj

0



(Pdb) step

> .../pdb_jump.py(13)f()

-> result.append(j)



(Pdb) pj

5



(Pdb) continue

> .../pdb_jump.py(12)f()

-> j += n



(Pdb) jump 13

> .../pdb_jump.py(13)f()

-> result.append(j)



(Pdb) pj

10



(Pdb) disable 1



(Pdb) continue

[5, 10, 25, 45, 70]



The program finished and will be restarted

> .../pdb_jump.py(7)<module>()

-> def f(n):

(Pdb)

वापस जाओ

संक्रमण प्रोग्राम निष्पादन को उन अभिव्यक्तियों में भी स्थानांतरित कर सकते हैं जिन्हें पहले से ही निष्पादित किया गया है, पुनः आरंभ करने के लिए। यहाँ j का मान एक बार फिर से बढ़ा दिया गया है, ताकि परिणामस्वरूप संख्या अधिक से अधिक निकले अन्यथा नहीं।



$ python -m pdb pdb_jump.py

> .../pdb_jump.py(7)<module>()

-> def f(n):

(Pdb) break 13

Breakpoint 1 at .../pdb_jump.py:13



(Pdb) continue

> .../pdb_jump.py(13)f()

-> result.append(j)



(Pdb) pj

5



(Pdb) jump 12

> .../pdb_jump.py(12)f()

-> j += n



(Pdb) continue

> .../pdb_jump.py(13)f()

-> result.append(j)



(Pdb) pj

10



(Pdb) disable 1



(Pdb) continue

[10, 20, 35, 55, 80]



The program finished and will be restarted

> .../pdb_jump.py(7)<module>()

-> def f(n):

(Pdb)

निषिद्ध क्रॉसिंग

संक्रमण "से" और "से" कुछ भाव जो गणना के प्रवाह को नियंत्रित करते हैं खतरनाक या अस्पष्ट हैं, और इसलिए, डिबगर द्वारा निषिद्ध हैं।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. डी एफ (एन):
8. यदि n <0:
9. ValueError बढ़ाएँ ( 'अमान्य n:% s' % n)
10. परिणाम = []
11. ज = ०
12. i for रेंज (n):
13. j = i * n + j
14. जे + = एन
15. result.append (j)
16. वापसी परिणाम
19. अगर __name__ == '__main__' :
20. कोशिश करें :
21. प्रिंट एफ (5)
22. अंत में :
23. 'हमेशा मुद्रित'
25. कोशिश करें :
26. प्रिंट एफ (-5)
27. सिवाय:
28. प्रिंट 'एक त्रुटि थी'
29. और :
30. प्रिंट 'कोई त्रुटि नहीं थी'
32. 'अंतिम विवरण' प्रिंट करें

आप फ़ंक्शन के अंदर जा सकते हैं, लेकिन यदि आप करते हैं, तो तर्कों को परिभाषित नहीं किया जाएगा और कोड काम करने की संभावना नहीं है।



$ python -m pdb pdb_no_jump.py

> .../pdb_no_jump.py(7)<module>()

-> def f(n):

(Pdb) break 21

Breakpoint 1 at .../pdb_no_jump.py:21



(Pdb) jump 8

> .../pdb_no_jump.py(8)<module>()

-> if n < 0:



(Pdb) pn

*** NameError: NameError("name 'n' is not defined",)



(Pdb) args



(Pdb)







आप ब्लॉक के अंदर नहीं जा सकते जैसे कि लूप्स या एक कोशिश: स्टेटमेंट को छोड़कर।



$ python -m pdb pdb_no_jump.py

> .../pdb_no_jump.py(7)<module>()

-> def f(n):

(Pdb) break 21

Breakpoint 1 at .../pdb_no_jump.py:21



(Pdb) continue

> .../pdb_no_jump.py(21)<module>()

-> print f(5)



(Pdb) jump 26

*** Jump failed: can't jump into the middle of a block



(Pdb)







अंत में ब्लॉक के कोड को निष्पादित किया जाना चाहिए, ताकि आप इससे बाहर नहीं निकल सकें।

$ python -m pdb pdb_no_jump.py

> .../pdb_no_jump.py(7)<module>()

-> def f(n):

(Pdb) break 23

Breakpoint 1 at .../pdb_no_jump.py:23



(Pdb) continue

[5, 15, 30, 50, 75]

> .../pdb_no_jump.py(23)<module>()

-> print 'Always printed'



(Pdb) jump 25

*** Jump failed: can't jump into or out of a 'finally' block



(Pdb)







और मुख्य सीमा यह है कि संक्रमण स्टैक के निचले फ्रेम द्वारा सीमित हैं। यदि आप चर देखने के लिए ढेर पर जाते हैं, तो आप इस स्तर पर प्रगति को नहीं बदल सकते।



$ python -m pdb pdb_no_jump.py

> .../pdb_no_jump.py(7)<module>()

-> def f(n):

(Pdb) break 11

Breakpoint 1 at .../pdb_no_jump.py:11



(Pdb) continue

> .../pdb_no_jump.py(11)f()

-> j = 0



(Pdb) where

/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/bdb.py(379)run()

-> exec cmd in globals, locals

<string>(1)<module>()

.../pdb_no_jump.py(21)<module>()

-> print f(5)

> .../pdb_no_jump.py(11)f()

-> j = 0



(Pdb) up

> .../pdb_no_jump.py(21)<module>()

-> print f(5)



(Pdb) jump 25

*** You can only jump within the bottom frame



(Pdb)

कार्यक्रम पुनः आरंभ

जब डिबगर प्रोग्राम के अंत तक पहुंचता है, तो यह स्वचालित रूप से इसे फिर से शुरू करता है। आप डिबग मोड को छोड़ने के बिना, और ब्रेकपॉइंट या अन्य सेटिंग्स को खोए बिना, इसे स्वयं भी पुनरारंभ कर सकते हैं।

1. #! / usr / bin / env अजगर
2. # एन्कोडिंग: utf-8
3. #
4. # कॉपीराइट (c) 2010 डग हेलमैन। सभी अधिकार सुरक्षित।
5. #
7. आयात sys
9. डी एफ ():
10. प्रिंट 'कमांड लाइन आर्ग्स:' , sys.argv
11. वापसी
13. अगर __name__ == '__main__' :
14. च ()

डिबगर में उपरोक्त प्रोग्राम चलाने से स्क्रिप्ट का नाम आउटपुट हो जाएगा, क्योंकि कमांड लाइन पर कोई अन्य तर्क नहीं दिया गया था।



$ python -m pdb pdb_run.py

> .../pdb_run.py(7)<module>()

-> import sys

(Pdb) continue



Command line args: ['pdb_run.py']

The program finished and will be restarted

> .../pdb_run.py(7)<module>()

-> import sys



(Pdb)







आप रन का उपयोग करके प्रोग्राम को पुनरारंभ कर सकते हैं । रन तर्कों को श्लेक्स का उपयोग करके पार्स किया जाता है और प्रोग्राम को पास किया जाता है जैसे कि वे कमांड लाइन से थे, इसलिए आप विभिन्न मापदंडों के साथ अपने प्रोग्राम को पुनरारंभ कर सकते हैं।



(Pdb) run abc "this is a long value"

Restarting pdb_run.py with arguments:

abc this is a long value

> .../pdb_run.py(7)<module>()

-> import sys



(Pdb) continue

Command line args: ['pdb_run.py', 'a', 'b', 'c', 'this is a long value']

The program finished and will be restarted

> .../pdb_run.py(7)<module>()

-> import sys



(Pdb)







किसी प्रोग्राम को पुनरारंभ करने के लिए रन का उपयोग कहीं और भी किया जा सकता है।



$ python -m pdb pdb_run.py

> .../pdb_run.py(7)<module>()

-> import sys

(Pdb) break 10

Breakpoint 1 at .../pdb_run.py:10



(Pdb) continue

> .../pdb_run.py(10)f()

-> print 'Command line args:', sys.argv



(Pdb) run one two three

Restarting pdb_run.py with arguments:

one two three

> .../pdb_run.py(7)<module>()

-> import sys



(Pdb)

उपनाम का उपयोग करके डिबगर सेट करना

जटिल आदेशों को फिर से टाइप करने से बचने का एक तरीका है - एक उपनाम परिभाषित करें। प्रत्येक टीम के पहले शब्द पर उपनाम का प्रकटीकरण लागू होता है। उपनाम बॉडी में कोई भी कमांड हो सकती है जिसे डीबगर इंटरप्रेटर अनुमति देता है, जिसमें डीबगर कमांड और पायथन एक्सप्रेशन शामिल हैं। अलियास परिभाषाओं में पुनरावृत्ति की अनुमति है, इसलिए कुछ उपनाम दूसरों का कारण बन सकते हैं।



$ python -m pdb pdb_function_arguments.py

> .../pdb_function_arguments.py(7)<module>()

-> import pdb

(Pdb) break 10

Breakpoint 1 at .../pdb_function_arguments.py:10



(Pdb) continue

> .../pdb_function_arguments.py(10)recursive_function()

-> if n > 0:



(Pdb) pp locals().keys()

['output', 'n']



(Pdb) alias pl pp locals().keys()



(Pdb) pl

['output', 'n']







बिना किसी बहस के साथ चल रहा उपनाम परिभाषित उपनामों की एक सूची प्रदर्शित करता है। एक तर्क के साथ - उपनाम का नाम, इसकी परिभाषा प्रदर्शित की गई है।



(Pdb) alias

pl = pp locals().keys()



(Pdb) alias pl

pl = pp locals().keys()

(Pdb)







% N का उपयोग करके एलियास तर्कों को एक्सेस किया जा सकता है, जहां n तर्क की संख्या है। 1 से शुरू होकर सभी तर्कों का उपयोग करने के लिए, % * का उपयोग करें।



$ python -m pdb pdb_function_arguments.py

> .../pdb_function_arguments.py(7)<module>()

-> import pdb

(Pdb) alias ph !help(%1)



(Pdb) ph locals

Help on built-in function locals in module __builtin__:



locals(...)

locals() -> dictionary



Update and return a dictionary containing the current scope's local variables.







उलीसा के साथ उपनाम की परिभाषा निकालें।



(Pdb) unalias ph



(Pdb) ph locals

*** SyntaxError: invalid syntax (<stdin>, line 1)



(Pdb)

कॉन्फ़िगरेशन सेटिंग्स सहेजना

किसी प्रोग्राम को डीबग करना कई पुनरावृत्तियों की आवश्यकता है; कोड चलाना, आउटपुट का विश्लेषण करना, कोड और इनपुट को ठीक करना और फिर से शुरू करना पीडीबी डिबगिंग प्रक्रिया के लिए आवश्यक पुनरावृत्तियों की संख्या में कटौती करने की कोशिश करता है, ताकि आप डिबगर के बजाय अपने कोड पर ध्यान केंद्रित कर सकें। डीबगर को दिए गए आदेशों की संख्या को कम करने में मदद करने के लिए, पीडीबी आपको कॉन्फ़िगरेशन को बचाने की अनुमति देता है ताकि आप इसे स्टार्टअप पर दोबारा पढ़ सकें।



~ / .Pdbrc फ़ाइल पहले पढ़ी जाती है, जिससे आप सभी डिबगिंग सत्रों के लिए व्यक्तिगत प्राथमिकताएँ निर्दिष्ट कर सकते हैं। उसके बाद, वर्तमान निर्देशिका से ./pdbrc पढ़ें ताकि आप किसी विशिष्ट प्रोजेक्ट के लिए सेटिंग्स निर्दिष्ट कर सकें।



$ cat ~/.pdbrc

# Show python help

alias ph !help(%1)

# Overridden alias

alias redefined p 'home definition'



$ cat .pdbrc

# Breakpoints

break 10

# Overridden alias

alias redefined p 'local definition'



$ python -m pdb pdb_function_arguments.py

Breakpoint 1 at .../pdb_function_arguments.py:10

> .../pdb_function_arguments.py(7)<module>()

-> import pdb

(Pdb) alias

ph = !help(%1)

redefined = p 'local definition'



(Pdb) break

Num Type Disp Enb Where

1 breakpoint keep yes at .../pdb_function_arguments.py:10



(Pdb)







डिबगर शेल में दर्ज किए जाने वाले किसी भी कॉन्फ़िगरेशन कमांड को इन फ़ाइलों में से एक में बचाया जा सकता है, लेकिन कमांड जो निष्पादन को नियंत्रित करते हैं (जारी, कूद, आदि) नहीं कर सकते। अपवाद चलाया जाता है, अर्थात, आप ./.pdbrc में डिबगिंग सत्र के लिए कमांड लाइन तर्क सेट कर सकते हैं ताकि बाद के लॉन्च के दौरान वे अपरिवर्तित रहें।