Creating exception classes in Python - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of custom exception handling

What is the output of this code when the function is called?

Python

class MyError(Exception):
    pass

def test():
    try:
        raise MyError("Oops")
    except MyError as e:
        print(f"Caught: {e}")
    except Exception:
        print("General error")

test()

A SyntaxError

B General error

C No output

D Caught: Oops

💡 Hint

Look at which exception is raised and which except block catches it.

The code raises MyError with message 'Oops'. The except block for MyError catches it and prints 'Caught: Oops'.

❓ Predict Output

intermediate

Output when subclass exception is raised

What will be printed when this code runs?

Python

class BaseError(Exception):
    pass

class SubError(BaseError):
    pass

try:
    raise SubError("Error happened")
except BaseError as e:
    print(f"Handled: {e}")

A Unhandled exception error

B Handled: Error happened

C Handled: SubError

D SyntaxError

💡 Hint

Remember subclass exceptions are caught by base class except blocks.

SubError is a subclass of BaseError, so the except BaseError block catches it and prints the message.

❓ Predict Output

advanced

Output of exception with custom __str__ method

What is the output of this code?

Python

class CustomError(Exception):
    def __init__(self, code):
        self.code = code
    def __str__(self):
        return f"Error code: {self.code}"

try:
    raise CustomError(404)
except CustomError as e:
    print(e)

A Error code: 404

B CustomError object at <memory_address>

C 404

D TypeError

💡 Hint

The __str__ method controls the string shown when printing the exception.

The __str__ method returns 'Error code: 404', so print(e) outputs that string.

❓ Predict Output

advanced

Exception chaining output

What will this code print?

Python

class FirstError(Exception):
    pass

class SecondError(Exception):
    pass

try:
    try:
        raise FirstError("First")
    except FirstError as e:
        raise SecondError("Second") from e
except SecondError as e:
    print(f"Caught: {e}")
    print(f"Cause: {e.__cause__}")

A

Caught: Second
Cause: FirstError('First')

B

Caught: Second
Cause: None

C

Caught: Second
Cause: First

D AttributeError

💡 Hint

The 'from' keyword sets the __cause__ attribute to the original exception.

The SecondError is raised from FirstError, so __cause__ holds the FirstError instance. Printing it shows 'First'.

🧠 Conceptual

expert

Correct way to create a custom exception with additional data

Which option correctly defines a custom exception class that stores an error code and message, and allows access to both after catching?

A

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

B

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

C

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

D

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

💡 Hint

Remember to call the base Exception __init__ with the message for proper behavior.

Option A calls super().__init__(msg) to set the message properly and stores code separately. Others either don't call base __init__ correctly or store message in a non-standard attribute.