Best practices for custom exceptions in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of custom exception handling

What will be the output of this Python code that defines and uses a custom exception?

Python

class MyError(Exception):
    pass

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

try:
    test()
except Exception:
    print("General exception caught")

A Caught: Oops

B General exception caught

C No output

D SyntaxError

💡 Hint

Look at which exception is raised and which is caught inside the test function.

The custom exception MyError is raised and caught inside the test function's try-except block, so it prints 'Caught: Oops'. The outer try-except does not run its except block.

🧠 Conceptual

intermediate

Why inherit from Exception for custom exceptions?

Why is it recommended to inherit custom exceptions from the built-in Exception class in Python?

A Because inheriting from Exception allows the custom exception to be caught by standard except blocks.

B Because inheriting from Exception disables the traceback.

C Because inheriting from Exception automatically logs the error.

D Because inheriting from Exception makes the exception a syntax error.

💡 Hint

Think about how Python's try-except blocks catch exceptions.

Inheriting from Exception ensures that the custom exception behaves like standard exceptions and can be caught by except Exception blocks.

❓ Predict Output

advanced

Output of custom exception with additional attributes

What is the output of this code that raises a custom exception with extra data?

Python

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

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

A Error: Invalid input, Code: None

B AttributeError

C Error: ValidationError, Code: 400

D Error: Invalid input, Code: 400

💡 Hint

Check how the message and code are passed and accessed.

The message is passed to the base Exception class and stored as the exception message. The code attribute is stored separately and accessed correctly.

🔧 Debug

advanced

Identify the error in this custom exception definition

What error will this code raise when defining a custom exception?

Python

class MyException:
    def __init__(self, message):
        self.message = message

raise MyException("Error happened")

A NameError

B SyntaxError

C TypeError: exceptions must derive from BaseException

D No error, runs fine

💡 Hint

Check what Python requires for something to be raised as an exception.

Python requires exceptions to inherit from BaseException or its subclasses. This class does not inherit from Exception, so raising it causes a TypeError.

🚀 Application

expert

How many items in the dictionary of custom exceptions?

Given this code, how many keys are in the dictionary 'errors' after execution?

Python

class ErrorA(Exception): pass
class ErrorB(Exception): pass
class ErrorC(ErrorA): pass

errors = {}
for err in [ErrorA, ErrorB, ErrorC]:
    errors[err.__name__] = err

errors['ErrorA'] = 'Custom message'

A 2

B 3

C 1

D 4

💡 Hint

Consider how dictionary keys are assigned and overwritten.

The dictionary initially has 3 keys: 'ErrorA', 'ErrorB', 'ErrorC'. The line errors['ErrorA'] = 'Custom message' replaces the value for 'ErrorA' but does not remove the key. So total keys remain 3.

Practice

1. Why is it a good practice to create custom exceptions in Python?

easy

A. To make error handling clearer and more specific

B. To avoid using try-except blocks

C. To speed up the program execution

D. To replace all built-in exceptions

Solution

1. Step 1: Understand the purpose of custom exceptions

   Custom exceptions help programmers identify and handle specific errors clearly.

2. Step 2: Compare with other options

   Options B, C, and D are incorrect because custom exceptions do not avoid try-except, speed execution, or replace built-ins.

3. Final Answer:

   To make error handling clearer and more specific -> Option A

4. Quick Check:

   Custom exceptions clarify errors = A [OK]

Hint: Custom exceptions clarify specific errors [OK]

Common Mistakes:

• Thinking custom exceptions speed up code
• Believing they replace built-in exceptions
• Assuming they remove need for try-except

2. Which of the following is the correct way to define a custom exception in Python?

easy

A. class MyError(Exception): pass

B. def MyError(): pass

C. class MyError: pass

D. exception MyError(Exception): pass

Solution

1. Step 1: Check Python syntax for custom exceptions

   Custom exceptions must be classes inheriting from Exception or its subclasses.

2. Step 2: Evaluate each option

   A defines a class without inheritance, B defines a function, D uses invalid keyword. Only C ('class MyError(Exception): pass') correctly defines a custom exception.

3. Final Answer:

   class MyError(Exception): pass -> Option A

4. Quick Check:

   Custom exceptions are classes inheriting Exception = C [OK]

Hint: Custom exceptions are classes inheriting Exception [OK]

Common Mistakes:

• Defining exceptions as functions
• Not inheriting from Exception
• Using invalid keywords like 'exception'

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. No output

B. MyError

C. Exception

D. Oops!

Solution

1. Step 1: Understand the raise statement

   The code raises MyError with message 'Oops!'.

2. Step 2: Check the except block output

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

3. Final Answer:

   Oops! -> Option D

4. Quick Check:

   Exception message prints = A [OK]

Hint: Exception message prints when caught and printed [OK]

Common Mistakes:

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

4. Identify the error in this custom exception definition:

class CustomError:
    def __init__(self, message):
        self.message = message

raise CustomError('Error occurred')

medium

A. No __str__ method to display message

B. CustomError does not inherit from Exception

C. Message attribute should be named 'msg'

D. Missing parentheses in raise statement

Solution

1. Step 1: Check inheritance of CustomError

   CustomError does not inherit from Exception, so it is not a proper exception class.

2. Step 2: Analyze other options

   Raise syntax is correct, attribute name is flexible, __str__ is optional but recommended.

3. Final Answer:

   CustomError does not inherit from Exception -> Option B

4. Quick Check:

   Custom exceptions must inherit Exception = D [OK]

Hint: Always inherit Exception for custom exceptions [OK]

Common Mistakes:

• Forgetting to inherit from Exception
• Assuming attribute names must be fixed
• Thinking __str__ is mandatory

5. You want to create a custom exception that stores an error code and a message. Which is the best practice to implement it?

hard

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

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

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

D. class ErrorCodeException(Exception):
pass

Solution

1. Step 1: Check inheritance and initialization

   class ErrorCodeException(Exception): def __init__(self, code, message): super().__init__(message) self.code = code inherits Exception and calls super().__init__(message) to set the message properly.

2. Step 2: Compare with other options

   class ErrorCodeException(Exception): def __init__(self, code, message): self.code = code self.message = message does not call super().__init__, so message may not behave like a normal exception message. class ErrorCodeException: def __init__(self, code, message): self.code = code self.message = message lacks inheritance. class ErrorCodeException(Exception): pass has no code or message storage.

3. Final Answer:

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

4. Quick Check:

   Inherit Exception and call super() with message = B [OK]

Hint: Call super().__init__(message) to set exception message [OK]

Common Mistakes:

• Not calling super().__init__ for message
• Not inheriting from Exception
• Storing message without Exception support