pdb —- Python的调试器

源代码：Lib/pdb.py

The module pdb 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 class Pdb.This is currently undocumented but easily understood by reading the source. Theextension interface uses the modules bdb and cmd.

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

>>> import pdb
>>> import mymodule
>>> pdb.run('mymodule.test()')
> <string>(0)?()
(Pdb) continue
> <string>(1)?()
(Pdb) continue
NameError: 'spam'
> <string>(1)?()
(Pdb)

在 3.3 版更改: Tab-completion via the readline module is available for commands andcommand arguments, e.g. the current global and local names are offered asarguments of the p command.

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

python3 -m pdb myscript.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.

3.2 新版功能: pdb.py now accepts a -c option that executes commands as if givenin a .pdbrc file, see Debugger Commands.

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

import pdb; 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 the continue command.

3.7 新版功能: The built-in breakpoint(), when called with defaults, can be usedinstead of import pdb; pdb.set_trace().

The typical usage to inspect a crashed program is:

>>> import pdb
>>> import mymodule
>>> mymodule.test()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "./mymodule.py", line 4, in test
    test2()
  File "./mymodule.py", line 3, in test2
    print(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 the statement (given as a string or a code object) under debuggercontrol. The debugger prompt appears before any code is executed; you canset breakpoints and type continue, or you can step through thestatement using step or next (all these commands areexplained below). The optional globals and locals 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() or eval() functions.)

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

• Evaluate the expression (given as a string or a code object) under debuggercontrol. When runeval() returns, it returns the value of theexpression. Otherwise this function is similar to run().

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

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

• pdb.settrace(*, _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.

在 3.7 版更改: The keyword-only argument header.

• pdb.postmortem(_traceback=None)

• Enter post-mortem debugging of the given traceback 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.

The run* functions and set_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:

• class pdb.Pdb(completekey='tab', stdin=None, stdout=None, skip=None, nosigint=False, readrc=True)
• Pdb is the debugger class.

The completekey, stdin and stdout arguments are passed to theunderlying cmd.Cmd class; see the description there.

The skip 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 presses Ctrl-C on the console) when you give a continue command.This allows you to break into the debugger again by pressing Ctrl-C. If youwant Pdb not to touch the SIGINT handler, set nosigint to true.

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

Example call to enable tracing with skip:

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

Raises an auditing event pdb.Pdb with no arguments.

3.1 新版功能: The skip argument.

3.2 新版功能: The nosigint argument. Previously, a SIGINT handler was never set byPdb.

在 3.6 版更改: The readrc 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 thateither h or help can be used to enter the help command (but not heor hel, nor H or Help or HELP). 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 a list 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 supports aliases. 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.

在 3.2 版更改: .pdbrc can now contain commands that continue debugging, such ascontinue or next. Previously, these commands had noeffect.

• h(elp) [command]

• Without argument, print the list of available commands. With a command asargument, print help about that command. help pdb displays the fulldocumentation (the docstring of the pdb module). Since the _command_argument must be an identifier, help exec 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 frame count (default one) levels down in the stack trace(to a newer frame).

• u(p) [count]

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

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

• With a lineno 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 on sys.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 for break.

• cl(ear) [filename:lineno | bpnumber [bpnumber …]]

• With a filename: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 new condition for the breakpoint, an expression which must evaluateto true before the breakpoint is honored. If condition is absent, anyexisting condition is removed; i.e., the breakpoint is made unconditional.

• commands [bpnumber]

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

(Pdb) commands 1
(com) p some_variable
(com) end
(Pdb)

To remove all commands from a breakpoint, type commands and follow itimmediately with end; that is, give no commands.

With no bpnumber argument, commands refers to the last breakpoint set.

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

Specifying any command resuming execution(currently continue, 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 between next and step isthat step stops inside a called function, while nextexecutes 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.

在 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 a for 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.

3.2 新版功能: The >> marker.

• ll | longlist
• List all source code for the current function or frame. Interesting linesare marked as for list.

3.2 新版功能.

• a(rgs)

• Print the argument list of the current function.

• p expression

• Evaluate the expression in the current context and print its value.

注解

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

• pp expression

• Like the p command, except the value of the expression ispretty-printed using the pprint module.

• whatis expression

• Print the type of the expression.

• source expression

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

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.

3.2 新版功能.

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

3.2 新版功能.

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

3.2 新版功能.

• alias [name [command]]
• Create an alias called name that executes command. 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 for name 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 commands can 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")
alias pi for k in %1.__dict__.keys(): print("%1.",k,"=",%1.__dict__[k])
# Print instance variables in self
alias ps pi self

• 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 a global statement on the same line,e.g.:

(Pdb) global list_options; list_options = ['-l']
(Pdb)

• run [args …]
• restart [args …]

• Restart the debugged Python program. If an argument is supplied, it is splitwith shlex and the result is used as the new sys.argv.History, breakpoints, actions and debugger options are preserved.restart is an alias for run.

• 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.

• 脚注

• 1

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