Extending built-in exceptions in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of extending built-in exceptions in Python?

Extending built-in exceptions allows you to create custom error types that behave like standard errors but can carry specific information or handle special cases in your program.

beginner

How do you define a custom exception by extending a built-in exception?

You create a new class that inherits from a built-in exception class like Exception or ValueError, for example: <pre>class MyError(Exception):
    pass</pre>

intermediate

Why might you want to add an __init__ method to your custom exception?

Adding an __init__ method lets you store extra information about the error, like a message or error code, which can be accessed when handling the exception.

intermediate

What does the following code do?<br><pre>class MyError(Exception):
    def __init__(self, message, code):
        super().__init__(message)
        self.code = code</pre>

It defines a custom exception MyError that takes a message and a code. The message is passed to the base Exception class, and the code is stored as an attribute for extra error info.

beginner

How do you raise and catch a custom exception?

You use the raise keyword to throw the exception and a try-except block to catch it:

try:
    raise MyError('Oops', 404)
except MyError as e:
    print(f'Error: {e}, code: {e.code}')

Which built-in class should you usually inherit from to create a custom exception?

A Exception

B object

C int

D list

Custom exceptions should inherit from Exception or one of its subclasses to behave like standard errors.

What does the super() function do in a custom exception's __init__ method?

A Creates a new exception

B Calls the parent class's __init__ method

C Raises the exception

D Prints the error message

super() calls the parent class's __init__ to properly initialize the base Exception part.

How can you add extra information to a custom exception?

A By using global variables

B By changing the built-in Exception class

C By raising multiple exceptions

D By defining additional attributes in the class

You add extra attributes in your custom exception class to store additional error details.

What happens if you raise a custom exception but do not catch it?

A The program continues silently

B The exception is ignored

C The program stops and shows a traceback

D The exception is converted to a string

Uncaught exceptions stop the program and print an error traceback.

Which keyword is used to raise a custom exception?

A raise

B throw

C catch

D try

The raise keyword is used to throw exceptions in Python.

Explain how to create and use a custom exception in Python.

Think about making a new class and how to handle errors.

Why is it useful to extend built-in exceptions instead of using Exception directly?

Consider how different errors help you understand problems better.

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