? Python Error Handling

⚡ Quick Overview

Error handling in Python is a way to gracefully manage exceptions (errors) that occur during program execution so that your program does not crash unexpectedly. Instead of stopping the program, you can catch errors, show user-friendly messages, and optionally recover from the problem.

? Key Concepts

• Exception: An error that occurs during program execution (e.g., dividing by zero, invalid input).
• try block: Wraps code that may raise an exception.
• except block: Handles the exception if it occurs.
• Multiple except: Different handlers for different error types.
• else block: Runs only if no exception occurs in the try block.
• finally block: Always runs (used for cleanup like closing files).
• raise: Manually trigger an exception when a condition is not met.

? Syntax and Theory

The general structure of error handling in Python uses try, except, else, and finally blocks:

try:
    # code that might raise an exception
    risky_operation()
except SpecificErrorType:
    # handle a specific error
    handle_error()
except AnotherErrorType:
    # handle another error
    handle_another_error()
else:
    # runs only if no exception was raised
    run_if_no_error()
finally:
    # always runs (cleanup)
    cleanup()

? Code Examples

⚠️ Basic try and except

Use try to wrap code that may raise an exception and except to handle it.

try:
    # attempt a division operation
    x = 10 / 0
except ZeroDivisionError:
    # handle division by zero gracefully
    print("Cannot divide by zero!")

? Handling Multiple Exceptions

You can catch multiple types of errors in separate except blocks.

try:
    # convert string to integer
    num = int("abc")
    # perform division with the converted number
    result = 10 / num
except ValueError:
    # handle invalid integer conversion
    print("Invalid conversion to integer")
except ZeroDivisionError:
    # handle division by zero
    print("Division by zero error")

? Generic Exception Handling

Catch any exception using except Exception as e and get the error message. Use this carefully, because it can hide specific bugs if overused.

try:
    # code that may raise any kind of exception
    x = 10 / 0
except Exception as e:
    # catch all exceptions and print the message
    print("Error occurred:", e)

? Using else and finally

else runs if no exception occurs; finally always runs, whether an error occurred or not.

try:
    # try to divide two numbers
    num = 10 / 2
except ZeroDivisionError:
    # handle division by zero
    print("Error!")
else:
    # runs only if no exception occurred
    print("Division successful")
finally:
    # code that always runs
    print("This always runs")

? Raising Exceptions Manually

You can raise exceptions manually using raise when a condition is not satisfied.

def check_age(age):
    # validate that age meets minimum requirement
    if age < 18:
        # raise an error if age is too low
        raise ValueError("Age must be 18 or older")
    # return True when age is valid
    return True

try:
    # call the validation function with an invalid age
    check_age(15)
except ValueError as e:
    # handle the validation error
    print("Error:", e)

? Live Output and Explanation

? Common Error Types

• ZeroDivisionError: Division by zero.
• ValueError: Invalid value for conversion or operation.
• TypeError: Invalid operation between incompatible data types.
• FileNotFoundError: File you are trying to access does not exist.
• IndexError: Accessing a list/tuple index that does not exist.
• KeyError: Accessing a dictionary key that does not exist.

? Use Cases and When to Use

• Validating user input (e.g., converting strings to numbers safely).
• Working with files that may or may not exist.
• Handling network errors (timeouts, connection issues).
• Protecting critical sections of code from unexpected crashes.
• Enforcing business rules using custom exceptions.