pdb — The Python Debugger

Source code:Lib/pdb.py

The modulepdb defines an interactive source code debugger for Pythonprograms. It supports setting (conditional) breakpoints and single stepping atthe source line level, inspection of stack frames, source code listing, andevaluation of arbitrary Python code in the context of any stack frame. It alsosupports post-mortem debugging and can be called under program control.

The debugger is extensible – it is actually defined as the classPdb.This is currently undocumented but easily understood by reading the source. Theextension interface uses the modulesbdb andcmd.

The debugger’s prompt is(Pdb). Typical usage to run a program under controlof the debugger is:

>>>importpdb>>>importmymodule>>>pdb.run('mymodule.test()')> <string>(0)?()(Pdb) continue> <string>(1)?()(Pdb) continueNameError: 'spam'> <string>(1)?()(Pdb)

Changed in version 3.3:Tab-completion via thereadline module is available for commands andcommand arguments, e.g. the current global and local names are offered asarguments of thep command.

pdb.py can also be invoked as a script to debug other scripts. Forexample:

python3-mpdbmyscript.py

When invoked as a script, pdb will automatically enter post-mortem debugging ifthe program being debugged exits abnormally. After post-mortem debugging (orafter normal exit of the program), pdb will restart the program. Automaticrestarting preserves pdb’s state (such as breakpoints) and in most cases is moreuseful than quitting the debugger upon program’s exit.

New in version 3.2:pdb.py now accepts a-c option that executes commands as if givenin a.pdbrc file, seeDebugger Commands.

New in version 3.7:pdb.py now accepts a-m option that execute modules similar to the waypython3-m does. As with a script, the debugger will pause execution justbefore the first line of the module.

The typical usage to break into the debugger from a running program is toinsert

importpdb;pdb.set_trace()

at the location you want to break into the debugger. You can then step throughthe code following this statement, and continue running without the debuggerusing thecontinue command.

New in version 3.7:The built-inbreakpoint(), when called with defaults, can be usedinstead ofimportpdb;pdb.set_trace().

The typical usage to inspect a crashed program is:

>>>importpdb>>>importmymodule>>>mymodule.test()Traceback (most recent call last):  File"<stdin>", line1, in<module>  File"./mymodule.py", line4, intesttest2()  File"./mymodule.py", line3, intest2print(spam)NameError:spam>>>pdb.pm()> ./mymodule.py(3)test2()-> print(spam)(Pdb)

The module defines the following functions; each enters the debugger in aslightly different way:

pdb.run(statement,globals=None,locals=None)

Execute thestatement (given as a string or a code object) under debuggercontrol. The debugger prompt appears before any code is executed; you canset breakpoints and typecontinue, or you can step through thestatement usingstep ornext (all these commands areexplained below). The optionalglobals andlocals arguments specify theenvironment in which the code is executed; by default the dictionary of themodule__main__ is used. (See the explanation of the built-inexec() oreval() functions.)

pdb.runeval(expression,globals=None,locals=None)

Evaluate theexpression (given as a string or a code object) under debuggercontrol. Whenruneval() returns, it returns the value of theexpression. Otherwise this function is similar torun().

pdb.runcall(function,*args,**kwds)

Call thefunction (a function or method object, not a string) with thegiven arguments. Whenruncall() returns, it returns whatever thefunction call returned. The debugger prompt appears as soon as the functionis entered.

pdb.set_trace(*,header=None)

Enter the debugger at the calling stack frame. This is useful to hard-codea breakpoint at a given point in a program, even if the code is nototherwise being debugged (e.g. when an assertion fails). If given,header is printed to the console just before debugging begins.

Changed in version 3.7:The keyword-only argumentheader.

pdb.post_mortem(traceback=None)

Enter post-mortem debugging of the giventraceback object. If notraceback is given, it uses the one of the exception that is currentlybeing handled (an exception must be being handled if the default is to beused).

pdb.pm()

Enter post-mortem debugging of the traceback found insys.last_traceback.

Therun* functions andset_trace() are aliases for instantiating thePdb class and calling the method of the same name. If you want toaccess further features, you have to do this yourself:

classpdb.Pdb(completekey='tab',stdin=None,stdout=None,skip=None,nosigint=False,readrc=True)

Pdb is the debugger class.

Thecompletekey,stdin andstdout arguments are passed to theunderlyingcmd.Cmd class; see the description there.

Theskip argument, if given, must be an iterable of glob-style module namepatterns. The debugger will not step into frames that originate in a modulethat matches one of these patterns.1

By default, Pdb sets a handler for the SIGINT signal (which is sent when theuser pressesCtrl-C on the console) when you give acontinue command.This allows you to break into the debugger again by pressingCtrl-C. If youwant Pdb not to touch the SIGINT handler, setnosigint to true.

Thereadrc argument defaults to true and controls whether Pdb will load.pdbrc files from the filesystem.

