Best practices for custom exceptions in Python - Mini Project: Build & Apply

Best practices for custom exceptions

📖 Scenario: Imagine you are building a simple banking application. You want to handle errors clearly when users try to withdraw more money than they have in their account.

🎯 Goal: Create a custom exception called InsufficientFundsError to handle withdrawal errors. Use it in a function that withdraws money from an account balance.

📋 What You'll Learn

Create a custom exception class named InsufficientFundsError that inherits from Exception.

Add a constructor to InsufficientFundsError that accepts a message and passes it to the base class.

Create a variable balance with the value 100.

Create a function withdraw(amount) that raises InsufficientFundsError if amount is greater than balance.

Use a try-except block to call withdraw(150) and print the error message if caught.

💡 Why This Matters

🌍 Real World

Custom exceptions help you handle specific errors in your programs clearly, like when a bank account has insufficient funds.

💼 Career

Understanding custom exceptions is important for writing robust, maintainable code in software development jobs.

1

Create the custom exception class

Create a custom exception class called InsufficientFundsError that inherits from Exception. Add an __init__ method that takes a message parameter and passes it to super().__init__(message).

Python

# Your code here

Hint

Remember to inherit from Exception and call super().__init__(message) inside the constructor.

2

Create the balance variable

Create a variable called balance and set it to 100.

Python

class InsufficientFundsError(Exception):
    def __init__(self, message):
        super().__init__(message)

# Your code here

Hint

Just create a variable named balance and assign it the value 100.

3

Create the withdraw function with exception

Create a function called withdraw that takes a parameter amount. Inside the function, check if amount is greater than balance. If yes, raise InsufficientFundsError with the message "Not enough funds to withdraw {amount}". Otherwise, subtract amount from balance.

Python

class InsufficientFundsError(Exception):
    def __init__(self, message):
        super().__init__(message)

balance = 100

# Your code here

Hint

Use raise InsufficientFundsError(...) to throw the error when amount is too big.

4

Use try-except to handle the exception

Write a try-except block that calls withdraw(150). Catch the InsufficientFundsError as e and print e.

Python

class InsufficientFundsError(Exception):
    def __init__(self, message):
        super().__init__(message)

balance = 100

def withdraw(amount):
    global balance
    if amount > balance:
        raise InsufficientFundsError(f"Not enough funds to withdraw {amount}")
    balance -= amount

# Your code here

Hint

Use try to call withdraw(150) and except InsufficientFundsError as e to catch and print the error.

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