使用Pdb调试Python

原文链接：https://segmentfault.com/a/1190000006628456

本文章为转载，纯属学习之用。

简单介绍

Python自带 Pdb库，使用 Pdb调试 Python程序还是很方便的。但是远程调试、多线程，Pdb是搞不定的

本文参考的相关文章如下：

• 《指针和字符串和字符串常量、用gdb来获取非法内存中的内容》

• 《Linux gdb调试器用法全面解析》

• 《用PDB库调试Python程序》

用Pdb调试有多种方式

使用 Pdb调试 Python的程序的方式主要是下面的三种！下面逐一介绍

命令行加-m参数

命令行启动目标程序，加上-m参数，这样调用 testPdb.py的话断点就是程序执行的第一行之前

本文接下来重点讲到的实例展示就是使用这种方式进行调试的！

python -m pdb testPdb.py
 
 

在python交互环境调试

 
 

   
   

    
    

   
   
   
   

    
    

     
     >>> import pdb
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     >>> import testPdb
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     >>> pdb.run('testPdb.test()')
    
    
   
   
 
 

代码中插入一段程序

比较常用的，就是在程序中间插入一段程序，相对于在一般 IDE 里面打上断点然后启动 debug，不过这种方式是 hardcode的

 
 

   
   

    
    

   
   
   
   

    
    

     
     if __name__ == 
     
     "__main__":
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     a = 
     
     1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     import pdb
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       pdb.set_trace()
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     b = 
     
     2
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     c = 
     
     a + 
     
     b
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     print(
     
     c)
    
    
   
   
 
 

然后正常运行脚本：python testPdb.py 到了 pdb.set_trace()那里就会定下来，然后就可以看到调试的提示符 (Pdb)了

针对上面的这段小程序的调试情况如下：

准备测试程序

接下来使用上面介绍的第一种方式来调试 Python程序，以此来介绍 pdb常用的命令，不过在开始之前先要准备好测试的程序代码：

testFun.py

这是一个会被主模块调用的子模块，用于测试使用 Pdb调试的时候，是不是可以断点从主模块跟踪进入子模块（后续有说明）

 
 

   
   

    
    

   
   
   
   

    
    

     
     #!/usr/bin/python
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # -*- coding: utf-
     
     8
     
      -*-
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     def add(a, b):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     return a + b
    
    
   
   
 
 

testPdb.py

这是下面被调试的主模块的代码

 
 

   
   

    
    

   
   
   
   

    
    

     
     #!/usr/bin/python
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # -*- coding: utf-8 -*-
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     def sub(a, b):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         return a - b
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     if __name__ == "__main__":
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ''
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         import testFun
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         i = 0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         a = 1
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         while(i < 100):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             a = testFun.add(a, 1)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             i = i + 1
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print "累加结果：", a
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ""
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         for letter in 'Pdb':
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             print "当前字母：", letter
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ""
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         fruits = ['banana', 'apple', 'mango']
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         for fruit in fruits:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             print "当前水果：", fruit
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ""
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         ret = 0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         for num in range(10, 12):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             ret = sub(ret, num)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print '循环结果：', ret
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ""
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
      
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         d = {'abc': 123, 123: "abc"}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         for (k,v) in d.items():
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             print "当前键值对：", k, '-', v
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         print ""
    
    
   
   
 
 

总结常用的命令

基础命令

h(elp)命令：会打印当前版本 Pdb可用的命令，如果要查询某个命令，可输入 h [command] ，例如 h l 查看 list命令

l(ist)命令：可以列出当前将要运行的代码块

断点管理

b(reak)：设置断点

比如 b 12 就是在当前脚本的第 9行加上断点

比如 b sub 就是在当前脚本的 sub函数定义处加断点

除了可以在当前的脚本中添加断点之外，还可以在当前脚本对其他脚本下断点，以上面用到的代码为例 b testFun.add 就可以实现在 testFun.py脚本中的 add函数处加断点

如果只用 b 就会显示现有的全部断点

condition bpnumber [condition]：设置条件断点，比如 condition 2 a==0 ，就是在第二个断点出加条件 “a==0”

cl(ear)：删除断点，如果后面带有参数，就是清楚指定的断点；如果不带参数就是清除所有的断点

disable/enable：禁用/激活断点

程序逻辑控制

下面展示的几个命令，需要知道对应的脚本的代码和行号，所以这里先截图展示下面测试需要用到的前几行代码

c(ont(inue))，让程序正常运行，直到遇到下一个断点

