Debugging Python Code: Tips and Tricks

Mastering Debugging Techniques to Fix Python Errors Efficiently

image by Gajanan Rajput

Introduction

Python is a powerful and versatile programming language, but debugging Python code can sometimes be challenging, even for experienced developers. Identifying and fixing errors efficiently is crucial for smooth development. In this article, we will explore some of the best tips and tricks to debug Python code effectively.

1. Understanding Common Python Errors

Before diving into debugging techniques, it’s essential to understand the common types of errors in Python:

• Syntax Errors: Occur when the Python interpreter encounters incorrect syntax.
• Indentation Errors: Due to incorrect indentation, which is crucial in Python.
• Name Errors: Arise when a variable or function is not defined.
• Type Errors: Occur when an operation is performed on an incompatible data type.
• Index Errors: Happen when accessing an invalid index in a list or tuple.
• Key Errors: Raised when trying to access a non-existent key in a dictionary.
• Attribute Errors: Occur when an object does not have the requested attribute.

2. Print Statements for Quick Debugging

One of the simplest ways to debug Python code is by using print() statements. By strategically placing print statements in your code, you can trace variable values and program flow.

x = 10
y = 0
print("Before division")
print("x:", x, "y:", y)
result = x / y  # This will cause a ZeroDivisionError
print("Result:", result)

While effective for small scripts, excessive use of print statements can clutter your code.

3. Using the Python Debugger (pdb)

Python’s built-in debugger, pdb, allows you to step through code, inspect variables, and control execution flow.

Get Madhu deepak’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

To start debugging, insert the following line in your code:

import pdb; pdb.set_trace()

Alternatively, you can run a script in debug mode:

python -m pdb script.py

Useful pdb commands:

• n (next) – Execute the next line
• s (step) – Step into a function
• c (continue) – Resume execution
• q (quit) – Exit debugger
• p variable – Print the value of a variable

4. Using Logging Instead of Print Statements

Instead of using print statements, the logging module provides more control over debug information.

import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

x = 10
y = 0
logging.debug("Before division. x: %d, y: %d", x, y)
result = x / y  # ZeroDivisionError
logging.debug("Result: %d", result)

Logging offers different levels like DEBUG, INFO, WARNING, ERROR, and CRITICAL, allowing better log management.

5. Exception Handling for Better Debugging

Using try-except blocks prevents program crashes and helps catch errors gracefully.

try:
    x = 10
    y = 0
    result = x / y
except ZeroDivisionError as e:
    print(f"Error: {e}")

You can log exceptions instead of printing them:

import logging

try:
    result = 10 / 0i
except ZeroDivisionError as e:
    logging.error("Exception occurred", exc_info=True)

6. Using IDE Debugging Tools

Most modern IDEs, such as PyCharm, VS Code, and Jupyter Notebook, offer built-in debugging tools with breakpoints, variable inspection, and step-through execution.

PyCharm Debugging

• Set breakpoints by clicking on the left margin.
• Run the script in debug mode.
• Inspect variables and modify them on the fly.

VS Code Debugging

• Use the Debug Console (Ctrl + Shift + D).
• Set breakpoints and use the interactive debug console.
• View variable values in real-time.

7. Using Assertions for Debugging

Assertions are useful for catching unexpected values during execution.

x = -1
assert x >= 0, "x should be non-negative"

If the assertion fails, Python raises an AssertionError with the specified message.

8. Using External Debugging Tools

There are several external tools available for debugging Python:

• Pydevd — A remote debugging tool for Python.
• Pyrasite — A debugging tool for running processes.
• Faulthandler — A built-in module for getting Python stack traces on crashes.

To enable faulthandler, use:

import faulthandler
faulthandler.enable()

9. Debugging Performance Issues with Profiling

If your Python script runs slower than expected, use the cProfile module to analyze performance.

python -m cProfile script.py

This will show function execution times, helping you identify bottlenecks.

10. Using Type Hints to Avoid Errors

Adding type hints makes your code more readable and helps catch type-related bugs.

def add_numbers(a: int, b: int) -> int:
    return a + b

Use mypy to check type errors:

mypy script.py

Conclusion

Debugging Python code is an essential skill that can save you hours of frustration. By understanding common errors, using print statements wisely, leveraging debugging tools like pdb, logging, exception handling, and performance profiling, you can make your debugging process more efficient. Start incorporating these tips and tricks into your workflow to write cleaner and error-free Python code!