Exception Handling in Python

Exception handling is a mechanism in Python to handle runtime errors, so the program can continue executing or fail gracefully. Python uses a set of keywords and constructs to manage exceptions, allowing you to write robust and error-resistant code.

8.1 The `try`, `except`, `finally` Block

Python uses the `try`, `except`, and `finally` blocks to handle exceptions. The `try` block contains code that may raise an exception, the `except` block handles the exception, and the `finally` block contains code that runs regardless of whether an exception occurred.

# Example of try, except, and finally in Python

try:
    # Code that may cause an exception
    result = 10 / 0
except ZeroDivisionError:
    # Code that runs if an exception occurs
    print("Cannot divide by zero!")
finally:
    # Code that runs no matter what
    print("Execution completed.")

In this example, the division by zero raises a ZeroDivisionError, which is handled in the except block. The finally block executes regardless of whether an exception occurred.

8.2 Raising Exceptions

You can use the raise keyword to trigger exceptions manually. This can be useful for enforcing certain conditions in your code or indicating that an error has occurred.

# Example of raising an exception in Python

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

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

In this example, the validate_age function raises a ValueError if the age is negative. This exception is caught and handled in the except block.

8.3 Common Exceptions

Python has several built-in exceptions that cover common error scenarios. Here are a few of them:

• ZeroDivisionError: Raised when dividing by zero.
• FileNotFoundError: Raised when attempting to open a file that does not exist.
• IndexError: Raised when accessing an index that is out of range in a list or tuple.
• KeyError: Raised when accessing a dictionary with a key that does not exist.
• TypeError: Raised when an operation or function is applied to an object of inappropriate type.

8.4 Custom Exceptions

You can define your own exceptions by creating a new exception class that inherits from the built-in Exception class. Custom exceptions allow you to represent specific error conditions in your application.

# Example of a custom exception in Python

class CustomError(Exception):
    def __init__(self, message):
        super().__init__(message)
        self.message = message

try:
    raise CustomError("This is a custom error.")
except CustomError as e:
    print(e.message)

In this example, CustomError is a custom exception class. When it is raised, the exception is caught and its message is printed.

8.5 Best Practices for Exception Handling

Here are some best practices for handling exceptions effectively:

• Catch Specific Exceptions: Handle specific exceptions rather than using a generic except block. This makes it easier to identify and fix issues.
• Use the `finally` Block Wisely: Use the finally block for cleanup actions that must occur regardless of whether an exception is raised.
• Avoid Empty `except` Blocks: Avoid using empty except blocks as they can hide bugs and make debugging difficult.
• Log Exceptions: Consider logging exceptions for future reference and debugging purposes.
• Raise Exceptions with Informative Messages: When raising exceptions, provide a clear and informative error message to help with troubleshooting.