Artificial Intelligence Course for Beginners in Alabang, Muntinlupa

1. Introduction: Why Good Code Still Breaks

No matter how carefully or thoroughly you write your Python code, real-world execution introduces factors that developers cannot fully predict. Most notably, user inputs or unexpected runtime conditions can break your code.

When an unexpected error occurs, Python stops program execution and displays an error message. Python halts because it does not know what impact that specific error will have downstream. Allowing faulty data or an erroneous input to propagate into subsequent operations can cause severe system malfunctions or security risks. Therefore, Python’s default safeguard is to terminate execution immediately and crash the program.

However, minor errors occur naturally during routine use. Modern programming languages—including Python—provide mechanisms to intercept these issues, handle them smoothly, and allow the application to continue running without crashing.

2. What Is an Exception?

An exception is a runtime event or error that disrupts the normal flow of an application’s instructions.

• The mechanism: When an unhandled error arises, Python generates a specific error keyword or exception type.
• The consequence of neglecting errors: If your application does not catch and handle that error keyword, Python halts execution.
• Real-world impact: An application that crashes unexpectedly leaves a poor impression on users or clients. For example, if a user downloads an app from an app store and it crashes upon first launch, most users immediately uninstall it. Robust software proactively anticipates potential points of failure and incorporates error handling to keep the user experience stable.

3. Three Common Exception Scenarios in Python

Python alerts developers to different types of errors by raising specific built-in exception keywords.

Scenario 1: Mathematical Errors (ZeroDivisionError)

In mathematics, division by zero is undefined. If a user input or calculation results in dividing any number by zero, Python halts execution and raises a ZeroDivisionError:

# Unhandled division by zero causes a crash
numerator = 10
denominator = 0  # e.g., received from user input

result = numerator / denominator  # Raises ZeroDivisionError!

If you anticipate this calculation error and handle the ZeroDivisionError keyword in code, Python will execute your precautionary steps instead of crashing.

Scenario 2: Missing Storage Files (FileNotFoundError)

When working with external files on a disk, a script may attempt to open a file that does not exist or has been moved to another path.

# Opening a non-existent file causes a crash
with open("student_records.txt", "r") as file:
    data = file.read()  # Raises FileNotFoundError if missing!

Python cannot guess how to proceed without the file, so it raises FileNotFoundError. By catching and handling this keyword, your program can handle the missing file gracefully—such as logging a clean notification or automatically creating the file—without terminating abruptly.

Scenario 3: Invalid Input Types and Values (ValueError)

When an application prompts a user for numeric information (such as age) and the user supplies an invalid string or negative value, standard operations fail:

# If the user enters "twenty" instead of 20:
user_input = "twenty"
age = int(user_input)  # Raises ValueError!

Because the text "twenty" cannot be converted into an integer, Python raises a ValueError. Catching ValueError allows the program to prompt the user again or supply a default value rather than crashing.

4. The Core Philosophy of Exception Handling

The central concept behind exception handling is communication between your program and the Python interpreter:

1. You identify operations where unexpected inputs or environment errors could reasonably happen.
2. You inform Python: "We anticipate that this error may occur, and we have written instructions to handle it".
3. When Python encounters the anticipated exception, it delegates execution to your handling logic rather than terminating the program.