To start debugging code with `pdb`, you need to write some code.
Here's the code you'll be using:
There are several different ways to debug code with `pdb`. Open up the Python REPL / interpreter in the same folder as the code you wish to debug.
Then run the following to run your code in the Python debugger
`pdb` uses many of the same commands as `gdb`, the C++ debugger. If you are familiar with `gdb`, then using `pdb` will be a snap!
In this code, you call `run()` to run your code. Then you type `continue` to continue the run. You can also type `c` as a shortcut for `continue`
When debugging, your code will run until one of the following occurs:
๐ An exception is raised
๐ You hit a breakpoint
๐ The code finishes successfully
You can also run the Python debugger on the command line by using a command like this one:
The output of running the code on the command line is different than running it in the REPL
The prompt, (Pdb) will appear. You will need to issue a command to `continue` or to step through your code
Here is an example console session where you use the `step` or `s` command to step through the code with `pdb`
You can add a breakpoint inside the `pdb` session itself by typing `break` followed by the line number you wish to add the breakpoint to
You can also add a breakpoint directly to your #Python code using `pdb.set_trace()`
Here is an example:
Starting in #Python 3.7, you can use the `breakpoint` keyword instead of `pdb.set_trace()`
If you run this code in PyCharm, VS Code and other popular debuggers, the IDE's debugger will launch instead of `pdb` when it reaches the `breakpoint()`
You can read more about the `breakpoint` keyword in PEP 553
Want to create a copy of a #Python list? Use Python's `copy()` method!
Note: Watch out if your list contains lists of dictionaries. In those cases, you might be better off using copy.deepcopy()
But be careful! If your list contains a mutable object, like another list or a dictionary, you may encounter some unexpected behavior.
In the following example, you `copy()` the list. Then you modify the nested dictionary in the copy, but that also changes the original list!
You can fix this behavior by using Python's `copy` module. It provides a deepcopy() function that you can use which will make a deep copy of the ENTIRE list!