Extending built-in exceptions in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of custom exception with additional attribute

What is the output of this code when the exception is caught and printed?

Python

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

try:
    raise MyError("Oops!", 404)
except MyError as e:
    print(f"Error: {e}, Code: {e.code}")

A Error: Oops!, Code: e.code

B Error: MyError('Oops!'), Code: 404

C Error: Oops!, Code: None

D Error: Oops!, Code: 404

💡 Hint

Look at how the message and code are passed and accessed in the exception.

The custom exception stores the message in the base Exception class and the code in a new attribute. Printing the exception object shows the message, and accessing e.code gives 404.

❓ Predict Output

intermediate

Output of overridden __str__ in custom exception

What will be printed when this code runs?

Python

class CustomError(Exception):
    def __init__(self, message, severity):
        super().__init__(message)
        self.severity = severity
    def __str__(self):
        return f"{self.args[0]} (Severity: {self.severity})"

try:
    raise CustomError("Failed operation", "High")
except CustomError as e:
    print(e)

A Failed operation (Severity: severity)

B Failed operation (Severity: High)

C Failed operation

D CustomError('Failed operation', 'High')

💡 Hint

The __str__ method controls how the exception is printed.

The __str__ method returns a formatted string combining the message and severity, so printing the exception shows that string.

🔧 Debug

advanced

Identify the error in custom exception initialization

This code tries to create a custom exception but raises an error. What is the cause?

Python

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

try:
    raise BadError("Error happened", 500)
except BadError as e:
    print(e)

A AttributeError because 'code' is missing

B SyntaxError due to missing colon

C TypeError because Exception __init__ is not called

D No error, prints 'Error happened'

💡 Hint

Check if the base Exception class is properly initialized.

The custom exception does not call super().__init__(message), so the base Exception is not initialized, causing a TypeError when printing.

📝 Syntax

advanced

Syntax error in custom exception definition

Which option contains a syntax error in defining a custom exception?

A

class MyException(Exception)
    def __init__(self, msg):
        super().__init__(msg)

B

class MyException(Exception):
    def __init__(self, msg):
        super().__init__(msg)
    def __str__(self):
        return self.args[0]

C

class MyException(Exception):
    pass

D

class MyException(Exception):
    def __init__(self, msg):
        super().__init__(msg)

💡 Hint

Check the class definition syntax carefully.

Option A is missing a colon ':' after the class declaration, causing a SyntaxError.

🚀 Application

expert

Determine the output of nested custom exceptions

What is the output of this code snippet?

Python

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

class DerivedError(BaseError):
    def __init__(self, message, code):
        super().__init__(message)
        self.code = code

try:
    try:
        raise DerivedError("Failure", 123)
    except DerivedError as e:
        raise BaseError(f"Wrapped: {e}") from e
except BaseError as e:
    print(e)
    print(type(e.__cause__))

A

Wrapped: Failure
<class '__main__.DerivedError'>

B

Wrapped: Failure
<class '__main__.BaseError'>

C

Failure
<class '__main__.BaseError'>

D

Failure
<class '__main__.DerivedError'>

💡 Hint

Look at how exception chaining with 'from' works and what __cause__ stores.

The outer exception message is 'Wrapped: Failure'. The __cause__ attribute points to the original DerivedError instance, so its type is DerivedError.

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