n(ext)，让程序运行下一行，如果当前语句有一个函数调用，用n是不会进入被调用的函数体中的

下图中展示的，当对脚本断点调试到 testFun.add(a, 1)时，继续执行n，并不会进入 testFun.add(a, 1)的函数内部

s(tep)，跟n相似，但如果当前有一个函数调用，那么 s会进入被调用的函数体中

下图中展示的，当对脚本断点调试到 testFun.add(a, 1)时，继续执行s，会进入 testFun.add(a, 1)对应的函数定义内部，虽然 testFun.add不是本脚本中定义的函数

j(ump)，让程序跳转到指定的行数

假如当前所在行是 10，注意：假如执行了 j 20 之后，那么相当于程序直接跳到 20行，中间的 11~19行其实就直接跳过去根本没有被执行到，所以如果这段代码中有变量的声明或对象的初始化需要在 20行及之后被用到，那么等到用到的时候就可能导致报错！

打印重要信息

a(rgs)，打印当前函数的参数。比如下图就是展示断点进入到 testFun.add内部之后，打印 testFun.add的参数

p，打印某个变量

退出调试

q，直接退出调试；或者使用 Ctrl+D的方式退出

最后说一句

上面展示的使用 Pdb调试的过程其实是很简单的，文章中主要通过截图展示运行的效果。如果单纯的看一遍文章，不出意外，会很没有头绪，甚至感觉截图中的命令、输出乱七八糟，但是如果亲自动手跟着走一遍流程，花不了一小时，但是效果绝对极佳！

文章来源：https://www.cnblogs.com/loveyouyou616/p/7525863.html

pdb是基于命令行的调试工具，非常类似gnu的gdb（调试c/c++）。

命令	简写命令	作用
break	b	设置断点
continue	c	继续执行程序
list	l	查看当前行的代码段
step	s	进入函数
return	r	执行代码直到从当前函数返回
quit	q	中止并退出
next	n	执行下一行
print	p	打印变量的值
help	h	帮助
args	a	查看传入参数
	回车	重复上一条命令
break	b	显示所有断点
break lineno	b lineno	在指定行设置断点
break file:lineno	b file:lineno	在指定文件的行设置断点
clear num		删除指定断点
bt		查看函数调用栈帧

执行时调试

程序启动，停止在第一行等待单步调试。

python -m pdb some.py

交互调试

进入python或ipython解释器

import pdb
pdb.run('testfun(args)') #此时会打开pdb调试，注意：先使用s跳转到这个testfun函数中，然后就可以使用l看到代码了

程序里埋点

当程序执行到pdb.set_trace() 位置时停下来调试

代码上下文
...

import pdb
pdb.set_trace()

…

 

日志调试

print大法好

---

使用pdb调试的5个demo

demo 1

import pdb 
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
final = a + b + c 
print final

#调试方法

# 《1 显示代码》
# l---->能够显示当前调试过程中的代码，其实l表示list列出的意思
#如下，途中，-> 指向的地方表示要将要执行的位置
# 2 a = “aaa”
# 3 pdb.set_trace()
# 4 b = “bbb”
# 5 c = “ccc”
# 6 pdb.set_trace()
# 7 -> final = a + b + c
# 8 print final

# 《2 执行下一行代码》
# n---->能够向下执行一行代码，然后停止运行等待继续调试 n表示next的意思

# 《3 查看变量的值》
# p---->能够查看变量的值，p表示prit打印输出的意思
#例如：
# p name 表示查看变量name的值

demo 2

import pdb 
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
pdb.set_trace()
final = a + b + c 
print final

# 《4 将程序继续运行》
# c----->让程序继续向下执行，与n的区别是n只会执行下面的一行代码，而c会像python xxxx.py一样 继续执行不会停止；c表示continue的意思

# 《5 set_trace()》
# 如果程序中有多个set_trace()，那么能够让程序在使用c的时候停留在下一个set_trace()位置处

demo 3

#coding=utf-8
import pdb 

def combine(s1,s2):
s3 = s1 + s2 + s1
s3 = ‘"’ + s3 +’"’
return s3

a = “aaa”
pdb.set_trace()
b = “bbb”
c = “ccc”
final = combine(a,b)
print final

