Exceptions

3 options:

1. assert

2. raise

3. try/except block

Try/Except block:

If you handle exceptions within except blocks, the program will not end. The exception will be handled, and program execution will continue. Unless you put a raise statement in the except block.

Python will match exceptions in the order they're listed by type in the try/except block.

try:
    # Code that may raise an exception
    # ...
except ExceptionType1:
    # Code to handle ExceptionType1
    # ...
except ExceptionType2:
    # Code to handle ExceptionType2
    # ...
except ExceptionType3 as e:
    # How to catch an exception, add a message to it,
    # and throw it again.
    raise ExceptionType3(f"Message about {some_variable}") from e
except (ExceptionType4, ExceptionType5, ExceptionType6):
    # How to catch multiple exceptions and apply
    # the same logic for all of them.
except Exception as e:
    # Catches any exception type that is derived from the
    # `Exception` base class.
except:
    # Catch-all - handles any exception type.
    # It will handle any exceptions leftover after
    # other except blocks. Must go at the end,
    # otherwise all exception types would trigger
    # this block first.
    # ...
else:
    # Code to run if no exception occurs
    # ...
finally:
    # Code that always runs, regardless of whether an exception occurred or not
    # ...

Commonly used built-in exception types in Python:

• Exception: The base class for all built-in exceptions.

• TypeError: Raised when an operation or function is applied to an object of inappropriate type.

• ValueError: Raised when a function receives an argument of the correct type but an invalid value.

• NameError: Raised when a local or global name is not found.

• IndexError: Raised when a sequence subscript is out of range.

• KeyError: Raised when a dictionary key is not found.

• FileNotFoundError: Raised when a file or directory is requested but cannot be found.

• IOError: Raised when an I/O operation (such as reading or writing a file) fails.

• ZeroDivisionError: Raised when a division or modulo operation is performed with a divisor of zero.

• AttributeError: Raised when an attribute reference or assignment fails.

• ImportError: Raised when an import statement fails to find a module.

• NotImplementedError: Raised by abstract methods that should be overridden in subclasses.

• OverflowError: Raised when the result of an arithmetic operation is too large to be expressed in the available numeric type.

• SyntaxError: Raised when there is a syntax error in the code.

• IndentationError: Raised when there is an incorrect indentation in the code.

From Bard:

Here's a guide to when to use assert, raise, and try in Python:

Assert:

• Purpose: To verify internal program logic and assumptions during development and testing.

• Behavior: If the assertion fails, an AssertionError is raised, typically halting execution.

• Use cases:

  • Checking preconditions for functions and methods.

  • Validating data invariants within functions and classes.

  • Ensuring expected states during testing.

• Example:

Python

def calculate_area(width, height):
    assert width > 0 and height > 0, "Dimensions must be positive"
    return width * height

Use code with caution. Learn more

Raise:

• Purpose: To signal explicit errors or exceptional situations that require handling.

• Behavior: Raises a specified exception, which can be caught using try-except blocks.

• Use cases:

  • Custom errors for specific failure conditions.

  • Signaling errors from external sources (e.g., file I/O, network operations).

  • Re-raising caught exceptions for further handling.

• Example:

Python

class InvalidInputError(Exception):
    pass

def divide(x, y):
    if y == 0:
        raise InvalidInputError("Cannot divide by zero")
    return x / y

Use code with caution. Learn more

Try:

• Purpose: To handle potential exceptions and control program flow when errors occur.

• Behavior: Executes code within the try block, catching specified exceptions in except blocks.

• Use cases:

  • Preventing program crashes from unexpected errors.

  • Implementing alternative actions or error recovery.

  • Cleaning up resources (e.g., closing files) even when errors occur.

• Example:

Python

try:
    with open("data.txt", "r") as file:
        data = file.read()
except FileNotFoundError:
    print("File not found")

Use code with caution. Learn more

Key Considerations:

• Assertions: Primarily for debugging and testing, not for runtime error handling.

• Raising Exceptions: Used to signal errors that need to be addressed.

• Try-Except: Catches and handles exceptions for controlled error management.

Choose the appropriate construct based on your specific needs for debugging, error signaling, or error handling in different scenarios.