Objective

In this unit, you'll learn about the basics of debugging and error handling in Python. You'll explore different techniques to identify and fix errors in your code and understand how to handle exceptions gracefully.

Errors and Debugging

Debugging is the process of identifying and fixing errors in a program. Errors in Python can be broadly classified into two categories:

  • Syntax Errors: These are errors that occur when the code is not written according to the rules of the Python language. For example, forgetting a colon at the end of an if statement.

  • Runtime Errors: These are errors that occur while the program is running. They can be due to logical mistakes in the code or unexpected input.

Basic Debugging Techniques

Some common techniques to debug Python code include:

  • Print Statements: Using print() to display the values of variables at different points in the code.
  • Using a Debugger: Tools like the Python Debugger (PDB) allow you to step through the code, inspect variables, and understand the flow of execution.
  • Reading Error Messages: Python provides detailed error messages that can help pinpoint the location and cause of an error.

Debugging Python Code with VS Code

Visual Studio Code (VS Code) provides a powerful and user-friendly way to find and fix issues in your Python code. By setting breakpoints and stepping through code, you can understand how your code is executing and where problems might be occurring.

Here's a step-by-step guide to get started with the VS Code debugger:

Step 1: Install the Python Extension (if you didn't already do so in Unit 1)

  1. Open VS Code.
  2. Go to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window.
  3. Search for "Python" in the Extensions view search box.
  4. Click on the "Install" button next to the Python extension provided by Microsoft.

Step 2: Open Your Python File

  1. Open the folder containing your Python file by going to File > Open Folder....
  2. Open the Python file you want to debug by clicking on it in the Explorer.

Step 3: Configure the Debugger

  1. Click on the Run icon in the Activity Bar to switch to the Run view.
  2. Click on "create a launch.json file" link or click on the gear icon in the Run view.
  3. Select "Python File" from the dropdown. This will create a launch.json file with the default configuration for debugging Python files.
  4. You can modify this file if needed, but the default settings should work for most Python files.

Step 4: Set Breakpoints

  1. Click on the left margin next to the line numbers in your Python file where you want to set a breakpoint. A red dot will appear, indicating a breakpoint.
  2. You can set multiple breakpoints if needed.

Step 5: Start Debugging

  1. Click on the green "Start Debugging" button in the Run view, or press F5.
  2. The debugger will start, and your code will run until it hits one of your breakpoints.
  3. You can then inspect variables, step through code, and use other debugging features.

Step 6: Use Debugging Features

  • Inspect Variables: Use the VARIABLES section in the Run view to inspect the values of variables.
  • Step Through Code: Use the toolbar at the top of the window to step into, over, or out of code.
  • Evaluate Expressions: Use the Debug Console to evaluate expressions in the context of the debug session.
  • Continue Execution: Press F5 or click the "Continue" button in the toolbar to continue execution until the next breakpoint or the end of the program.

Step 7: Stop Debugging

  • Click the "Stop" button in the toolbar, or close the debug session to stop debugging.

Example

Consider the following Python code:

def add(x, y):
    return x + y

def main():
    a = 5
    b = 10
    result = add(a, b)
    print(f"The result is {result}")

if __name__ == "__main__":
    main()

You can set a breakpoint inside the add function or inside the main function to inspect the values of a, b, and result.

Errors and Exceptions

An exception is an event that occurs during the execution of a program that disrupts the normal flow of the program's instructions. In Python, exceptions are triggered automatically on errors, and they can also be triggered and intercepted by your code.

Common errors and exceptions include:

SyntaxError

Occurs when there's an error in the syntax of the code. For example:

if x = 5:  # Should be '=='
    print("x is 5")

TypeError

Occurs when an operation or function is applied to an object of an inappropriate type. For example:

"5" + 5  # Cannot add string and integer

ValueError

Occurs when a built-in operation or function receives an argument with the right type but an inappropriate value. For example:

int("five")  # Cannot convert to integer

ZeroDivisionError

Occurs when you try to divide by zero. For example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

FileNotFoundError

Occurs when trying to open a file that does not exist. For example:

with open("nonexistent_file.txt") as file:
    content = file.read()

Raising Exceptions

You can use the raise statement to trigger an exception in your code. This can be useful to signal that an error has occurred.

Example of Raising an Exception

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    print(f"Age: {age}")

try:
    validate_age(-5)
except ValueError as e:
    print(e)

Custom Exceptions

You can define custom exceptions to represent specific error conditions in your code. Custom exceptions are created by defining a new class that inherits from the built-in Exception class.

Example of a Custom Exception

class NegativeAgeError(Exception):
    pass

def validate_age(age):
    if age < 0:
        raise NegativeAgeError("Age cannot be negative")
    print(f"Age: {age}")

try:
    validate_age(-5)
except NegativeAgeError as e:
    print(e)

Error Handling with try, except, else, finally

Python provides a way to handle exceptions using the try, except, else, and finally statements.

  • try: You write the code that might cause an exception inside the try block.
  • except: If an exception occurs in the try block, the code inside the except block is executed.
  • else: If no exception occurs, the code inside the else block is executed.
  • finally: This block is always executed, whether an exception occurred or not.

Example of Error Handling

try:
    result = 10 / 2
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print("Division successful!")
finally:
    print("Always executed!")

Project: Add Error Checking to Your Turtle Program

In this project, you'll enhance your turtle drawing program by adding error checking to handle potential issues like invalid shapes or out-of-bounds coordinates.

import turtle

# Define a custom exception
class InvalidShapeError(Exception):
    pass

# Prompt the user for the number of sides and check
# that the value is a valid number greater than or equal to 3
def get_num_sides():
    sides = input("Enter the number of sides for the shape: ")

    try:
        sides = int(sides)
    except ValueError:
        print("Please enter a valid number.")
        return get_num_sides()
    
    try:
        if sides < 3:
            raise InvalidShapeError("A shape must have at least 3 sides.")
    except InvalidShapeError as e:
        print(e)
        return get_num_sides()
    
    return sides

def draw_shape(t, sides):
    angle = 360 / sides
    for _ in range(sides):
        t.forward(100)
        t.left(angle)

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.bgcolor("white")

# Initialize a turtle object
t = turtle.Turtle()
t.hideturtle()

# Get the number of sides from the user
num_sides = get_num_sides()

# Draw the shape
draw_shape(t, num_sides)

# Wait until the window is closed
turtle.done()

In this code, we've added error checking to ensure that the user enters a valid number of sides for the shape, and that the number of sides is at least 3. If the user enters an invalid value, a helpful error message is printed.

Play with this example to make sure you have a solid understanding of how to identify and fix errors in your code and how to handle exceptions gracefully.

In the next unit, we'll explore writing code to test our main program to ensure it is functioning as expected.