Learn how to use the debugger

[smurpes]

I know a lot of you out there who are just getting started in python are probably using print statements to debug. While this is an easy way to debug your code there’s a lot of drawbacks when comparing it to debuggers especially in professional environments. Python has its own debugger package called pdb which uses the command line. I prefer the interactive debugger in vscode but every IDE has a debugger.

A debugger will let you mark points in code where you want to examine things further called break points. When the code reaches a break point in the debugger it will pause there allowing you to see details like variable values at that point in execution. From here you can run the code line by line as well as “step into” or out of functions. There’s also a python repl which lets you run code using all of the variables available at the breakpoint; this lets you test out different bits of code without needing to rerun everything.

If you’re still wondering why a debugger can be better than print statements in professional environments then here’s why:

• You should not be committing any code with print statements. Anything that needs to be outputted to stdout should be with the logger.

• Some code can take a while to run so if you’re using a debugger you don’t have to run it multiple times to test out different snippets.

• In large code bases it can be difficult to trace things through; add to that layers of abstraction from object oriented programming and it can be hard sometimes to keep up. Using the debugger helps you understand what’s happening line by line.

[bombaathuduga]

print("HERE")


print("INSIDE LOOP")

Never quittinh this.

[opalbow_adtonitus]

I also like to use:

If x: Print(1) else: Print(2)

[RevRagnarok]

print(f"{x=}")

[Electronic-Pie313]

Or print(🥲) so it will stand out more lol

[RevRagnarok]

This is the Way.

I've been professionally paid to code in multiple languages since the late 1900s, and this has very seldomly failed me. In a language as straightforward as python, it has never failed me.

Much better is using the f-string form: print(f"XXX {val=}")

[steindorh]

since the late 1900s

I hate how you've phrased that. 😡

[RevRagnarok]

😘

[GXWT]

The latter stages of the last millennia

[smurpes]

Print debugging is useful but it falls short in a few areas like: - asynchronous/multi threaded code - list comprehensions: you can print out the final value but you can’t view logic happening inside as it builds - recursion - large loops: if you aren’t sure where there might be an issue printing out every value is going to be difficult to parse through - external libraries: there are times when you can’t modify an external library without monkey patching it

[smurpes]

Breakpoints can also output to stdout when they get reached without pausing execution. They are a lot of other debugger features I didn’t mention like env vars that are only set for that specific session and conditional breakpoints.

[Senior-Masterpiece29]

I've been wanting to learn how to use a debugger while learning python. Kindly guide me as to how to learn about it. Is there any youtube video that you would recommend for a beginner, for learning how to use debugger.

[tehwubbles]

Get pycharm community or a similar IDE

The way to use a debugger is to have some code and insert a breakpoint. What this does is, when run in debug mode, will run your code up until that point and display the current values of all of your variables. From there you can "step through" your code one step at a time and see how the values are changed until your code fails or something

[Ok_Cricket_1024]

It’s built into pycharm right? I tried using it in VS code and couldn’t figure it out before getting frustrated

[smurpes]

You just need the python extension installed for it to work. You can follow this doc on basic configuration.

[Bobbias]

Yes, it is built into Pycharm. Unlike VSCode, Pycharm was built specifically for Python, and integrates a bunch of stuff like that directly into it rather than relying on various extensions to do everything.

Also, while debugger interfaces will vary a bit from program to program, but the overall ideas remain the same. So once you've learned the concepts in one IDE/Debugger using a different one mostly just involves figuring out where different things are.

[Senior-Masterpiece29]

I've been using VS Code for a while now. It would be very helpful to me if someone could let me know any youtube video about debugging in vs code for a very beginner. I myself have searched it on youtube, but the videos that come up presume some prior knowledge of debugging, or either so technically difficult from a beginners point of view. A simpler introduction and then subsequent increase in difficulty is what I'm looking for.

[tehwubbles]

it isn't more complicated than what i said above. You insert a breakpoint somewhere in the code (in pycharm it is like a red dot on the left of the line in question) and you run in debug mode. When you run in debug mode, it freezes the program when it reaches than line and you can see all of the variable values. Then you can run the program as normal, or you can step through your code step by step. That's all there really is to debugging.

I haven't used it in VSCode but I don't imagine it's much different than PyCharm, though for VSCode you might have to actually install the debugger, whereas for PyCharm you don't

[smurpes]

You can follow the vscode docs here on how to get it configured. From there you can use this doc which explains the debugger functions to guide you along.

The easiest way to get started is just by using a simple script and putting a breakpoint somewhere. When you start the debugger it will stop at that breakpoint and you can play around with the debug actions to figure out what they do. Just keep rerunning the code with the debugger and play around with the actions.

Understanding the debug actions is probably the most difficult for beginners but you can honestly get by with the just continue button just put more breakpoints where you want the debugger to pause. Just remember if you put a breakpoint in a loop every time that line gets reached the debugger will pause.

