10 Essential Python Debugging Techniques Every Developer Should Master

In Python development, debugging is a core skill. Whether you are a beginner or an experienced engineer, mastering efficient debugging techniques can significantly improve development productivity.

1. Using the built-in debugger pdb

The pdb module allows setting breakpoints, inspecting variable states, and stepping through code.

import pdb

def buggy_function(a, b):
    pdb.set_trace()  # set breakpoint
    return a / b

buggy_function(10, 0)

Running this code pauses execution at the breakpoint, entering an interactive debugging session where variables can be examined and modified.

Common pdb commands include n (next line), c (continue), and q (quit).

2. Advanced use of breakpoint()

Since Python 3.7, the built-in breakpoint() function provides a simpler way to invoke the debugger.

def calculate_area(length, width):
    breakpoint()  # insert breakpoint
    return length * width

calculate_area(5, "10")

When execution reaches breakpoint(), the debugger starts automatically, allowing real-time inspection and modification of program state.

3. Using assertions for early error detection

Assertions provide a concise way to catch errors early.

def calculate_speed(distance, time):
    assert time > 0, "Time must be greater than zero"
    return distance / time

Assertions are self-documenting but should be used cautiously in production code.

4. Professional logging with the logging module

Compared with simple print statements, the logging module offers a flexible and controllable logging solution.

import logging

logging.basicConfig(level=logging.DEBUG)

def buggy_function(a, b):
    logging.debug(f"Inputs: a={a}, b={b}")
    return a / b

buggy_function(10, 0)

The logging module supports different log levels (DEBUG, INFO, WARNING, etc.) and can redirect output to files for later analysis.

5. Optimizing list comprehensions

Complex list comprehensions can reduce readability. Splitting them into separate steps improves clarity.

# Not recommended
squared_numbers = [x**2 for x in numbers if x % 2 == 0 and x > 0]

# Recommended
filtered_numbers = [x for x in numbers if x % 2 == 0 and x > 0]
squared_numbers = [x**2 for x in filtered_numbers]

6. Debugging in IPython and Jupyter notebooks

The %debug magic command launches an interactive debugger after an exception.

def divide(a, b):
    return a / b

divide(10, 0)  # then run %debug

7. Using the warnings module

The warnings module can alert potential issues without stopping program execution.

import warnings

def risky_function(a, b):
    if b == 0:
        warnings.warn("b is zero, may cause division by zero", UserWarning)
    return a / b

risky_function(10, 0)

8. Debugging tools in IDEs (PyCharm, VSCode)

Modern IDEs provide full-featured debuggers. A typical workflow in PyCharm includes:

Set a breakpoint on the target line.

Run the program in debug mode.

Use the variable viewer and console for deep analysis.

IDE debuggers allow flexible navigation of the call stack.

9. Inspect module for runtime state inspection

The inspect module can retrieve local variables and other runtime information without inserting print statements.

import inspect

def example_function():
    frame = inspect.currentframe()
    print("Local variables:", frame.f_locals)

example_function()

10. Using unittest as a preventive debugging tool

The unittest framework can be used to build test scenarios that catch errors before they appear in production.

import unittest

class TestMath(unittest.TestCase):
    def setUp(self):
        self.data = {"a": 10, "b": 0}

    def test_division(self):
        with self.assertRaises(ZeroDivisionError):
            divide(self.data["a"], self.data["b"])

unittest.main()

Conclusion

By applying these debugging techniques, developers can more efficiently identify and resolve issues, improving code quality and development speed.