Extending built-in exceptions in Python - Mini Project: Build & Apply

Extending built-in exceptions

📖 Scenario: Imagine you are building a simple banking app. You want to handle errors when someone tries to withdraw more money than they have.

🎯 Goal: Create a custom error by extending Python's built-in Exception class. Use it to show a clear message when a withdrawal is too large.

📋 What You'll Learn

Create a custom exception class called InsufficientFundsError that extends Exception

Add an __init__ method to InsufficientFundsError that takes balance and amount as parameters

Store balance and amount as attributes in InsufficientFundsError

Override the __str__ method to return a message like: 'Cannot withdraw {amount}, only {balance} available.'

Create a variable balance set to 100

Create a variable withdraw_amount set to 150

Write code that raises InsufficientFundsError if withdraw_amount is greater than balance

Use a try-except block to catch InsufficientFundsError and print the error message

💡 Why This Matters

🌍 Real World

Custom exceptions help make error messages clearer and easier to understand in real applications like banking or shopping apps.

💼 Career

Knowing how to extend exceptions is useful for writing clean, maintainable code and handling errors in professional software development.

1

Create the custom exception class

Create a class called InsufficientFundsError that extends Exception. Add an __init__ method that takes balance and amount as parameters and stores them as attributes.

Python

# Your code here

Hint

Remember to use class InsufficientFundsError(Exception): to extend the built-in Exception class.

2

Add the __str__ method to show the error message

Add a __str__ method to InsufficientFundsError that returns the string: f"Cannot withdraw {self.amount}, only {self.balance} available."

Python

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount

# Your code here

Hint

The __str__ method should return a formatted string with self.amount and self.balance.

3

Set up balance and withdrawal amount variables

Create a variable called balance and set it to 100. Create another variable called withdraw_amount and set it to 150.

Python

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
    def __str__(self):
        return f"Cannot withdraw {self.amount}, only {self.balance} available."

# Your code here

Hint

Use simple assignment to create balance and withdraw_amount.

4

Raise and catch the custom exception

Write a try-except block. Inside try, raise InsufficientFundsError(balance, withdraw_amount) if withdraw_amount is greater than balance. In except InsufficientFundsError as e, print e.

Python

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
    def __str__(self):
        return f"Cannot withdraw {self.amount}, only {self.balance} available."

balance = 100
withdraw_amount = 150

# Your code here

Hint

Use raise InsufficientFundsError(balance, withdraw_amount) inside the try block and catch it with except InsufficientFundsError as e.

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