Extending built-in exceptions in Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a new exception class named MyError that inherits from Exception.

Python

class MyError([1]):
    pass

Drag options to blanks, or click blank then click option'

AError

BException

CBaseException

DValueError

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent class name.

Inheriting from a specific error like ValueError instead of Exception.

The new exception class should inherit from Exception to behave like a standard error.

2fill in blank

medium

Complete the code to raise the custom exception MyError with the message 'Oops!'.

Python

raise [1]('Oops!')

Drag options to blanks, or click blank then click option'

AException

BError

CMyError

DValueError

Attempts:

3 left

💡 Hint

Common Mistakes

Raising the base Exception instead of the custom one.

Using a built-in error like ValueError by mistake.

To raise the custom exception, use its class name MyError.

3fill in blank

hard

Fix the error in the custom exception class by correctly calling the base class constructor.

Python

class MyError(Exception):
    def __init__(self, message):
        [1](message)

Drag options to blanks, or click blank then click option'

Asuper().__init__

Bself.__init__

CException.__init__

Dinit

Attempts:

3 left

💡 Hint

Common Mistakes

Calling self.__init__ causes infinite recursion.

Using just init without context.

Use super().__init__(message) to properly call the base class constructor.

4fill in blank

hard

Fill both blanks to add a custom attribute code to the exception and initialize it.

Python

class MyError(Exception):
    def __init__(self, message, [1]):
        super().__init__(message)
        self.[2] = code

Drag options to blanks, or click blank then click option'

Acode

Bmsg

Dmessage

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for parameter and attribute.

Forgetting to assign the attribute.

The constructor takes code as a parameter and assigns it to self.code.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps error codes to messages for errors with code greater than 100.

Python

errors = {
    [1]: [2] for [3] in error_list if [3].code > 100
}

Drag options to blanks, or click blank then click option'

Aerror.code

Berror.message

Cerror

Derr

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable name in the loop.

Swapping keys and values in the dictionary.

The comprehension uses error as the loop variable, maps error.code to error.message for codes above 100.

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