# 《6 设置断点》
# b---->设置断点，即当使用c的时候，c可以在遇到set_trace()的时候停止，也可以在遇到标记有断点的地方停止；b表示break的意思
#例如：
#b 11 在第11行设置断点，注意这个11可以使用l来得到
# (Pdb) l
# 4 s3 = s1 + s2 + s1
# 5 s3 = ‘"’ + s3 +’"’
# 6 return s3
# 7 a = “aaa”
# 8 pdb.set_trace()
# 9 -> b = “bbb”
# 10 c = “ccc”
# 11 final = combine(a,b)
# 12 print final
# [EOF]
# (Pdb) b 11
# Breakpoint 1 at /Users/wangmingdong/Desktop/test3.py:11
# (Pdb) c
# > /Users/wangmingdong/Desktop/test3.py(11)<module>()
# -> final = combine(a,b)
# (Pdb) l
# 6 return s3
# 7 a = “aaa”
# 8 pdb.set_trace()
# 9 b = “bbb”
# 10 c = “ccc”
# 11 B-> final = combine(a,b)
# 12 print final

# 《7 进入函数继续调试》
# s---->进入函数里面继续调试，如果使用n表示把一个函数的调用当做一条语句执行过去，而使用s的话，会进入到这个函数 并且停止
#例如
# (Pdb) l
# 6 return s3
# 7 a = “aaa”
# 8 pdb.set_trace()
# 9 b = “bbb”
# 10 c = “ccc”
# 11 B-> final = combine(a,b)
# 12 print final
# [EOF]
# (Pdb) s
# --Call–
# > /Users/wangmingdong/Desktop/test3.py(3)combine()
# -> def combine(s1,s2):
# (Pdb) l
# 1 import pdb
# 2
# 3 -> def combine(s1,s2):
# 4 s3 = s1 + s2 + s1
# 5 s3 = ‘"’ + s3 +’"’
# 6 return s3
# 7 a = “aaa”
# 8 pdb.set_trace()
# 9 b = “bbb”
# 10 c = “ccc”
# 11 B final = combine(a,b)
# (Pdb)

# 《8 查看传递到函数中的变量》
# a---->调用一个函数时，可以查看传递到这个函数中的所有的参数；a表示arg的意思
#例如：
# (Pdb) l
# 1 #coding=utf-8
# 2 import pdb
# 3
# 4 -> def combine(s1,s2):
# 5 s3 = s1 + s2 + s1
# 6 s3 = ‘"’ + s3 +’"’
# 7 return s3
# 8
# 9 a = “aaa”
# 10 pdb.set_trace()
# 11 b = “bbb”
# (Pdb) a
# s1 = aaa
# s2 = bbb

# 《9 执行到函数的最后一步》
# r----->如果在函数中不想一步步的调试了，只是想到这个函数的最后一条语句那个位置，比如return语句，那么就可以使用r；r表示return的意思

demo 4

In [1]: def pdb_test(arg):
   ...:     for i in range(arg):
   ...:         print(i)
   ...:     return arg
   ...:

In [2]: #在python交互模式中，如果想要调试这个函数，那么可以

In [3]: #采用，pdb.run的方式，如下：

In [4]: import pdb

In [5]: pdb.run(“pdb_test(10)”)
> <string>(1)<module>()
(Pdb) s
–Call–
> <ipython-input-1-ef4d08b8cc81>(1)pdb_test()
-> def pdb_test(arg):
(Pdb) l
1 -> def pdb_test(arg):
2 for i in range(arg):
3 print(i)
4 return arg
[EOF]
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb) l
1 def pdb_test(arg):
2 -> for i in range(arg):
3 print(i)
4 return arg
[EOF]
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(3)pdb_test()
-> print(i)
(Pdb)
0
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb)
> <ipython-input-1-ef4d08b8cc81>(3)pdb_test()
-> print(i)
(Pdb)
1
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb)

demo 5 运行过程中使用pdb修改变量的值

In [7]: pdb.run("pdb_test(1)")
> <string>(1)<module>()
(Pdb) s
--Call--
> <ipython-input-1-ef4d08b8cc81>(1)pdb_test()
-> def pdb_test(arg):
(Pdb) a
arg = 1
(Pdb) l
  1  ->    def pdb_test(arg):
  2          for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) !arg = 100  #!!!这里是修改变量的方法
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb) l
  1      def pdb_test(arg):
  2  ->        for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) p arg
100
(Pdb)

pdb 调试有个明显的缺陷就是对于多线程，远程调试等支持得不够好，同时没有较为直观的界面显示，不太适合大型的 python 项目。而在较大的 python 项目中，这些调试需求比较常见，因此需要使用更为高级的调试工具。