Example call to enable tracing withskip:

importpdb;pdb.Pdb(skip=['django.*']).set_trace()

Raises anauditing eventpdb.Pdb with no arguments.

New in version 3.1:Theskip argument.

New in version 3.2:Thenosigint argument. Previously, a SIGINT handler was never set byPdb.

Changed in version 3.6:Thereadrc argument.

run(statement,globals=None,locals=None)
runeval(expression,globals=None,locals=None)
runcall(function,*args,**kwds)
set_trace()

See the documentation for the functions explained above.

Debugger Commands

The commands recognized by the debugger are listed below. Most commands can beabbreviated to one or two letters as indicated; e.g.h(elp) means thateitherh orhelp can be used to enter the help command (but notheorhel, norH orHelp orHELP). Arguments to commands must beseparated by whitespace (spaces or tabs). Optional arguments are enclosed insquare brackets ([]) in the command syntax; the square brackets must not betyped. Alternatives in the command syntax are separated by a vertical bar(|).

Entering a blank line repeats the last command entered. Exception: if the lastcommand was alist command, the next 11 lines are listed.

Commands that the debugger doesn’t recognize are assumed to be Python statementsand are executed in the context of the program being debugged. Pythonstatements can also be prefixed with an exclamation point (!). This is apowerful way to inspect the program being debugged; it is even possible tochange a variable or call a function. When an exception occurs in such astatement, the exception name is printed but the debugger’s state is notchanged.

The debugger supportsaliases. Aliases can haveparameters which allows one a certain level of adaptability to the context underexamination.

Multiple commands may be entered on a single line, separated by;;. (Asingle; is not used as it is the separator for multiple commands in a linethat is passed to the Python parser.) No intelligence is applied to separatingthe commands; the input is split at the first;; pair, even if it is in themiddle of a quoted string.

If a file.pdbrc exists in the user’s home directory or in the currentdirectory, it is read in and executed as if it had been typed at the debuggerprompt. This is particularly useful for aliases. If both files exist, the onein the home directory is read first and aliases defined there can be overriddenby the local file.

Changed in version 3.2:.pdbrc can now contain commands that continue debugging, such ascontinue ornext. Previously, these commands had noeffect.

h(elp) [command]

Without argument, print the list of available commands. With acommand asargument, print help about that command.helppdb displays the fulldocumentation (the docstring of thepdb module). Since thecommandargument must be an identifier,helpexec must be entered to get help onthe! command.

w(here)

Print a stack trace, with the most recent frame at the bottom. An arrowindicates the current frame, which determines the context of most commands.

d(own) [count]

Move the current framecount (default one) levels down in the stack trace(to a newer frame).

u(p) [count]

Move the current framecount (default one) levels up in the stack trace (toan older frame).

b(reak) [([filename:]lineno | function) [, condition]]

With alineno argument, set a break there in the current file. With afunction argument, set a break at the first executable statement withinthat function. The line number may be prefixed with a filename and a colon,to specify a breakpoint in another file (probably one that hasn’t been loadedyet). The file is searched onsys.path. Note that each breakpointis assigned a number to which all the other breakpoint commands refer.

If a second argument is present, it is an expression which must evaluate totrue before the breakpoint is honored.

Without argument, list all breaks, including for each breakpoint, the numberof times that breakpoint has been hit, the current ignore count, and theassociated condition if any.

tbreak [([filename:]lineno | function) [, condition]]

Temporary breakpoint, which is removed automatically when it is first hit.The arguments are the same as forbreak.

cl(ear) [filename:lineno | bpnumber [bpnumber ...]]

With afilename:lineno argument, clear all the breakpoints at this line.With a space separated list of breakpoint numbers, clear those breakpoints.Without argument, clear all breaks (but first ask confirmation).

disable [bpnumber [bpnumber ...]]

Disable the breakpoints given as a space separated list of breakpointnumbers. Disabling a breakpoint means it cannot cause the program to stopexecution, but unlike clearing a breakpoint, it remains in the list ofbreakpoints and can be (re-)enabled.

enable [bpnumber [bpnumber ...]]

Enable the breakpoints specified.

ignore bpnumber [count]

Set the ignore count for the given breakpoint number. If count is omitted,the ignore count is set to 0. A breakpoint becomes active when the ignorecount is zero. When non-zero, the count is decremented each time thebreakpoint is reached and the breakpoint is not disabled and any associatedcondition evaluates to true.

condition bpnumber [condition]

Set a newcondition for the breakpoint, an expression which must evaluateto true before the breakpoint is honored. Ifcondition is absent, anyexisting condition is removed; i.e., the breakpoint is made unconditional.

commands [bpnumber]

Specify a list of commands for breakpoint numberbpnumber. The commandsthemselves appear on the following lines. Type a line containing justend to terminate the commands. An example:

(Pdb)commands1(com)psome_variable(com)end(Pdb)

