Exception Handling

Exception Handling is a crucial programming construct used to manage runtime errors, also known as exceptions, that occur during the execution of a program. Instead of letting the program crash when an unexpected event happens (like trying to divide by zero, accessing a non-existent file, or receiving invalid user input), exception handling allows developers to gracefully respond to these situations, maintain program flow, and provide informative feedback to the user or system.

Key Concepts:

1. Exceptions: These are events that disrupt the normal flow of a program. They are objects that inherit from a base `Exception` class in many programming languages. Examples include `ValueError`, `TypeError`, `FileNotFoundError`, `ZeroDivisionError`, etc.

2. `try` block: This block contains the code that is susceptible to raising an exception. The program attempts to execute the code within this block.

3. `except` block: If an exception occurs within the `try` block, the program's control jumps to the corresponding `except` block. This block contains the code to handle the specific exception (or all exceptions if not specified). You can have multiple `except` blocks to handle different types of exceptions.

4. `else` block (optional): This block is executed if the code inside the `try` block runs completely without raising any exceptions. It's useful for code that should only run if the `try` block was successful.

5. `finally` block (optional): This block always executes, regardless of whether an exception occurred in the `try` block, was caught by an `except` block, or if the `try` block completed successfully. It's typically used for cleanup operations, such as closing files, releasing resources, or network connections, ensuring these actions happen even in error scenarios.

6. `raise` statement: This statement is used to explicitly trigger an exception. Developers can raise built-in exceptions or define and raise custom exceptions to signal specific error conditions in their code.

Why is it important?

- Robustness: Prevents programs from crashing unexpectedly, leading to more stable applications.
- User Experience: Allows programs to provide meaningful error messages to users instead of cryptic system errors.
- Code Clarity: Separates error-handling logic from the main business logic, making the code easier to read and maintain.
- Resource Management: Ensures that critical resources (like file handles or network connections) are properly closed or released, even when errors occur.
- Debugging: Helps in identifying and resolving issues by providing clear indications of what went wrong.

python
def divide_numbers(numerator_str, denominator_str):
    """
    Attempts to divide two numbers provided as strings.
    Demonstrates try-except-else-finally for exception handling.
    """
    try:
         Attempt to convert strings to numbers
        numerator = float(numerator_str)
        denominator = float(denominator_str)

         Attempt to perform division
        result = numerator / denominator

    except ValueError:
         Handle cases where input strings cannot be converted to float
        print(f"Error: Invalid input. Please enter valid numbers. Got '{numerator_str}', '{denominator_str}'")
        return None
    except ZeroDivisionError:
         Handle division by zero
        print("Error: Cannot divide by zero.")
        return None
    except Exception as e:
         Catch any other unexpected exceptions
        print(f"An unexpected error occurred: {e}")
        return None
    else:
         This block executes if no exception occurred in the 'try' block
        print(f"Division successful! Result: {result}")
        return result
    finally:
         This block always executes, regardless of whether an exception occurred or was handled.
        print("--- Operation attempt finished ---")

 --- Example Usage ---

print("\n--- Valid Division --- ")
divide_numbers("10", "2")

print("\n--- Division by Zero --- ")
divide_numbers("10", "0")

print("\n--- Invalid Input (non-numeric) --- ")
divide_numbers("abc", "5")

print("\n--- Another Valid Division --- ")
divide_numbers("15.5", "2.5")

 Example of raising a custom exception (optional, for advanced understanding)
class MyCustomError(Exception):
    """A custom exception for demonstration."""
    pass

def process_data(data):
    if not isinstance(data, dict):
        raise TypeError("Data must be a dictionary.")
    if "key" not in data:
        raise MyCustomError("Missing 'key' in data.")
    return f"Processing data with key: {data['key']}"

print("\n--- Raising Exceptions --- ")
try:
    print(process_data("not_a_dict"))
except TypeError as e:
    print(f"Caught: {e}")

try:
    print(process_data({"value": 123}))
except MyCustomError as e:
    print(f"Caught: {e}")

try:
    print(process_data({"key": "some_value"}))
except (TypeError, MyCustomError) as e:
    print(f"Caught: {e}")