Why You Need pdb++ for Python Debugging

Here’s the article for PythonSkillset.com:

When print() Isn’t Enough: Why You Need pdb++

Every Python developer hits that wall. Your code runs, but it runs wrong. You sprinkle print() statements everywhere, rerun the script, and squint at the console. It works, but it’s slow and messy. There’s a better way, and it’s called pdb++.

Think of pdb++ as the standard Python debugger (pdb) but with a serious upgrade. It’s like switching from a basic screwdriver to a power drill. It doesn’t change how debugging works fundamentally, but it makes the whole experience smoother, faster, and way less frustrating.

I first started using pdb++ after a particularly nasty bug where the standard debugger kept crashing on me. I needed something more stable, and I needed it to show me my code in color. pdb++ solved both problems. Now, I can’t imagine debugging without it.

What Makes pdb++ Special?

At its core, pdb++ is a drop-in replacement for pdb. If you know how to use pdb, you already know how to use pdb++. The commands are the same: n for next, c for continue, s for step into, l for list, and so on.

But here’s where it gets interesting.

1. Syntax Highlighting

The first thing you notice when you drop into a pdb++ session is that your code is in color. Keywords are highlighted, strings and comments stand out, and variables pop. This might sound trivial, but when you’re scanning a complex function with nested loops and conditionals, color makes it dramatically easier to see what’s happening.

2. Sticky Mode

This alone is worth the price of admission (which is free, by the way). In standard pdb, after every n command, the debugger shows you the next line. But you often forget where you are in the broader function. With pdb++ in sticky mode, the terminal window is split. The top part shows the full source code with the current line highlighted. The bottom part is your command prompt. You can watch the highlight crawl down the code as you step through. It’s like having a map while you walk through dark code.

3. Better Tracebacks

When your code crashes and you enter post-mortem debugging (with the pm command), pdb++ shows you a much more detailed traceback. It includes local variables in each frame of the call stack. So instead of just knowing where the error happened, you can see what values caused it. This saves so much time.

4. Smart Tab Completion

Inside the debugger, you can hit Tab to autocomplete variable names, attribute names, even module paths. It’s the same kind of convenience you get from a modern IDE. If you’ve ever typed my_ve and then hit Tab to complete my_very_long_variable_name, you know exactly what I’m talking about.

5. Underline Matching

pdb++ can underline the current line in the source code display, instead of just adding an arrow. This is a small visual cue that makes it easier to see exactly where you are.

Getting Started with pdb++

Install it in one line:

pip install pdbpp

That’s it. Now, whenever you use the standard pdb.set_trace() in your code, pdb++ will automatically take over. No need to change your imports.

import pdb

def calculate_discount(price, customer_type):
    pdb.set_trace()  # pdbpp takes over silently
    if customer_type == "gold":
        return price * 0.8
    return price * 0.9

When you run this, you land in the pdb++ interface. Try typing n to step to the next line. Look at the color. Try l to see the context. Then try typing customer_type and hitting Enter to check the variable value.

To enable sticky mode, type sticky at the (Pdb++) prompt. Your terminal will immediately split into source view on top and prompt below.

If you want sticky mode by default, set an environment variable:

export PYDBPLUS_STICKY=1

Or add it to your shell profile for permanent use.

A Real-World Example

I was recently working on a script that processes user uploads for PythonSkillset’s file handling guide. There was a bug where large CSV files would silently fail. Standard pdb would show me the line where it fails, but not why. With pdb++, I dropped in a trace right before the file processing loop:

import pdb

def process_large_csv(filepath):
    # ... setup code ...
    pdb.set_trace()
    for row in csv_reader:
        process_row(row)

When I ran the script and hit the trace, I turned on sticky mode. I could see the entire process_large_csv function laid out in color on my terminal. I stepped through line by line with n. After a few steps, I noticed the csv_reader variable was actually an empty list because of a file pointer issue earlier in the function. In standard pdb, I would have had to type print(csv_reader) and then switch my mental focus. With pdb++, the context was right there.

When Should You Use It?

Every single time you use pdb. There’s no downside. pdb++ doesn’t change the behavior of your code, it only changes the debugging interface. It’s compatible with Python 3.6 and later.

If you’re still debugging with print(), make the switch today. Install pdb++, sprinkle a few pdb.set_trace() calls in your code, and watch your debugging speed double. It’s one of those small tools that instantly becomes an essential part of your workflow.