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.

Practice

1. What is the correct way to create a custom exception class in Python?

easy

A. exception MyError(Exception): pass

B. def MyError(): raise Exception

C. class MyError(Exception): pass

D. class MyError: pass

Solution

1. Step 1: Understand how to define a class inheriting Exception

   Custom exceptions must inherit from the built-in Exception class to behave like errors.

2. Step 2: Check syntax correctness

   class MyError(Exception): pass correctly defines a class named MyError inheriting from Exception with pass inside.

3. Final Answer:

   class MyError(Exception): pass -> Option C

4. Quick Check:

   Custom exception class = class MyError(Exception): pass [OK]

Hint: Inherit from Exception to create custom errors [OK]

Common Mistakes:

• Not inheriting from Exception
• Using def instead of class
• Wrong keyword like 'exception' instead of 'class'

2. Which of the following is the correct syntax to raise a custom exception named MyError?

easy

A. raise MyError()

B. throw MyError()

C. raise new MyError()

D. throw new MyError()

Solution

1. Step 1: Recall the Python keyword to raise exceptions

   Python uses the keyword 'raise' to trigger exceptions, not 'throw'.

2. Step 2: Check the syntax for raising a custom exception

   Correct syntax is 'raise MyError()' to create and raise the exception instance.

3. Final Answer:

   raise MyError() -> Option A

4. Quick Check:

   Raise custom error = raise MyError() [OK]

Hint: Use 'raise' keyword followed by exception instance [OK]

Common Mistakes:

• Using 'throw' instead of 'raise'
• Adding 'new' keyword like in other languages
• Not calling the exception as a function

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. Oops!

B. MyError

C. Exception

D. No output

Solution

1. Step 1: Understand the raise statement with message

   The code raises MyError with the message 'Oops!'.

2. Step 2: Catch the exception and print its message

   The except block catches MyError as 'e' and prints 'e', which outputs the message 'Oops!'.

3. Final Answer:

   Oops! -> Option A

4. Quick Check:

   Exception message prints = Oops! [OK]

Hint: Exception instance prints its message string [OK]

Common Mistakes:

• Printing exception class name instead of message
• Not catching the exception properly
• Expecting no output

4. Identify the error in this code snippet:

class MyError(Exception):
    pass

try:
    raise MyError
except MyError:
    print("Caught error")

medium

A. Incorrect exception name in except block

B. No error, code runs fine

C. Syntax error in class definition

D. Missing parentheses when raising MyError

Solution

1. Step 1: Check how the exception is raised

   In Python, it is valid to raise an exception class without parentheses if it has no __init__ arguments.

2. Step 2: Identify the problem in the code

   The code uses 'raise MyError' without parentheses, which is valid and does not raise an error.

3. Final Answer:

   No error, code runs fine -> Option B

4. Quick Check:

   Raising exception class without parentheses is allowed [OK]

Hint: Raising exception class without parentheses is valid if no arguments [OK]

Common Mistakes:

• Omitting parentheses after exception name
• Mismatching exception names in except block
• Incorrect class syntax

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):
self.code = 0
super().__init__(message)

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)

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

Solution

1. Step 1: Understand how to extend Exception with extra attributes

   To add an error code, override __init__ and call super().__init__(message) to set the message properly.

2. Step 2: Check which option correctly calls super().__init__ and stores code

   class ValidationError(Exception): def __init__(self, message, code): super().__init__(message) self.code = code calls super().__init__(message) and assigns self.code = code, correctly storing both.

3. Final Answer:

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

4. Quick Check:

   Call super().__init__(message) and store extra attributes [OK]

Hint: Call super().__init__(message) to set message, then add code [OK]

Common Mistakes:

• Not calling super().__init__ for message
• Assigning message without super call
• Missing code attribute assignment