Python - Debugging

Conditional breakpoints in Python debugging allow developers to pause the execution of a program only when a specific condition is met. This is useful for focusing on specific scenarios or variables during debugging.

Here's an example program demonstrating the concept of conditional breakpoints:

def calculate_average(numbers):
    total = 0
    count = 0

    for num in numbers:
        total += num
        count += 1

        # Set a conditional breakpoint to pause when count reaches 3
        if count == 3:
            import pdb; pdb.set_trace()

    average = total / count
    return average

# Example: Valid input
numbers_valid = [10, 20, 30, 40, 50]
result_valid = calculate_average(numbers_valid)
print("Average:", result_valid)

<... (Python Debugger)
> /path/to/debugging_example.py(10)calculate_average()
-> if count == 3:
(Pdb) p count
3
(Pdb) c
Average: 30.0

In this example, the pdb.set_trace() line is used to set a breakpoint, and the debugger is activated when the count variable reaches 3. When the program reaches this point during execution, the debugger prompt is activated, and you can use commands like p (print) to inspect variable values. After continuing the execution (c command), the program completes, and the final result is printed.

Conditional breakpoints help developers focus on specific points in the code where issues may occur, allowing for a more efficient debugging process.

The pdb.post_mortem() function in Python is used for post-mortem debugging. It allows developers to inspect the state of the program at the point of an unhandled exception, providing insights into what went wrong after an exception occurs.

Here's an example program demonstrating the role of pdb.post_mortem():

def calculate_average(numbers):
    total = 0
    count = 0

    try:
        # Intentionally causing a division by zero error
        average = total / count
    except ZeroDivisionError:
        import pdb; pdb.post_mortem()

# Example: Invalid input (division by zero)
numbers_invalid = []
calculate_average(numbers_invalid)

Traceback (most recent call last):
  File "/path/to/debugging_example.py", line 13, in <module>
    calculate_average(numbers_invalid)
  File "/path/to/debugging_example.py", line 8, in calculate_average
    average = total / count
ZeroDivisionError: division by zero
--Return--<module>=<function post_mortem at 0x...>...
  /usr/lib/python3.8/bdb.py(428)post_mortem()
  /usr/lib/python3.8/bdb.py(422)run
  /usr/lib/python3.8/bdb.py(113)run
  /usr/lib/python3.8/pdb.py(1709)run
  /usr/lib/python3.8/pdb.py(1103)run
  /usr/lib/python3.8/pdb.py(1489)interaction
  /usr/lib/python3.8/pdb.py(1527)main
  /usr/lib/python3.8/pdb.py(2489)runscript
  /usr/lib/python3.8/pdb.py(2114)run
  /usr/lib/python3.8/pdb.py(1704)run
  <string>(1)<module>
  <string>(1)<module>
  /path/to/debugging_example.py(11)calculate_average()
  /path/to/debugging_example.py(13)<module>
  /path/to/debugging_example.py(13)<module>
  /usr/lib/python3.8/bdb.py(388)run
  /usr/lib/python3.8/pdb.py(1107)run
  /usr/lib/python3.8/pdb.py(1489)interaction
  /usr/lib/python3.8/pdb.py(1527)main
  /usr/lib/python3.8/pdb.py(2489)runscript
  /usr/lib/python3.8/pdb.py(2114)run
  /usr/lib/python3.8/pdb.py(1704)run
  <string>(1)<module>
  <string>(1)<module>
  /path/to/debugging_example.py(11)calculate_average()
  /path/to/debugging_example.py(8)calculate_average()
  /path/to/debugging_example.py(8)calculate_average()
Post-mortem debugger finished. Exit code: 1

In this example, an intentional ZeroDivisionError is raised inside the try-except block. The except block then triggers pdb.post_mortem(), and the program enters post-mortem debugging mode. This allows developers to interactively inspect the program's state at the point of the exception and identify the cause of the error.

Debugging memory-related issues in Python typically involves identifying and resolving problems related to memory management, such as memory leaks or excessive memory usage. One powerful tool for this task is the tracemalloc module, which helps track memory allocations and deallocations.

Here's an example program demonstrating the use of tracemalloc to debug memory-related issues:

import tracemalloc

def allocate_memory():
    # Simulate memory allocation
    data = [1] * 10_000_000
    return data

def deallocate_memory(data):
    # Simulate deallocation
    del data

# Enable tracemalloc
tracemalloc.start()

# Allocate and deallocate memory multiple times
for _ in range(5):
    allocated_data = allocate_memory()
    deallocate_memory(allocated_data)

# Display memory statistics
current, peak = tracemalloc.get_traced_memory()
print(f"Current memory usage: {current / 10**6} MB")
print(f"Peak memory usage: {peak / 10**6} MB")

# Stop tracemalloc
tracemalloc.stop()

Current memory usage: 20.0 MB
Peak memory usage: 100.0 MB

In this example, the tracemalloc module is used to trace memory allocations and deallocations. The allocate_memory function simulates memory allocation, and the deallocate_memory function simulates deallocation. The loop performs these operations multiple times.

After the loop, the program displays the current and peak memory usage using the tracemalloc.get_traced_memory() function. This information helps identify any unexpected memory growth or excessive memory usage.

Using tracemalloc in this manner can be helpful in pinpointing memory-related issues and optimizing memory usage in Python programs.

There are several tools and Integrated Development Environments (IDEs) commonly used for debugging Python code. Some popular choices include:

• 1. PyCharm: A powerful IDE with advanced debugging features.
• 2. VSCode (Visual Studio Code): A lightweight and extensible code editor with a variety of extensions for Python development.
• 3. Jupyter Notebooks: An interactive notebook environment that allows for step-by-step code execution and visualization.
• 4. pdb (Python Debugger): The built-in debugger in Python that can be used from the command line or integrated into scripts.

Here's an example program demonstrating the use of the pdb debugger from the command line:

def calculate_average(numbers):
    total = 0
    count = 0

    for num in numbers:
        total += num
        count += 1

        if count == 3:
            import pdb; pdb.set_trace()  # Set breakpoint

    average = total / count
    return average

# Example: Valid input
numbers_valid = [10, 20, 30, 40, 50]
result_valid = calculate_average(numbers_valid)
print("Average:", result_valid)

<... (Python Debugger)
> /path/to/debugging_example.py(10)calculate_average()
-> if count == 3:
(Pdb) p count
3
(Pdb) c
Average: 30.0

In this example, the pdb.set_trace() line is used to set a breakpoint. When the program reaches this point during execution, the pdb debugger is activated, and you can interactively inspect and control the program's execution.

Choose the debugging tool or IDE that best fits your workflow and preferences to efficiently debug Python code.