Why custom exceptions are needed in Python - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why create custom exceptions?

Why do programmers create custom exceptions instead of using only built-in exceptions?

A To provide more specific error messages that match the program's unique needs.

B Because built-in exceptions cannot be caught by try-except blocks.

C To make the program run faster by avoiding built-in exceptions.

D To automatically fix errors without user intervention.

💡 Hint

Think about how specific error messages help understand problems better.

Custom exceptions help programmers signal specific problems that built-in exceptions don't cover. This makes debugging and handling errors clearer and easier.

❓ Predict Output

intermediate

Output of custom exception handling

What will be the output of this code?

Python

class MyError(Exception):
    pass

try:
    raise MyError('Oops!')
except MyError as e:
    print(f'Caught custom error: {e}')
except Exception:
    print('Caught general error')

A SyntaxError

B Caught general error

C No output

D Caught custom error: Oops!

💡 Hint

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

The code raises a custom exception MyError, which is caught by the except MyError block, printing the message with the error text.

❓ Predict Output

advanced

Handling multiple custom exceptions

What will be printed when this code runs?

Python

class ErrorA(Exception):
    pass

class ErrorB(Exception):
    pass

def test_error(e):
    try:
        raise e
    except ErrorA:
        print('Caught ErrorA')
    except ErrorB:
        print('Caught ErrorB')
    except Exception:
        print('Caught general exception')

test_error(ErrorB('error'))

A Caught general exception

B Caught ErrorB

C Caught ErrorA

D No output

💡 Hint

Check which exception is raised and which except block matches it first.

The function raises ErrorB, which is caught by the except ErrorB block, printing 'Caught ErrorB'.

🧠 Conceptual

advanced

Why not use only built-in exceptions?

Which of these is NOT a good reason to create custom exceptions?

A To confuse other programmers by adding unnecessary complexity.

B To make error handling more precise and meaningful.

C To clearly separate different error types in your program.

D To provide better messages for specific error cases.

💡 Hint

Think about the purpose of custom exceptions in teamwork and code clarity.

Custom exceptions are meant to improve clarity and error handling, not to confuse or complicate code unnecessarily.

❓ Predict Output

expert

Output with inheritance in custom exceptions

What is the output of this code?

Python

class BaseError(Exception):
    pass

class ChildError(BaseError):
    pass

try:
    raise ChildError('child error occurred')
except BaseError as e:
    print(f'Caught base error: {e}')
except ChildError:
    print('Caught child error')

A Caught child error

B No output

C Caught base error: child error occurred

D TypeError

💡 Hint

Remember that except blocks are checked in order and inheritance matters.

The ChildError is a subclass of BaseError. The first except block matches it and prints the message.

Practice

1. Why do programmers create custom exceptions instead of using only built-in exceptions?

easy

A. To clearly identify and handle specific errors unique to their program

B. Because built-in exceptions are slower to execute

C. To avoid writing any error handling code

D. Because Python does not have any built-in exceptions

Solution

1. Step 1: Understand the purpose of exceptions

   Exceptions help handle errors during program execution. Built-in exceptions cover common errors.

2. Step 2: Recognize the need for custom exceptions

   Custom exceptions let programmers mark and handle errors specific to their program clearly and separately.

3. Final Answer:

   To clearly identify and handle specific errors unique to their program -> Option A

4. Quick Check:

   Custom exceptions = specific error handling [OK]

Hint: Custom exceptions clarify unique errors in your code [OK]

Common Mistakes:

• Thinking built-in exceptions are slow
• Believing custom exceptions remove need for error handling
• Assuming Python lacks built-in exceptions

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

easy

A. def MyError(): pass

B. class MyError(Exception): pass

C. class MyError: pass

D. exception MyError(Exception): pass

Solution

1. Step 1: Recall syntax for custom exceptions

   Custom exceptions are classes that inherit from Exception or its subclasses.

2. Step 2: Identify correct class definition

   class MyError(Exception): pass correctly defines MyError as a subclass of Exception with pass to keep it simple.

3. Final Answer:

   class MyError(Exception): pass -> Option B

4. Quick Check:

   Custom exception = class inheriting Exception [OK]

Hint: Custom exceptions are classes inheriting Exception [OK]

Common Mistakes:

• Defining exception as a function
• Not inheriting from Exception
• Using wrong keyword like 'exception'

3. What will be the output of this code?

class MyError(Exception):
    pass

def test(value):
    if value < 0:
        raise MyError("Negative value")
    return value

try:
    print(test(-1))
except MyError as e:
    print(e)

medium

A. Negative value

B. -1

C. None

D. No output

Solution

1. Step 1: Analyze function behavior

   The function test raises MyError with message "Negative value" if input is less than 0.

2. Step 2: Trace try-except block

   Calling test(-1) raises MyError. The except block catches it and prints the error message.

3. Final Answer:

   Negative value -> Option A

4. Quick Check:

   Raised custom exception message printed [OK]

Hint: Raised custom exception prints its message in except block [OK]

Common Mistakes:

• Expecting function to return -1
• Thinking no output occurs
• Confusing exception name with message

4. Find the error in this custom exception usage:

class MyError(Exception):
    pass

try:
    raise MyError("Oops")
except Exception as e:
    print("Error:", e.message)

medium

A. Custom exception must not inherit Exception

B. except block should catch MyError, not Exception

C. raise keyword is missing

D. Using e.message to get error text causes AttributeError

Solution

1. Step 1: Check exception message access

   In Python, exception objects do not have a message attribute by default.

2. Step 2: Identify correct way to get message

   The message is accessed by converting the exception to string or using args. Using e.message causes an AttributeError.

3. Final Answer:

   Using e.message to get error text causes AttributeError -> Option D

4. Quick Check:

   Exception message accessed via str(e), not e.message [OK]

Hint: Use str(e) to get exception message, not e.message [OK]

Common Mistakes:

• Assuming e.message exists
• Thinking custom exceptions can't inherit Exception
• Missing raise keyword
• Believing except must catch only MyError

5. You want to create a custom exception InvalidAgeError that triggers when age is below 0 or above 120. Which approach best uses custom exceptions to handle this validation?

hard

A. Print error message instead of raising exceptions

B. Use only built-in ValueError without custom exceptions

C. Define InvalidAgeError inheriting Exception, raise it in a function checking age limits

D. Catch all exceptions with a generic except block without custom exceptions

Solution

1. Step 1: Understand validation needs

   Age must be checked for invalid values and a clear error raised if invalid.

2. Step 2: Use custom exception for clarity

   Defining InvalidAgeError inheriting from Exception and raising it on invalid age clearly signals this specific error.

3. Step 3: Compare other options

   Using only built-in exceptions or printing errors reduces clarity and control. Catching all exceptions generically hides specific issues.

4. Final Answer:

   Define InvalidAgeError inheriting Exception, raise it in a function checking age limits -> Option C

5. Quick Check:

   Custom exception for specific validation error [OK]

Hint: Raise custom exceptions for clear, specific validation errors [OK]

Common Mistakes:

• Relying only on built-in exceptions
• Printing errors instead of raising
• Using generic except blocks hiding issues