Debugging is a critical skill in software development, vital for uncovering and resolving errors and inefficiencies in code. Effective debugging can significantly improve the reliability and performance of software. In this lesson, we'll explore several foundational debugging techniques used in Python programming, each illustrated with detailed examples.

Using the Print Statements

The simplest and often the quickest way to debug is by inserting print() statements in the code to display the current state or values of variables at different points in execution.

Example

In this example, we use print() statements to track the maximum value found in a list of numbers.

Explanation:

• max_number = numbers[0]: Initializes max_number with the first element of the list.
• for number in numbers: Iterates through each number in the list.
• if number > max_number: Checks if the current number is greater than the current max_number.
• print(f"New max found: {max_number}"): Prints a debug message each time a new maximum is found.
• return max_number: Returns the maximum number found.

Using Assertions

Assertions are a debugging aid that checks a condition as a sanity check during program execution. An AssertionError is raised if the assertion fails.

Example

In this example, we use an assertion to ensure that both numbers added in a function are positive.

Explanation:

• assert a > 0 and b > 0: The assert statement checks that both a and b are positive.
• "Both numbers must be positive": This message is displayed if the assertion fails.
• return a + b: Returns the sum if the assertion passes.
• The try-except block attempts to execute the function and catches any AssertionError that occurs, printing an informative message.

Logging

Logging is a versatile tool for tracking events that occur during software execution. It can record various levels of information (like debug, info, warning, error, critical) which helps in understanding the program's behavior over time, without stopping the program.

Example

In this example, we configure basic logging and use it to track the flow and results of a multiplication function.

Explanation:

• logging.basicConfig(...): Configures how logging messages should be formatted and at what level messages should be logged.
• logging.debug(...): Logs a debug message before multiplying the numbers.
• result = x * y: Performs the multiplication.
• logging.info(...): Logs an informational message with the result of the multiplication.

Using Python Debuggers (pdb)

The Python debugger (pdb) is an interactive debugging environment for Python programs. It allows you to execute your code step-by-step, inspect variables, set breakpoints, and evaluate expressions dynamically. This capability makes it an invaluable tool for more intricate debugging scenarios where static code analysis is insufficient.

Example

In this example, we will demonstrate how to use pdb to step through a simple function that calculates the sum of numbers up to a given number.

Explanation:

• import pdb: Imports the Python debugger module.
• total = 0: Initializes total to zero, which will store the sum of numbers.
• for i in range(1, n + 1): Loops through numbers from 1 to n.
• total += i: Adds the current number i to the total.
• pdb.set_trace(): This line introduces a breakpoint. When Python execution reaches this point, it will pause and open the interactive debugging session.
• return total: Returns the computed sum after the loop completes.

How to Use pdb in the Interactive Session

• When execution pauses at pdb.set_trace(), the interactive debugger session starts in the terminal or console.
• Inside the debugger, you can use various commands to inspect and manipulate the execution:
  • c: Continue execution until the next breakpoint.
  • n: Step to the next line within the same function.
  • l: List source code for the current file.
  • p: Print the value of an expression.
  • q: Quit the debugger and abort the program.

These commands allow you to interactively explore how changes to the code affect execution, which can provide insights that are not easily obtainable through static code analysis alone.

The Python debugger (pdb) provides a powerful suite of tools for deep interactive debugging. By enabling developers to pause execution, inspect program state, and perform line-by-line evaluation, pdb helps uncover subtle bugs that might be difficult to detect using more traditional debugging methods. Effective use of debugging tools like pdb, combined with logging, assertions, and print statements, forms a comprehensive approach to diagnosing and fixing problems in Python applications, leading to more robust and error-free code.