How to Debug Python Errors

In-depth understanding of Python errors: Efficient troubleshooting with introspection and debugger

This article explores how to efficiently debug program errors using Python's introspection and debugging tools such as PDB. The article will be developed from the aspects of typical error information analysis, PDB debugger usage, production environment debugging, and frequently asked questions to help readers improve their Python debugging skills.

Python's powerful introspection allows us to understand runtime errors more deeply. By checking every frame in the call stack, including the calling parameters of the function, we can reproduce and understand errors more easily. Tools such as Sentry make full use of this feature to provide richer error context information.

Let's look at a common Python error example:

<code>TypeError: expected string or buffer
  File "sentry/stacktraces.py", line 309, in process_single_stacktrace
    processable_frame, processing_task)
  File "sentry/lang/native/plugin.py", line 196, in process_frame
    in_app = (in_app and not self.sym.is_internal_function(raw_frame.get('function')))
  File "sentry/lang/native/symbolizer.py", line 278, in is_internal_function
    return _internal_function_re.search(function) is not None</code>

This error message only tells us the type and location of the error, but cannot directly point out the cause of the error. We may have to guess that integers or NoneTypes are passed, but the actual situation may be diverse.

Log record and PDB debugger

A simple debugging method is to add logging:

import logging
# ...
logging.debug("function is of type %s", type(function))

This helps to understand variable types during development. However, in production environments, this approach is not ideal due to the redundancy of DEBUG-level logs.

At this point, the Python debugger (PDB) comes in handy. PDB allows us to step through the code through breakpoints and check variables and their types. We can set breakpoints by inserting import pdb; pdb.set_trace() into the code:

def is_internal_function(self, function):
    try:
        return _internal_function_re.search(function) is not None
    except Exception:
        import pdb; pdb.set_trace()
        raise

After the breakpoint hits, we will enter the PDB interactive environment where we can use the

to view the variable type, use the type(function) to view local variables, and navigate the call stack with the locals() and down commands. up

Production environment debugging

In a production environment, the CPython runtime allows us to access the current call stack, including local variables for each execution frame.

Exception information can be obtained, including traceback objects. By traversing the traceback object, we can access the sys.exc_info() attribute of each frame to view the local variable: f_locals

Tools such as

exc_type, exc_value, tb = sys.exc_info()
inner_frame = tb.tb_next.tb_frame # 可能需要遍历tb_next找到合适的frame
pprint(inner_frame.f_locals)

Sentry will automatically perform similar introspection operations, providing rich error context information without manually adding code.

FAQ

The article finally provides FAQs about Python error debugging, covering common error types, PDB usage, IDE debugging, exception handling, remote debugging, multi-threaded debugging, third-party library debugging, performance problem debugging, and debugging skills improvement etc.

Some content of this article is adapted from Sentry articles. Thanks to our partners who support SitePoint.

The above is the detailed content of How to Debug Python Errors. For more information, please follow other related articles on the PHP Chinese website!