Extending built-in exceptions in Python

Introduction

Sometimes, you want to create your own error messages that fit your program better. Extending built-in exceptions helps you make custom errors that act like normal errors but with your own touch.

When you want to give clearer error messages for your program's special rules.

When you want to catch specific problems in your code and handle them differently.

When you build a library or tool and want users to understand what went wrong easily.

When you want to add extra information to an error to help debugging.

When you want your error to behave like a normal error but with a custom name.

Syntax

Python

class MyError(Exception):
    pass

You create a new error by making a class that uses a built-in error like Exception as a base.

The pass means the new error works just like the base error without extra changes.

Examples

This creates a simple custom error that acts like a normal exception.

Python

class MyError(Exception):
    pass

This custom error stores a message and a code to give more details about the problem.

Python

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

This shows how to raise and catch the custom error, then print its message and code.

Python

try:
    raise ValidationError('Invalid input', 400)
except ValidationError as e:
    print(f'Error: {e}, Code: {e.code}')

Sample Program

This program defines a custom error called MyError. It raises this error with a message, then catches it and prints the message.

Python

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

try:
    raise MyError('Something went wrong!')
except MyError as e:
    print(f'Caught an error: {e.message}')

Important Notes

Always inherit from Exception or its subclasses to make your custom errors work well with Python's error system.

You can add extra information or methods to your custom error to help explain the problem better.

Use custom errors to make your code easier to understand and debug.

Summary

Custom errors help you make your program's problems clearer.

Extend built-in exceptions by creating a new class that inherits from them.

You can add extra details to your errors to help with debugging and handling.

Practice

1. What is the main reason to extend built-in exceptions in Python?

easy

A. To create custom error types that describe specific problems clearly

B. To make the program run faster

C. To avoid using try-except blocks

D. To automatically fix errors when they occur

Solution

1. Step 1: Understand the purpose of exceptions

   Exceptions help signal errors or unusual situations in a program.

2. Step 2: Why extend built-in exceptions?

   Extending allows creating specific error types that explain problems clearly and help debugging.

3. Final Answer:

   To create custom error types that describe specific problems clearly -> Option A

4. Quick Check:

   Custom exceptions = clearer error messages [OK]

Hint: Custom exceptions clarify errors, not speed or auto-fix [OK]

Common Mistakes:

• Thinking extending exceptions speeds up code
• Believing exceptions fix errors automatically
• Confusing exceptions with avoiding try-except

2. Which of the following is the correct way to define a custom exception named MyError that extends ValueError?

easy

A. def MyError(ValueError): pass

B. class MyError(ValueError): pass

C. class MyError: ValueError

D. exception MyError(ValueError): pass

Solution

1. Step 1: Recognize class syntax for exceptions

   Custom exceptions are classes that inherit from built-in exceptions.

2. Step 2: Check correct Python class definition

   Use class MyError(ValueError): pass to extend ValueError properly.

3. Final Answer:

   class MyError(ValueError): pass -> Option B

4. Quick Check:

   Use class + inheritance syntax for exceptions [OK]

Hint: Use class keyword and inherit from built-in exception [OK]

Common Mistakes:

• Using def instead of class
• Wrong inheritance syntax
• Using 'exception' keyword which doesn't exist

3. What will be the output of this code?

class MyError(Exception):
    pass

try:
    raise MyError('Oops!')
except MyError as e:
    print(e)

medium

A. MyError

B. Exception

C. Oops!

D. No output

Solution

1. Step 1: Understand raising and catching custom exception

   The code raises MyError with message 'Oops!'.

2. Step 2: What does print(e) show?

   Printing the exception variable e shows the message passed during raise.

3. Final Answer:

   Oops! -> Option C

4. Quick Check:

   Exception message prints when caught and printed [OK]

Hint: Print exception object to see its message [OK]

Common Mistakes:

• Printing exception class name instead of message
• Expecting no output because of exception
• Confusing exception type with message

4. Identify the error in this custom exception definition:

class CustomError(Exception):
    def __init__(self, message):
        print(message)

medium

A. Exception cannot be extended

B. Class name should be lowercase

C. print() cannot be used in __init__

D. Missing call to super().__init__(message) in __init__

Solution

1. Step 1: Check __init__ method in custom exception

   Custom exceptions should call the parent Exception __init__ to set the message properly.

2. Step 2: Why call super().__init__(message)?

   This ensures the message is stored and accessible like normal exceptions.

3. Final Answer:

   Missing call to super().__init__(message) in __init__ -> Option D

4. Quick Check:

   Always call super().__init__ in custom exception init [OK]

Hint: Call super().__init__ to set message in custom exceptions [OK]

Common Mistakes:

• Forgetting super().__init__ call
• Thinking print replaces message storage
• Believing class names must be lowercase

5. You want to create a custom exception ValidationError that stores an error code along with the message. Which code correctly implements this?

hard

A. class ValidationError(Exception):
def __init__(self, message, code):
super().__init__(message)
self.code = code

B. class ValidationError(Exception):
def __init__(self, message, code):
self.message = message
self.code = code

C. class ValidationError(Exception):
def __init__(self, code):
super().__init__(code)
self.message = ''

D. class ValidationError(Exception):
def __init__(self, message):
super().__init__(message)
self.code = None

Solution

1. Step 1: Understand storing extra info in custom exceptions

   We want to keep both message and code, so __init__ must accept both.

2. Step 2: Properly call super().__init__ with message and store code

   class ValidationError(Exception): def __init__(self, message, code): super().__init__(message) self.code = code calls super().__init__(message) to set message and saves code as attribute.

3. Final Answer:

   class ValidationError(Exception): def __init__(self, message, code): super().__init__(message) self.code = code -> Option A

4. Quick Check:

   Call super with message, store extra attributes separately [OK]

Hint: Call super with message, save extra data as attributes [OK]

Common Mistakes:

• Not calling super().__init__ with message
• Not storing extra info as attributes
• Mixing message and code parameters