To remove all commands from a breakpoint, typecommands and follow itimmediately withend; that is, give no commands.

With nobpnumber argument,commands refers to the last breakpoint set.

You can use breakpoint commands to start your program up again. Simply usethecontinue command, orstep,or any other command that resumes execution.

Specifying any command resuming execution(currentlycontinue,step,next,return,jump,quit and their abbreviations)terminates the command list (as ifthat command was immediately followed by end). This is because any time youresume execution (even with a simple next or step), you may encounter anotherbreakpoint—which could have its own command list, leading to ambiguities aboutwhich list to execute.

If you use the ‘silent’ command in the command list, the usual message aboutstopping at a breakpoint is not printed. This may be desirable for breakpointsthat are to print a specific message and then continue. If none of the othercommands print anything, you see no sign that the breakpoint was reached.

s(tep)

Execute the current line, stop at the first possible occasion (either in afunction that is called or on the next line in the current function).

n(ext)

Continue execution until the next line in the current function is reached orit returns. (The difference betweennext andstep isthatstep stops inside a called function, whilenextexecutes called functions at (nearly) full speed, only stopping at the nextline in the current function.)

unt(il) [lineno]

Without argument, continue execution until the line with a number greaterthan the current one is reached.

With a line number, continue execution until a line with a number greater orequal to that is reached. In both cases, also stop when the current framereturns.

Changed in version 3.2:Allow giving an explicit line number.

r(eturn)

Continue execution until the current function returns.

c(ont(inue))

Continue execution, only stop when a breakpoint is encountered.

j(ump) lineno

Set the next line that will be executed. Only available in the bottom-mostframe. This lets you jump back and execute code again, or jump forward toskip code that you don’t want to run.

It should be noted that not all jumps are allowed – for instance it is notpossible to jump into the middle of afor loop or out of afinally clause.

l(ist) [first[, last]]

List source code for the current file. Without arguments, list 11 linesaround the current line or continue the previous listing. With. asargument, list 11 lines around the current line. With one argument,list 11 lines around at that line. With two arguments, list the given range;if the second argument is less than the first, it is interpreted as a count.

The current line in the current frame is indicated by->. If anexception is being debugged, the line where the exception was originallyraised or propagated is indicated by>>, if it differs from the currentline.

New in version 3.2:The>> marker.

ll | longlist

List all source code for the current function or frame. Interesting linesare marked as forlist.

New in version 3.2.

a(rgs)

Print the argument list of the current function.

p expression

Evaluate theexpression in the current context and print its value.

Note

print() can also be used, but is not a debugger command — this executes thePythonprint() function.

pp expression

Like thep command, except the value of the expression ispretty-printed using thepprint module.

whatis expression

Print the type of theexpression.

source expression

Try to get source code for the given object and display it.

New in version 3.2.

display [expression]

Display the value of the expression if it changed, each time execution stopsin the current frame.

Without expression, list all display expressions for the current frame.

New in version 3.2.

undisplay [expression]

Do not display the expression any more in the current frame. Withoutexpression, clear all display expressions for the current frame.

New in version 3.2.

interact

Start an interactive interpreter (using thecode module) whose globalnamespace contains all the (global and local) names found in the currentscope.

New in version 3.2.

alias [name [command]]

Create an alias calledname that executescommand. The command mustnot be enclosed in quotes. Replaceable parameters can be indicated by%1,%2, and so on, while%* is replaced by all the parameters.If no command is given, the current alias forname is shown. If noarguments are given, all aliases are listed.

Aliases may be nested and can contain anything that can be legally typed atthe pdb prompt. Note that internal pdb commandscan be overridden byaliases. Such a command is then hidden until the alias is removed. Aliasingis recursively applied to the first word of the command line; all other wordsin the line are left alone.

As an example, here are two useful aliases (especially when placed in the.pdbrc file):

# Print instance variables (usage "pi classInst")aliaspiforkin%1.__dict__.keys():print("%1.",k,"=",%1.__dict__[k])# Print instance variables in selfaliaspspiself
unalias name

Delete the specified alias.

! statement

Execute the (one-line)statement in the context of the current stack frame.The exclamation point can be omitted unless the first word of the statementresembles a debugger command. To set a global variable, you can prefix theassignment command with aglobal statement on the same line,e.g.:

(Pdb)globallist_options;list_options=['-l'](Pdb)
run [args ...]
restart [args ...]

Restart the debugged Python program. If an argument is supplied, it is splitwithshlex and the result is used as the newsys.argv.History, breakpoints, actions and debugger options are preserved.restart is an alias forrun.

q(uit)

Quit from the debugger. The program being executed is aborted.

debug code

Enter a recursive debugger that steps through the codeargument (which is an arbitrary expression or statement to beexecuted in the current environment).

retval

Print the return value for the last return of a function.

Footnotes

1

Whether a frame is considered to originate in a certain moduleis determined by the__name__ in the frame globals.