Best practices for custom exceptions in Python - Step-by-Step Execution

Concept Flow - Best practices for custom exceptions

Define Custom Exception Class

↓

Raise Custom Exception

↓

Catch Exception with try-except

↓

Handle or Log Exception

↓

Program Continues or Exits

This flow shows how to define, raise, catch, and handle custom exceptions in Python.

Execution Sample

Python

class MyError(Exception):
    pass

try:
    raise MyError("Oops!")
except MyError as e:
    print(e)

Defines a custom exception, raises it, catches it, and prints the message.

Execution Table

Step	Action	Evaluation	Result
1	Define class MyError(Exception)	Class created	MyError ready to use
2	Enter try block	No exception yet	Proceed
3	Raise MyError with message 'Oops!'	Exception raised	Jump to except block
4	Catch MyError as e	e holds 'Oops!'	Inside except block
5	Print e	Prints 'Oops!'	Output: Oops!
6	End try-except	No more code	Program ends normally

💡 Exception caught and handled, program continues without crashing

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
e	undefined	undefined	MyError('Oops!')	MyError('Oops!')

Key Moments - 3 Insights

Why do we inherit from Exception when creating a custom exception?

Inheriting from Exception makes your custom exception compatible with Python's error handling, as shown in Step 1 of the execution_table.

What happens if we don't catch the custom exception?

If not caught, the program stops with an error. Step 3 shows raising the exception, and without Step 4's except block, it would crash.

Why use a custom exception instead of a built-in one?

Custom exceptions clarify what went wrong and help separate error types, making handling more precise as seen in the try-except flow.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of variable 'e' after Step 4?

A MyError('Oops!')

B undefined

C None

D Exception

💡 Hint

Check variable_tracker row for 'e' after Step 4

At which step does the program jump to the except block?

A Step 2

B Step 3

C Step 5

D Step 1

💡 Hint

See execution_table row where exception is raised and control flow changes

If we remove the except block, what happens after Step 3?

A Program continues normally

B Exception is ignored

C Program crashes with error

D Exception is automatically handled

💡 Hint

Refer to key_moments about what happens if exception is not caught

Concept Snapshot

Define custom exceptions by inheriting Exception.
Raise them with raise keyword.
Catch with try-except blocks.
Use clear names and messages.
Helps separate error types and improve debugging.

Full Transcript

This visual execution shows how to create and use custom exceptions in Python. First, we define a class inheriting from Exception. Then, inside a try block, we raise the custom exception with a message. The except block catches it and assigns it to variable 'e'. We print the message stored in 'e'. The program continues normally after handling the exception. Key points include inheriting from Exception to integrate with Python's error system, always catching exceptions to avoid crashes, and using custom exceptions to clarify error causes.

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