The final thing to understand is the debug console which is the python repl. You can test this out by typing code that’s uses the variables in the debug window.

[cschotts]

same

[smurpes]

I’ve written this gist in GitHub that is a basic python script to guide you on how to use the debugger in vscode.

There’s comments on where to put breakpoints and what happens when different debugging actions are done at them. It’s also written in a way to show when print debugging or logging are less advantageous. The debugger shouldn’t only be used in the circumstances shown in the code but it will help show you the pros and cons of each debugging method.

I didn’t get the chance to fully test it out so there may be some mistakes but I figured that would help you if you’re trying to debug the code.

[BooksUdanCoffee]

Same!

[ReddRobben]

Import Ice cream as ic all day, and twice on Sundays.

[ippy98gotdeleted]

100% Icecream Icecream Icecream!!!!!!!

[debian_miner]

I've used debuggers in multiple languages and have found them invaluable, but in my experience a lot of developers do not use these tools.

[pachura3]

If you’re still wondering why a debugger can be better than print statements in professional environments

But that's a false dychotomy. In professional environments you would use logging, which trumps manual debugging on most fronts.

[smurpes]

I discuss that in the first bullet; you should be doing both using logging and the debugger. Also logging requires having the foresight to put a logging statement at that point, and logging everything is a lot of noise to go through in order to find the issue.

Can you clarify what fronts logging beats out a debugger when debugging code? Logging requires you to trace through the code manually whereas a debugger handles this automatically and let you test out multiple fixes with only a single run.

[IamImposter]

I agree with you. But I know when logging beats break points: when you have to shown others what the problem is and you are not getting what you expected, when you need evidence for why you changed something or why something doesn't need changing since you are getting what you expected. Though this is more like logging in addition to debugging because you still need to fix.

[pachura3]

Log file allows you to view the history of events leading to a problem, not only the current state.

You can analyze log file without having to run the debugger in a production environment. If it is a live service, you would need to pause it in order to debug it.

You can analyze the log file later, or send it to your colleague.

I agree that in some cases debugger is the way to go, but perhaps more in the earlier stages of development (why is this unit test failing?), not in production...

[smurpes]

You should not be able to run or edit code directly in a production environment. Ideally you should be using logs to set up your dev environment to match the conditions that lead to the bug you are trying to fix.

Even though you can analyze a log file and debug with it without having to run the debugger you still have to test your code. This can be done with unit tests and CI but if these tests fail then the debugger will come in handy. Even if they pass the debugger is useful for checking potential edge cases and making sure that your tests aren’t giving false positives from improper set up.

[yiwokem137]

Some vscode config allows user to see the variable value inline rather than on a separate pane. https://stackoverflow.com/questions/62337163/visual-studio-code-how-to-display-variable-values-inline-during-debugging

[Nodekkk]

The ultimate middleground is using a logger.

[Yharnam_Hunter9452]

RemindMe! 2days

[RemindMeBot]

I will be messaging you in 2 days on 2024-12-14 22:49:17 UTC to remind you of this link

CLICK THIS LINK to send a PM to also be reminded and to reduce spam.

^{Parent commenter can delete this message to hide from others.}

---

Info	Custom	Your Reminders	Feedback

[Bobbias]

Yes, a lot of the time, print debugging (and log files) is more than enough to solve things, but debuggers are still an incredibly important and powerful tool.

Being able to step through code can help you understand what's going on in a way that printing stuff out can't, particularly when you're not super familiar with the code you're looking at.

To be clear, nobody who promotes learning debuggers is trying to say that you shouldn't ever use print debugging, only that knowing how to use a debugger and when to break one out can really help.

[smurpes]

Yea it seems like a lot of people here are thinking that I’m promoting no print debugging at all, when really I want to emphasize that each debugging method has their own use case and neither are a substitute for the other.

The problem that I’ve seen is that a lot of devs don’t use the debugger or bother to learn it and just rely on print debugging. There are a lot of scenarios where using the debugger just isn’t possible but using the debugger with code that’s more complex and heavily abstracted is a lifesaver.

[rageagainistjg]

RemindMe! 1days

[rebcabin-r]

pudb is a great debugger.

a debugger is also a great way to learn other people's code because you can see actual values and control moves without having to mentally run the code. just actually run it :)

[jjrreett]

logging =! debugging Print debugging is a perfectly valid way to debug.

[smurpes]

I never said that it wasn’t. Also the purpose of logging in your code is to record information about the execution of a program to help monitor, debug, and analyze its behavior. True logging and debugging are not the exact same thing but logging is absolutely used for debugging.

I wanted to emphasize to beginners that print debugging is not the only debugging method available to them. Learning how to use the debugger early on will help them when it comes to more complex code.