100. pdb Debugging

Here are examples and explanations of how to use Python's built-in pdb debugger for step-by-step debugging:

---

1. Starting the Debugger

import pdb

def add_numbers(a, b):
    pdb.set_trace()  # Start debugger here
    result = a + b
    return result

add_numbers(5, 10)

How to Debug:

1. Run the script in the terminal.

2. The debugger will stop at pdb.set_trace().

3. Commands like n (next), c (continue), and q (quit) help navigate.

---

2. Debugging from the Command Line

def multiply_numbers(a, b):
    result = a * b
    return result

if __name__ == "__main__":
    import pdb
    pdb.run('multiply_numbers(4, 5)')

Command Line Debugging:

• Run the script, and you'll enter the debugger for the multiply_numbers(4, 5) function.

---

3. Using Breakpoints

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

if __name__ == "__main__":
    import pdb
    pdb.set_trace()  # Start debugging here
    result = factorial(5)
    print(result)

Key Commands:

• Use break <line_number> to set a breakpoint.

• Use list to view the code around the current line.

• Use continue to run until the next breakpoint.

---

4. Inspecting Variables

def divide_numbers(a, b):
    result = a / b
    return result

if __name__ == "__main__":
    import pdb
    pdb.set_trace()
    x = 10
    y = 2
    divide_numbers(x, y)

Inspecting:

• Use p x or p y to print variable values.

• Use whatis x to check the type of a variable.

---

5. Using break Command

def process_data(data):
    for i, value in enumerate(data):
        print(f"Processing {value}")

if __name__ == "__main__":
    import pdb
    pdb.set_trace()
    process_data([10, 20, 30])

Setting Breakpoints:

• Inside the debugger, type break 2 (line 2 of process_data) to stop the program at that line.

---

6. Using Conditional Breakpoints

def check_numbers(numbers):
    for num in numbers:
        if num > 10:
            print(f"{num} is large")

if __name__ == "__main__":
    import pdb
    pdb.set_trace()
    check_numbers([5, 15, 25])

Conditional Breakpoints:

• Inside the debugger, type break 5, num > 10 to stop only when the condition is true.

---

7. Stepping Through Code

def calculate_area(length, width):
    return length * width

if __name__ == "__main__":
    import pdb
    pdb.set_trace()
    area = calculate_area(5, 3)
    print(f"Area: {area}")

Commands:

• n: Execute the next line without diving into functions.

• s: Step into a function call.

---

8. Post-Mortem Debugging

def faulty_function(a, b):
    return a / b

if __name__ == "__main__":
    import pdb
    try:
        faulty_function(10, 0)
    except ZeroDivisionError:
        pdb.post_mortem()

Post-Mortem Debugging:

• The debugger starts after an exception, allowing you to inspect the code state where the error occurred.

---

9. Printing Call Stack

def func1():
    func2()

def func2():
    func3()

def func3():
    import pdb
    pdb.set_trace()
    print("In func3")

func1()

Command:

• Use where or bt to view the call stack and see how you reached the current point.

---

10. Exiting the Debugger

def main():
    import pdb
    pdb.set_trace()
    print("Debugging started")
    print("Exiting program")

main()

Exit Commands:

• Use q to quit the debugger.

• Use c to continue execution until the end of the program.

---

These examples showcase how to leverage pdb for precise and interactive debugging in Python programs.