In all programming exercises, it is difficult to go far and deep without a handy debugger. The built-in debugger, In this tutorial you will learn:<\/p>\n Let\u2019s get started.<\/p>\n Python debugging tools This tutorial is in 4 parts, they are<\/p>\n The purpose of a debugger is to provide you a slow motion button to control the flow of a program. It also allow you to freeze the program at certain point of time and examine the state.<\/p>\n The simplest operation under a debugger is to step through<\/strong> the code. That is to run one line of code at a time and wait for your acknowledgment before proceeding into next. The reason we want to run the program in a stop-and-go fashion is to allow us to check the logic and value or verify the algorithm.<\/p>\n For a larger program, we may not want to step through the code from the beginning as it may take a long time before we reached the line that we are interested in. Therefore, debuggers also provide a breakpoint<\/strong> feature that will kick in when a specific line of code is reached. From that point onward, we can step through it line by line.<\/p>\n Let\u2019s see how we can make use of a debugger with an example. The following is the Python code for showing particle swarm optimization<\/a> in an animation:<\/p>\n The particle swarm optimization is done by executing the Assume this program is saved as and the solution will be print out to the screen and the animation will be saved as The At the prompt, you can type in the debugger commands. To show the list of supported commands, we can use At the beginning of a debugger session, we start with the first line of the program. Normally a Python program would start with a few lines of In If the program is long, it is quite boring to use the A command similar to After we set a breakpoint with the Indeed, we can place a breakpoint with a condition, so that it will stop only if the condition is met. The below will impose a condition that the first random number ( Indeed, we can also try to manipulate variables while we are debugging.<\/p>\n In the above, we use If we use a breakpoint and found something unexpected, chances are that it was caused by issues in a different level of the call stack. Debuggers would allow you to navigate to different levels:<\/p>\n In the above, the first The above covers most of the useful commands in the debugger. If we want to terminate the debugger (which also terminates the program), we can use the If you are not very comfortable to run the debugger in command line, you can rely on the debugger from your IDE. Almost always the IDE will provide you some debugging facility. In Visual Studio Code for example, you can launch the debugger in the \u201cRun\u201d menu.<\/p>\n The screen below shows Visual Studio Code at debugging session. The buttons at the center top are correspond to The To demonstrate, let\u2019s consider a GUI application. It will wait until user\u2019s action before the program can end. Hence it is a perfect example to see how we can use Let\u2019s save this program as The final The and it will bring you into the GDB\u2019s prompt:<\/p>\n GDB is supposed to be a debugger for compiled programs (usually from C or C++). The Python extension allows you to check the code (written in Python) being run by the Python interpreter (which is written in C). It is less feature-rich than the Python\u2019s The command supported under GDB are GDB is useful if your Python code uses a library that is compiled from C (such as numpy) and want to investigate how the it runs. It is also useful to learn why your program is frozen by checking the call stack in run time. However, it may be rarely the case that you need to use GDB to debug your machine learning project.<\/p>\n The Python But For GDB with Python extension, it is most mature to be used in Linux environment. Please see the following for more details on its usage:<\/p>\n The command interface of In this tutorial, you discovered the features of Python\u2019s Specifically, you learned:<\/p>\n In the next post, we will see that The post Python debugging tools<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"pdb<\/code>, in Python is a mature and capable one that can help us a lot if you know how to use it. In this tutorial we are going see what the pdb<\/code> can do for you as well as some of its alternative.<\/p>\n\n
![\"\"](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2022\/01\/thomas-park-AF2k44m22-I-unsplash.jpg\")
<\/p>\n
Photo by Thomas Park<\/a>. Some rights reserved.<\/p>\n<\/div>\nTutorial Overview<\/h2>\n
\n
The concept of running a debugger<\/h2>\n
Walk-through of using a debugger<\/h2>\n
import numpy as np\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib.animation import FuncAnimation\r\n\r\ndef f(x,y):\r\n \"Objective function\"\r\n return (x-3.14)**2 + (y-2.72)**2 + np.sin(3*x+1.41) + np.sin(4*y-1.73)\r\n\r\n# Compute and plot the function in 3D within [0,5]x[0,5]\r\nx, y = np.array(np.meshgrid(np.linspace(0,5,100), np.linspace(0,5,100)))\r\nz = f(x, y)\r\n\r\n# Find the global minimum\r\nx_min = x.ravel()[z.argmin()]\r\ny_min = y.ravel()[z.argmin()]\r\n\r\n# Hyper-parameter of the algorithm\r\nc1 = c2 = 0.1\r\nw = 0.8\r\n\r\n# Create particles\r\nn_particles = 20\r\nnp.random.seed(100)\r\nX = np.random.rand(2, n_particles) * 5\r\nV = np.random.randn(2, n_particles) * 0.1\r\n\r\n# Initialize data\r\npbest = X\r\npbest_obj = f(X[0], X[1])\r\ngbest = pbest[:, pbest_obj.argmin()]\r\ngbest_obj = pbest_obj.min()\r\n\r\ndef update():\r\n \"Function to do one iteration of particle swarm optimization\"\r\n global V, X, pbest, pbest_obj, gbest, gbest_obj\r\n # Update params\r\n r1, r2 = np.random.rand(2)\r\n V = w * V + c1*r1*(pbest - X) + c2*r2*(gbest.reshape(-1,1)-X)\r\n X = X + V\r\n obj = f(X[0], X[1])\r\n pbest[:, (pbest_obj >= obj)] = X[:, (pbest_obj >= obj)]\r\n pbest_obj = np.array([pbest_obj, obj]).min(axis=0)\r\n gbest = pbest[:, pbest_obj.argmin()]\r\n gbest_obj = pbest_obj.min()\r\n\r\n# Set up base figure: The contour map\r\nfig, ax = plt.subplots(figsize=(8,6))\r\nfig.set_tight_layout(True)\r\nimg = ax.imshow(z, extent=[0, 5, 0, 5], origin='lower', cmap='viridis', alpha=0.5)\r\nfig.colorbar(img, ax=ax)\r\nax.plot([x_min], [y_min], marker='x', markersize=5, color=\"white\")\r\ncontours = ax.contour(x, y, z, 10, colors='black', alpha=0.4)\r\nax.clabel(contours, inline=True, fontsize=8, fmt=\"%.0f\")\r\npbest_plot = ax.scatter(pbest[0], pbest[1], marker='o', color='black', alpha=0.5)\r\np_plot = ax.scatter(X[0], X[1], marker='o', color='blue', alpha=0.5)\r\np_arrow = ax.quiver(X[0], X[1], V[0], V[1], color='blue', width=0.005, angles='xy', scale_units='xy', scale=1)\r\ngbest_plot = plt.scatter([gbest[0]], [gbest[1]], marker='*', s=100, color='black', alpha=0.4)\r\nax.set_xlim([0,5])\r\nax.set_ylim([0,5])\r\n\r\ndef animate(i):\r\n \"Steps of PSO: algorithm update and show in plot\"\r\n title = 'Iteration {:02d}'.format(i)\r\n # Update params\r\n update()\r\n # Set picture\r\n ax.set_title(title)\r\n pbest_plot.set_offsets(pbest.T)\r\n p_plot.set_offsets(X.T)\r\n p_arrow.set_offsets(X.T)\r\n p_arrow.set_UVC(V[0], V[1])\r\n gbest_plot.set_offsets(gbest.reshape(1,-1))\r\n return ax, pbest_plot, p_plot, p_arrow, gbest_plot\r\n\r\nanim = FuncAnimation(fig, animate, frames=list(range(1,50)), interval=500, blit=False, repeat=True)\r\nanim.save(\"PSO.gif\", dpi=120, writer=\"imagemagick\")\r\n\r\nprint(\"PSO found best solution at f({})={}\".format(gbest, gbest_obj))\r\nprint(\"Global optimal at f({})={}\".format([x_min,y_min], f(x_min,y_min)))<\/pre>\nupdate()<\/code> function a number of times. Each time it runs, we are closer to the optimal solution to the objective function. We are using matplotlib\u2019s FuncAnimation()<\/code> function instead of a loop to run update()<\/code>. So we can capture the position of the particles at each iteration.<\/p>\npso.py<\/code>, to run this program in command line is simply to enter:<\/p>\npython pso.py<\/pre>\n
PSO.gif<\/code>. But if we want to run it with the Python debugger, we enter the following in command line:<\/p>\npython -m pdb pso.py<\/pre>\n
-m pdb<\/code> part is to load the pdb<\/code> module and let the module to execute the file pso.py<\/code> for you. When you run this command, you will be welcomed with the pdb<\/code> prompt as follows:<\/p>\n> \/Users\/mlm\/pso.py(1)<module>()\r\n-> import numpy as np\r\n(Pdb)<\/pre>\n
h<\/code>. And to show the detail of the specific command (such as list<\/code>), we can use h list<\/code>:<\/p>\n> \/Users\/mlm\/pso.py(1)<module>()\r\n-> import numpy as np\r\n(Pdb) h\r\n\r\nDocumented commands (type help <topic>):\r\n========================================\r\nEOF c d h list q rv undisplay\r\na cl debug help ll quit s unt\r\nalias clear disable ignore longlist r source until\r\nargs commands display interact n restart step up\r\nb condition down j next return tbreak w\r\nbreak cont enable jump p retval u whatis\r\nbt continue exit l pp run unalias where\r\n\r\nMiscellaneous help topics:\r\n==========================\r\nexec pdb\r\n\r\n(Pdb)<\/pre>\n
import<\/code>. We can use n<\/code> to move to the next line, or s<\/code> to step into a function:<\/p>\n> \/Users\/mlm\/pso.py(1)<module>()\r\n-> import numpy as np\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(2)<module>()\r\n-> import matplotlib.pyplot as plt\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(3)<module>()\r\n-> from matplotlib.animation import FuncAnimation\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(5)<module>()\r\n-> def f(x,y):\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(10)<module>()\r\n-> x, y = np.array(np.meshgrid(np.linspace(0,5,100), np.linspace(0,5,100)))\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(11)<module>()\r\n-> z = f(x, y)\r\n(Pdb) s\r\n--Call--\r\n> \/Users\/mlm\/pso.py(5)f()\r\n-> def f(x,y):\r\n(Pdb) s\r\n> \/Users\/mlm\/pso.py(7)f()\r\n-> return (x-3.14)**2 + (y-2.72)**2 + np.sin(3*x+1.41) + np.sin(4*y-1.73)\r\n(Pdb) s\r\n--Return--\r\n> \/Users\/mlm\/pso.py(7)f()->array([[17.25... 7.46457344]])\r\n-> return (x-3.14)**2 + (y-2.72)**2 + np.sin(3*x+1.41) + np.sin(4*y-1.73)\r\n(Pdb) s\r\n> \/Users\/mlm\/pso.py(14)<module>()\r\n-> x_min = x.ravel()[z.argmin()]\r\n(Pdb)<\/pre>\n
pdb<\/code>, the line of code will be printed before the prompt. Usually n<\/code> command is what we would prefer as it executes that line of code and moves the flow at the same level<\/strong> without drill down deeper. When we are at a line that calls a function (such as line 11 of the above program, that runs z = f(x, y)<\/code>) we can use s<\/code> to step into<\/strong> the function. In the above example, we first step into f()<\/code> function, then another step to execute the computation, and finally, collect the return value from the function to give it back to the line that invoked the function. We see there are multiple s<\/code> command needed for a function as simple as one line because finding the function from the statement, calling the function, and return each takes one step. We can also see that in the body of the function, we called np.sin()<\/code> like a function but the debugger\u2019s s<\/code> command does not go into it. It is because the np.sin()<\/code> function is not implemented in Python but in C. The pdb<\/code> does not support compiled code.<\/p>\nn<\/code> command many times to move to somewhere we are interested. We can use until<\/code> command with a line number to let the debugger run the program until that line is reached:<\/p>\n> \/Users\/mlm\/pso.py(1)<module>()\r\n-> import numpy as np\r\n(Pdb) until 11\r\n> \/Users\/mlm\/pso.py(11)<module>()\r\n-> z = f(x, y)\r\n(Pdb) s\r\n--Call--\r\n> \/Users\/mlm\/pso.py(5)f()\r\n-> def f(x,y):\r\n(Pdb) s\r\n> \/Users\/mlm\/pso.py(7)f()\r\n-> return (x-3.14)**2 + (y-2.72)**2 + np.sin(3*x+1.41) + np.sin(4*y-1.73)\r\n(Pdb) s\r\n--Return--\r\n> \/Users\/mlm\/pso.py(7)f()->array([[17.25... 7.46457344]])\r\n-> return (x-3.14)**2 + (y-2.72)**2 + np.sin(3*x+1.41) + np.sin(4*y-1.73)\r\n(Pdb) s\r\n> \/Users\/mlm\/pso.py(14)<module>()\r\n-> x_min = x.ravel()[z.argmin()]\r\n(Pdb)<\/pre>\n
until<\/code> is return<\/code>, which will execute the current function until the point that it is about to return. You can consider that as until<\/code> with the line number equal to the last line of the current function. The until<\/code> command is one-off, meaning it will bring you to that line only. If you want to stop at a particular line whenever<\/strong> it is being run, we can make a breakpoint<\/strong>\u00a0on it. For example, if we are interested in how each iteration of the optimization algorithm moves the solution, we can set a breakpoint right after the update is applied:<\/p>\n> \/Users\/mlm\/pso.py(1)<module>()\r\n-> import numpy as np\r\n(Pdb) b 40\r\nBreakpoint 1 at \/Users\/mlm\/pso.py:40\r\n(Pdb) c\r\n> \/Users\/mlm\/pso.py(40)update()\r\n-> obj = f(X[0], X[1])\r\n(Pdb) bt\r\n \/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/bdb.py(580)run()\r\n-> exec(cmd, globals, locals)\r\n <string>(1)<module>()\r\n \/Users\/mlm\/pso.py(76)<module>()\r\n-> anim.save(\"PSO.gif\", dpi=120, writer=\"imagemagick\")\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1078)save()\r\n-> anim._init_draw() # Clear the initial frame\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1698)_init_draw()\r\n-> self._draw_frame(frame_data)\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1720)_draw_frame()\r\n-> self._drawn_artists = self._func(framedata, *self._args)\r\n \/Users\/mlm\/pso.py(65)animate()\r\n-> update()\r\n> \/Users\/mlm\/pso.py(40)update()\r\n-> obj = f(X[0], X[1])\r\n(Pdb) p r1\r\n0.8054505373292797\r\n(Pdb) p r2\r\n0.7543489945823536\r\n(Pdb) p X\r\narray([[2.77550474, 1.60073607, 2.14133019, 4.11466522, 0.2445649 ,\r\n 0.65149396, 3.24520628, 4.08804798, 0.89696478, 2.82703884,\r\n 4.42055413, 1.03681404, 0.95318658, 0.60737118, 1.17702652,\r\n 4.67551174, 3.95781321, 0.95077669, 4.08220292, 1.33330594],\r\n [2.07985611, 4.53702225, 3.81359193, 1.83427181, 0.87867832,\r\n 1.8423856 , 0.11392109, 1.2635162 , 3.84974582, 0.27397365,\r\n 2.86219806, 3.05406841, 0.64253831, 1.85730719, 0.26090638,\r\n 4.28053621, 4.71648133, 0.44101305, 4.14882396, 2.74620598]])\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(41)update()\r\n-> pbest[:, (pbest_obj >= obj)] = X[:, (pbest_obj >= obj)]\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(42)update()\r\n-> pbest_obj = np.array([pbest_obj, obj]).min(axis=0)\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(43)update()\r\n-> gbest = pbest[:, pbest_obj.argmin()]\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(44)update()\r\n-> gbest_obj = pbest_obj.min()\r\n(Pdb)<\/pre>\n
b<\/code> command, we can let the debugger run our program until the breakpoint is hit. The c<\/code> command means to continue<\/strong> until a trigger is met. At any point, we can use bt<\/code> command to show the traceback to check how we reached here. We can also use the p<\/code> command to print the variables (or an expression) to check what value they are holding.<\/p>\nr1<\/code>) is greater than 0.5:<\/p>\n(Pdb) b 40, r1 > 0.5\r\nBreakpoint 1 at \/Users\/mlm\/pso.py:40\r\n(Pdb) c\r\n> \/Users\/mlm\/pso.py(40)update()\r\n-> obj = f(X[0], X[1])\r\n(Pdb) p r1, r2\r\n(0.8054505373292797, 0.7543489945823536)\r\n(Pdb) c\r\n> \/Users\/mlm\/pso.py(40)update()\r\n-> obj = f(X[0], X[1])\r\n(Pdb) p r1, r2\r\n(0.5404045753007164, 0.2967937508800147)\r\n(Pdb)<\/pre>\n
(Pdb) l\r\n 35 \t global V, X, pbest, pbest_obj, gbest, gbest_obj\r\n 36 \t # Update params\r\n 37 \t r1, r2 = np.random.rand(2)\r\n 38 \t V = w * V + c1*r1*(pbest - X) + c2*r2*(gbest.reshape(-1,1)-X)\r\n 39 \t X = X + V\r\n 40 B->\t obj = f(X[0], X[1])\r\n 41 \t pbest[:, (pbest_obj >= obj)] = X[:, (pbest_obj >= obj)]\r\n 42 \t pbest_obj = np.array([pbest_obj, obj]).min(axis=0)\r\n 43 \t gbest = pbest[:, pbest_obj.argmin()]\r\n 44 \t gbest_obj = pbest_obj.min()\r\n 45\r\n(Pdb) p V\r\narray([[ 0.03742722, 0.20930531, 0.06273426, -0.1710678 , 0.33629384,\r\n 0.19506555, -0.10238065, -0.12707257, 0.28042122, -0.03250191,\r\n -0.14004886, 0.13224399, 0.16083673, 0.21198813, 0.17530208,\r\n -0.27665503, -0.15344393, 0.20079061, -0.10057509, 0.09128536],\r\n [-0.05034548, -0.27986224, -0.30725954, 0.11214169, 0.0934514 ,\r\n 0.00335978, 0.20517519, 0.06308483, -0.22007053, 0.26176423,\r\n -0.12617228, -0.05676629, 0.18296986, -0.01669114, 0.18934933,\r\n -0.27623121, -0.32482898, 0.213894 , -0.34427909, -0.12058168]])\r\n(Pdb) p r1, r2\r\n(0.5404045753007164, 0.2967937508800147)\r\n(Pdb) r1 = 0.2\r\n(Pdb) p r1, r2\r\n(0.2, 0.2967937508800147)\r\n(Pdb) j 38\r\n> \/Users\/mlm\/pso.py(38)update()\r\n-> V = w * V + c1*r1*(pbest - X) + c2*r2*(gbest.reshape(-1,1)-X)\r\n(Pdb) n\r\n> \/Users\/mlm\/pso.py(39)update()\r\n-> X = X + V\r\n(Pdb) p V\r\narray([[ 0.02680837, 0.16594979, 0.06350735, -0.15577623, 0.30737655,\r\n 0.19911613, -0.08242418, -0.12513798, 0.24939995, -0.02217463,\r\n -0.13474876, 0.14466204, 0.16661846, 0.21194543, 0.16952298,\r\n -0.24462505, -0.138997 , 0.19377154, -0.10699911, 0.10631063],\r\n [-0.03606147, -0.25128615, -0.26362411, 0.08163408, 0.09842085,\r\n 0.00765688, 0.19771385, 0.06597805, -0.20564599, 0.23113388,\r\n -0.0956787 , -0.07044121, 0.16637064, -0.00639259, 0.18245734,\r\n -0.25698717, -0.30336147, 0.19354112, -0.29904698, -0.08810355]])\r\n(Pdb)<\/pre>\n
l<\/code> command to list the code around the current statement (identified by the arrow -><\/code>). In the listing, we can also see the breakpoint (marked with B<\/code>) is set at line 40. As we can see the current value of V<\/code> and r1<\/code>, we can modify r1<\/code> from 0.54 to 0.2 and run the statement on V<\/code> again by using j<\/code> (jump) to line 38. And as we see after we execute the statement with n<\/code> command, the value of V<\/code> is changed.<\/p>\n(Pdb) bt\r\n \/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/bdb.py(580)run()\r\n-> exec(cmd, globals, locals)\r\n <string>(1)<module>()\r\n \/Users\/mlm\/pso.py(76)<module>()\r\n-> anim.save(\"PSO.gif\", dpi=120, writer=\"imagemagick\")\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1091)save()\r\n-> anim._draw_next_frame(d, blit=False)\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1126)_draw_next_frame()\r\n-> self._draw_frame(framedata)\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1720)_draw_frame()\r\n-> self._drawn_artists = self._func(framedata, *self._args)\r\n \/Users\/mlm\/pso.py(65)animate()\r\n-> update()\r\n> \/Users\/mlm\/pso.py(39)update()\r\n-> X = X + V\r\n(Pdb) up\r\n> \/Users\/mlm\/pso.py(65)animate()\r\n-> update()\r\n(Pdb) bt\r\n \/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/bdb.py(580)run()\r\n-> exec(cmd, globals, locals)\r\n <string>(1)<module>()\r\n \/Users\/mlm\/pso.py(76)<module>()\r\n-> anim.save(\"PSO.gif\", dpi=120, writer=\"imagemagick\")\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1091)save()\r\n-> anim._draw_next_frame(d, blit=False)\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1126)_draw_next_frame()\r\n-> self._draw_frame(framedata)\r\n \/usr\/local\/lib\/python3.9\/site-packages\/matplotlib\/animation.py(1720)_draw_frame()\r\n-> self._drawn_artists = self._func(framedata, *self._args)\r\n> \/Users\/mlm\/pso.py(65)animate()\r\n-> update()\r\n \/Users\/mlm\/pso.py(39)update()\r\n-> X = X + V\r\n(Pdb) l\r\n 60\r\n 61 def animate(i):\r\n 62 \"Steps of PSO: algorithm update and show in plot\"\r\n 63 title = 'Iteration {:02d}'.format(i)\r\n 64 # Update params\r\n 65 -> update()\r\n 66 # Set picture\r\n 67 ax.set_title(title)\r\n 68 pbest_plot.set_offsets(pbest.T)\r\n 69 p_plot.set_offsets(X.T)\r\n 70 p_arrow.set_offsets(X.T)\r\n(Pdb) p title\r\n'Iteration 02'\r\n(Pdb)<\/pre>\nbt<\/code> command gives the call stack when we are at the bottom frame, i.e., the deepest of the call stack. We can see that we are about to execute the statement X = X + V<\/code>. Then the up<\/code> command moves our focus to one level up on the call stack, which is the line running update()<\/code> function (as we see at the line preceded with ><\/code>). Since our focus is changed, the list command l<\/code> will print a different fragment of code and the p<\/code> command can examine a variable in a different scope.<\/p>\nq<\/code> command to quit or hit Ctrl-D if your terminal supports.<\/p>\nDebugger in Visual Studio Code<\/h2>\n
pdb<\/code> commands continue<\/code>, next<\/code>, step<\/code>, return<\/code>, restart<\/code>, and quit<\/code> respectively. A breakpoint can be created by clicking on the line number, which a red dot will be appeared to identify that. The bonus of using an IDE is that the variables are shown immediately at each debugging step. We can also watch for an express and show the call stack. These are at left side of the screen below.<\/p>\n![\"\"](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2022\/01\/VSCode-Debug.png\")
<\/p>\nUsing GDB on a running Python program<\/h2>\n
pdb<\/code> from Python is suitable only for programs running from scratch. If we have a program already running but stuck, we cannot use pdb to hook into<\/strong> it to check what\u2019s going on. The Python extension from GDB, however, can do this.<\/p>\ngdb<\/code> to hook into a running process. The code below is a \u201chello world\u201d program using PyQt5 that just create an empty window and waiting for user to close it:<\/p>\nimport sys\r\nfrom PyQt5.QtWidgets import QApplication, QWidget, QMainWindow\r\n\r\nclass Frame(QMainWindow):\r\n def __init__(self):\r\n super().__init__()\r\n self.initUI()\r\n def initUI(self):\r\n self.setWindowTitle(\"Simple title\")\r\n self.resize(800,600)\r\n\r\ndef main():\r\n app = QApplication(sys.argv)\r\n frame = Frame()\r\n frame.show()\r\n sys.exit(app.exec_())\r\n\r\nif __name__ == '__main__':\r\n main()<\/pre>\n
simpleqt.py<\/code> and run it using the following in Linux under X window environment:<\/p>\npython simpleqt.py &<\/pre>\n
&<\/code> will make it run in background. Now we can check for its process ID using the ps<\/code> command:<\/p>\nps a | grep python<\/pre>\n<\/p>\n
...\r\n 3997 pts\/1 Sl 0:00 python simpleqt.py\r\n...<\/pre>\n
ps<\/code> command will tell you the process ID at the first column. If you have gdb<\/code> installed with python extension, we can run<\/p>\ngdb python 3997<\/pre>\n
GNU gdb (Debian 10.1-1.7) 10.1.90.20210103-git\r\nCopyright (C) 2021 Free Software Foundation, Inc.\r\nLicense GPLv3+: GNU GPL version 3 or later <http:\/\/gnu.org\/licenses\/gpl.html>\r\nThis is free software: you are free to change and redistribute it.\r\nThere is NO WARRANTY, to the extent permitted by law.\r\nType \"show copying\" and \"show warranty\" for details.\r\nThis GDB was configured as \"x86_64-linux-gnu\".\r\nType \"show configuration\" for configuration details.\r\nFor bug reporting instructions, please see:\r\n<https:\/\/www.gnu.org\/software\/gdb\/bugs\/>.\r\nFind the GDB manual and other documentation resources online at:\r\n <http:\/\/www.gnu.org\/software\/gdb\/documentation\/>.\r\n\r\nFor help, type \"help\".\r\nType \"apropos word\" to search for commands related to \"word\"...\r\nReading symbols from python...\r\nReading symbols from \/usr\/lib\/debug\/.build-id\/f9\/02f8a561c3abdb9c8d8c859d4243bd8c3f928f.debug...\r\nAttaching to program: \/usr\/local\/bin\/python, process 3997\r\n[New LWP 3998]\r\n[New LWP 3999]\r\n[New LWP 4001]\r\n[New LWP 4002]\r\n[New LWP 4003]\r\n[New LWP 4004]\r\n[Thread debugging using libthread_db enabled]\r\nUsing host libthread_db library \"\/lib\/x86_64-linux-gnu\/libthread_db.so.1\".\r\n0x00007fb11b1c93ff in __GI___poll (fds=0x7fb110007220, nfds=3, timeout=-1) at ..\/sysdeps\/unix\/sysv\/linux\/poll.c:29\r\n29 ..\/sysdeps\/unix\/sysv\/linux\/poll.c: No such file or directory.\r\n(gdb) py-bt\r\nTraceback (most recent call first):\r\n <built-in method exec_ of QApplication object at remote 0x7fb115f64c10>\r\n File \"\/mnt\/data\/simpleqt.py\", line 16, in main\r\n sys.exit(app.exec_())\r\n File \"\/mnt\/data\/simpleqt.py\", line 19, in <module>\r\n main()\r\n(gdb) py-list\r\n 11 \r\n 12 def main():\r\n 13 app = QApplication(sys.argv)\r\n 14 frame = Frame()\r\n 15 frame.show()\r\n >16 sys.exit(app.exec_())\r\n 17 \r\n 18 if __name__ == '__main__':\r\n 19 main()\r\n(gdb)<\/pre>\n
pdb<\/code> in terms of handling Python code but useful when you want to need to hook into a running process.<\/p>\npy-list<\/code>, py-bt<\/code>, py-up<\/code>, py-down<\/code>, and py-print<\/code>. They are comparable to the same commands in pdb<\/code> without the py-<\/code> prefix.<\/p>\nFurther Readings<\/h2>\n
pdb<\/code> module\u2019s document is at<\/p>\n\n
pdb<\/code> is not the only debugger available. Some third-party tools are listed in:<\/p>\n\n
\n
pdb<\/code> is influenced by that of GDB. Hence we can learn the technique of debugging a program in general from the latter. A good primer on how to use a debugger would be<\/p>\n\n
Summary<\/h2>\n
pdb<\/code><\/p>\n\n
pdb<\/code> do and how to use it<\/li>\npdb<\/code>\n<\/li>\n<\/ul>\npdb<\/code> is also a Python function that can be called inside a Python program.<\/p>\n