Question

Exception objects and lists. Change the oops function you just wrote to raise an exception you define yourself, called MyError. Identify your exception with a class (unless you're using Python \(2.5\) or earlier, you must). Then, extend the try statement in the catcher function to catch this exception and its instance in addition to IndexError, and print the instance you catch.

Short answer

Define `MyError`, raise it in `oops`, and catch it in `catcher` alongside `IndexError`.

Step-by-step solution

Define Custom Exception

Create a custom exception class named `MyError`. This class should inherit from the base `Exception` class.

Modify the oops Function

Change the `oops` function to raise an instance of your newly defined `MyError` exception.

Catch the Custom Exception

Update the `catcher` function to include a `try` block that calls the `oops` function and catches both `IndexError` and `MyError` exceptions.

Print the Caught Exception

Within the `except` block of the `catcher` function, print the instance of the caught exception.

Verify Your Solution

Run the `catcher` function to ensure it correctly catches and handles the custom `MyError` exception, as well as `IndexError` exceptions.

Key concepts

Custom Exceptions

In Python, you're not limited to pre-built exceptions. You can define your own custom exceptions which help make your code more readable and expressive. A custom exception is simply a new class that derives from the built-in `Exception` class.
Here’s how you can define a custom exception class named `MyError`:
```python
class MyError(Exception):
pass
```
Now, `MyError` acts like a typical exception in Python, but with a custom name. You can customize it further by adding methods or initializing it with specific attributes.

Try-Except Block

A `try-except` block in Python allows you to handle exceptions gracefully. This structure helps you manage errors without stopping the execution of your program.
Here's a basic example of a `try-except` block:
```python
try:
# Code that might raise an exception
except SomeException as e:
# Code that runs if there is an exception
print(e)
```
Extending this example to catch our custom exception `MyError`, as well as a common `IndexError`, can be done as follows:
```python
try:
oops()
except IndexError as e:
print(f'Caught an IndexError: {e}')
except MyError as e:
print(f'Caught MyError: {e}')
```

Error Handling

Error handling is essential to make your programs robust and user-friendly. It involves anticipating potential problems and managing them gracefully without crashing.
To efficiently handle errors in Python, you should:

• Define custom exceptions that make your errors more descriptive.
• Use `try-except` blocks to catch and manage exceptions without stopping program execution.
• Always provide useful messages when catching exceptions to help with debugging and user understanding.

In our example, the `catcher` function should call the `oops` function and use `try-except` to handle both `IndexError` and `MyError`.
By doing these steps, you ensure that your program continues running smoothly and that it handles unexpected situations with clarity and robustness.