Main function

In the previous article, we learned how to perform file operations using Python—laying a solid foundation for our automation scripts. Today, we’ll explore several essential debugging techniques crucial for automation tasks. These techniques will help you identify and fix issues in your code more efficiently, significantly boosting your development productivity. We’ll first introduce commonly used debugging methods in Python, then demonstrate their practical application through concrete examples.

1. Basic Debugging Techniques

1.1 Using print Statements

This is the most fundamental debugging technique. By inserting print statements at key locations in your code, you can output variable values or program states to verify whether execution proceeds as expected.

def add(a, b):
    print(f"Adding {a} and {b}")
    return a + b

result = add(5, 3)
print(f"Result: {result}")

1.2 Using assert Statements

The assert statement tests whether a given condition evaluates to True. If not, it raises an AssertionError. This is especially useful for enforcing critical preconditions.

def divide(a, b):
    assert b != 0, "Divider cannot be zero!"
    return a / b

print(divide(10, 2))  # Works normally
print(divide(10, 0))  # Raises AssertionError

1.3 Using Logging

For more complex applications, the logging module provides a flexible and robust way to manage and record program output—far surpassing simple print statements in capability and configurability.

import logging

logging.basicConfig(level=logging.DEBUG)

def calculate_sum(a, b):
    logging.debug(f"Calculating sum of {a} and {b}")
    return a + b

result = calculate_sum(10, 5)
logging.info(f"The result is: {result}")

2. Using Dedicated Debugging Tools

Python also offers powerful built-in and third-party debugging tools that enable deeper, more systematic inspection of program behavior.

2.1 Using the pdb Module

pdb is Python’s built-in interactive debugger, allowing line-by-line execution and inspection directly from the command line.

import pdb

def faulty_function():
    a = 1
    b = 2
    pdb.set_trace()  # Sets a breakpoint here
    c = a + b
    return c

faulty_function()

At runtime, execution pauses when reaching pdb.set_trace(). You can then interactively inspect variables, step through code, evaluate expressions, and more—all within the Python interpreter.

2.2 Using IDE Debugging Features

Modern IDEs—such as PyCharm and VS Code—provide rich, visual debugging interfaces. You can set breakpoints, inspect variable values in real time, step over or into functions, and even modify variables on-the-fly—greatly simplifying the debugging process.

3. Case Study: Debugging an Automation Script

Next, we’ll demonstrate these debugging techniques using a simple file-processing automation script. Suppose we need to read data from one file, transform it, and write the result to another file.

3.1 The Automation Script

def read_file(file_path):
    with open(file_path, 'r') as f:
        data = f.readlines()
    return data

def process_data(data):
    return [line.strip().upper() for line in data]

def write_file(file_path, data):
    with open(file_path, 'w') as f:
        f.writelines(data)

# Main function
if __name__ == "__main__":
    input_file = 'input.txt'
    output_file = 'output.txt'

    data = read_file(input_file)
    processed_data = process_data(data)
    write_file(output_file, processed_data)

3.2 Applying Debugging Techniques

1. Use print statements to verify data transformation:
   Add print statements inside process_data() to confirm that input data is being read and transformed correctly:

   def process_data(data):
       print(f"Original data: {data}")
       processed = [line.strip().upper() for line in data]
       print(f"Processed data: {processed}")
       return processed
   

2. Use assert to validate data integrity:
   Add an assertion in read_file() to ensure the file isn’t empty:

   def read_file(file_path):
       with open(file_path, 'r') as f:
           data = f.readlines()
       assert data, "The file is empty!"
       return data
   

3. Use logging to record execution flow:
   Add structured log messages throughout the workflow for traceability and post-execution analysis:

   import logging
   logging.basicConfig(level=logging.INFO)
   
   # ... Insert logging calls in relevant places ...
   logging.info("Reading file...")
   

These debugging techniques collectively empower you to rapidly detect, isolate, and resolve issues—especially valuable when tackling large-scale or mission-critical automation tasks.

Conclusion

Mastering debugging techniques is indispensable when building Python-based automation solutions. In this article, we covered core approaches—including print-based inspection, assert-driven validation, structured logging, and interactive debugging with pdb. Together, these tools equip you to diagnose problems accurately and iterate confidently during development.

In the next article, we’ll explore web automation using Selenium. Before diving in, make sure you’re comfortable applying these debugging techniques—they’ll prove invaluable when working with more complex, real-world automation scenarios.