Creating Custom Exceptions and Operator Overloading in Python

Course: Python Training

Topic: Creating Custom Exceptions and Operator Overloading

Course Link: Python Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction

Python provides powerful object-oriented programming features that allow developers to create reusable, maintainable, and flexible applications. Two important concepts in object-oriented programming are custom exceptions and operator overloading.

Custom exceptions allow developers to define application-specific errors that communicate exactly what went wrong in a program. Instead of relying only on general exceptions, developers can create meaningful exceptions for situations such as insufficient bank balance, invalid student marks, unavailable products, or failed business rules.

Operator overloading allows a class to define how standard operators such as +, -, *, ==, and < behave when applied to its objects. It is implemented using special methods, also called magic methods or dunder methods.

Together, these concepts help developers build Python applications that handle errors clearly and allow custom objects to behave naturally when used with operators.

2. Learning Objectives

• Understand Python's built-in exception handling mechanism.
• Create custom exception classes using inheritance.
• Raise custom exceptions with the raise statement.
• Handle custom exceptions using try and except.
• Understand operator overloading and special methods.
• Overload arithmetic, comparison, and string representation operators.
• Implement reverse and in-place arithmetic operations.
• Apply both concepts in practical Python projects.

3. Understanding Exceptions in Python

An exception is an event that occurs during program execution when an operation cannot be completed normally. Exceptions may result from invalid input, missing files, incorrect data types, division by zero, or application-specific conditions.

Example: Built-in Exception

number = 10
divisor = 0

result = number / divisor
print(result)

Output: Python raises a ZeroDivisionError because division by zero is not permitted.

Without suitable exception handling, an unhandled exception interrupts the normal execution of the program.

Common Built-in Exceptions

4. What Are Custom Exceptions?

A custom exception is an exception class created by a developer to represent a specific error condition in an application. Custom exceptions make error handling more meaningful because their names and messages describe the problem in the context of the application.

Python recommends deriving application-specific exceptions from the built-in Exception class or one of its subclasses, rather than directly from BaseException.

Basic Syntax

class CustomError(Exception):
    pass

Here, CustomError is a new exception class. The pass statement indicates that the class does not require any additional implementation.

Example: Creating a Custom Exception

class InvalidAgeError(Exception):
    pass

age = 15

if age < 18:
    raise InvalidAgeError("Age must be at least 18")

print("Eligible")

Expected behavior: The program raises InvalidAgeError with the message Age must be at least 18. The final print statement is not executed.

Explanation:

• InvalidAgeError represents a specific application rule.
• It inherits from Exception, making it suitable for normal exception handling.
• The raise statement creates and raises the error.
• The message explains why the operation failed.

5. Raising and Handling Custom Exceptions

Creating a custom exception is only one part of the process. A program can also catch the exception and respond appropriately rather than allowing it to terminate the application unexpectedly.

Example

class InsufficientBalanceError(Exception):
    pass

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError("Withdrawal amount must be positive")

    if amount > balance:
        raise InsufficientBalanceError(
            "Insufficient balance for withdrawal"
        )

    return balance - amount

try:
    remaining_balance = withdraw(5000, 7000)
    print("Remaining balance:", remaining_balance)
except InsufficientBalanceError as error:
    print("Transaction failed:", error)

Output:

Transaction failed: Insufficient balance for withdrawal

Explanation:

• The withdraw() function checks the requested withdrawal amount.
• It raises a built-in ValueError if the amount is not positive.
• It raises InsufficientBalanceError if the requested amount exceeds the available balance.
• The except block catches the specific custom exception.
• The error message is available through the exception object.

6. Adding Information to Custom Exceptions

Custom exception classes can store additional information that helps developers understand the cause of a failure. For example, a payment exception may contain the transaction ID or the amount that could not be processed.

Example: Custom Exception with Attributes

class PaymentError(Exception):
    def __init__(self, amount, message):
        self.amount = amount
        super().__init__(message)

try:
    raise PaymentError(2500, "Payment could not be completed")
except PaymentError as error:
    print("Message:", error)
    print("Amount:", error.amount)

Output:

Message: Payment could not be completed
Amount: 2500

The constructor stores the amount in an instance attribute and passes the message to the parent Exception class. Calling super().__init__(message) ensures that the exception's normal message handling works correctly.

7. Creating an Exception Hierarchy

A project may require several related custom exceptions. Instead of making each exception completely independent, developers can define a common base exception and derive more specific exceptions from it.

Example

class ApplicationError(Exception):
    """Base exception for application errors."""
    pass

class InvalidUserError(ApplicationError):
    pass

class InvalidPasswordError(ApplicationError):
    pass

class AccountLockedError(ApplicationError):
    pass

def login(username, password):
    if not username:
        raise InvalidUserError("Username is required")

    if password != "correct-password":
        raise InvalidPasswordError("Invalid password")

    return "Login successful"

try:
    print(login("user1", "wrong-password"))
except InvalidUserError as error:
    print("User error:", error)
except InvalidPasswordError as error:
    print("Password error:", error)
except ApplicationError as error:
    print("Application error:", error)

Output:

Password error: Invalid password

The base class ApplicationError allows related application errors to be handled together. Specific subclasses make it possible to respond differently to different failure conditions.

8. Best Practices for Custom Exceptions

• Use descriptive names that usually end in Error.
• Inherit from Exception or an appropriate subclass.
• Keep exception classes simple unless extra information is needed.
• Raise exceptions when an operation cannot satisfy its requirements.
• Catch specific exceptions rather than catching every exception indiscriminately.
• Use clear messages that help users or developers understand the problem.
• Preserve the original cause when converting one exception into another.
• Avoid using exceptions for ordinary control flow when a normal condition check is clearer.

9. What Is Operator Overloading?

Operator overloading is a Python feature that lets classes define how operators behave for instances of those classes. Python uses special methods to connect operator syntax to class behavior.

For example, when the expression object1 + object2 is evaluated, Python may call the special method object1.__add__(object2). The exact operator behavior depends on the types involved and the methods implemented by those types.

Why Is Operator Overloading Useful?

• It allows objects to work naturally with familiar operators.
• It improves readability for mathematical and domain-specific classes.
• It supports reusable abstractions such as vectors, fractions, money values, and measurements.
• It lets classes define meaningful comparisons between objects.
• It makes custom types easier to use alongside built-in Python types when designed consistently.

10. Understanding Special Methods

Special methods are methods with double underscores at the beginning and end of their names. They are often called dunder methods. Python invokes them through language syntax or built-in operations.

Defining these methods lets developers customize supported operations for their classes. Each method should follow the expected meaning of the corresponding operator.

11. Overloading the Addition Operator (+)

The __add__() method defines how the addition operator behaves for an object when it appears on the left side of an addition expression.

Example: Adding Two Objects

class Number:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if not isinstance(other, Number):
            return NotImplemented
        return Number(self.value + other.value)

    def __repr__(self):
        return f"Number({self.value})"

num1 = Number(10)
num2 = Number(20)

result = num1 + num2
print(result)

Output:

Number(30)

Explanation:

• The Number class stores a numeric value.
• The __add__() method checks whether the other operand is also a Number.
• It returns NotImplemented for unsupported operand types, allowing Python to try other supported operator handling or raise a suitable error.
• For compatible objects, it creates and returns a new Number instance containing the sum.
• The __repr__() method provides a useful representation when printing the result in this example.

12. Overloading Subtraction, Multiplication, and Division

Python supports other arithmetic special methods, allowing custom classes to define additional mathematical operations.

Example: A Measurement Class

class Measurement:
    def __init__(self, value):
        self.value = value

    def __sub__(self, other):
        if not isinstance(other, Measurement):
            return NotImplemented
        return Measurement(self.value - other.value)

    def __mul__(self, other):
        if not isinstance(other, Measurement):
            return NotImplemented
        return Measurement(self.value * other.value)

    def __truediv__(self, other):
        if not isinstance(other, Measurement):
            return NotImplemented
        if other.value == 0:
            raise ZeroDivisionError("Cannot divide by zero")
        return Measurement(self.value / other.value)

    def __repr__(self):
        return f"Measurement({self.value})"

a = Measurement(20)
b = Measurement(5)

print(a - b)
print(a * b)
print(a / b)

Output:

Measurement(15)
Measurement(100)
Measurement(4.0)

This example demonstrates operator overloading for three arithmetic operations. In real measurement applications, the class should also define clear unit and dimensional rules because not every multiplication or division of measurements is physically meaningful.

13. Overloading Comparison Operators

Comparison operators determine relationships between objects. Methods such as __eq__(), __lt__(), and __gt__() allow classes to define these relationships.

Example: Comparing Product Prices

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __lt__(self, other):
        if not isinstance(other, Product):
            return NotImplemented
        return self.price < other.price

    def __eq__(self, other):
        if not isinstance(other, Product):
            return NotImplemented
        return self.price == other.price

product1 = Product("Keyboard", 1200)
product2 = Product("Mouse", 800)

print(product1 < product2)
print(product1 == product2)

Output:

False
False

The first expression checks whether the keyboard is cheaper than the mouse. The second checks whether their prices are equal. These comparisons use price only; a real application may instead need to compare product IDs or other business-specific attributes.

14. Overloading String Representation

The __str__() and __repr__() methods define how an object is represented as text.

• __str__() provides a user-friendly representation, especially for print() and str().
• __repr__() provides a developer-oriented representation useful for debugging and inspection.

Example

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    def __str__(self):
        return f"Student: {self.name}, Marks: {self.marks}"

    def __repr__(self):
        return f"Student(name={self.name!r}, marks={self.marks!r})"

student = Student("Riya", 92)

print(str(student))
print(repr(student))

Output:

Student: Riya, Marks: 92
Student(name='Riya', marks=92)

Clear string representations make debugging easier and help communicate the contents of an object.

15. Reverse Operator Overloading

Reverse arithmetic methods are used when a custom object appears on the right side of an operator and the left operand cannot complete the operation itself. Common reverse methods include __radd__(), __rsub__(), and __rmul__().

Example: Adding an Integer to a Custom Object

class Score:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if isinstance(other, Score):
            return Score(self.value + other.value)
        if isinstance(other, int) and not isinstance(other, bool):
            return Score(self.value + other)
        return NotImplemented

    def __radd__(self, other):
        if isinstance(other, int) and not isinstance(other, bool):
            return Score(other + self.value)
        return NotImplemented

    def __repr__(self):
        return f"Score({self.value})"

score = Score(50)

print(score + 10)
print(10 + score)

Output:

Score(60)
Score(60)

The __add__() method handles an integer on the right side of the custom object. The __radd__() method supports an integer on the left side when Python dispatches to the reverse operation.

16. In-Place Operator Overloading

In-place operators such as +=, -=, and *= can be customized using special methods such as __iadd__(), __isub__(), and __imul__().

Example

class Counter:
    def __init__(self, value=0):
        self.value = value

    def __iadd__(self, amount):
        self.value += amount
        return self

    def __repr__(self):
        return f"Counter({self.value})"

counter = Counter(10)
counter += 5

print(counter)

Output:

Counter(15)

The __iadd__() method updates the existing counter and returns the same object. If an in-place method is not implemented, Python may fall back to the corresponding regular arithmetic operation and reassign the result.

17. Returning NotImplemented Correctly

NotImplemented is a special value used by binary operator methods to indicate that the method does not support the supplied operand types. It is not the same as NotImplementedError, which is an exception.

Example

class Box:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if not isinstance(other, Box):
            return NotImplemented
        return Box(self.value + other.value)

If an unsupported operand is supplied, Python may try a suitable reflected operation on the other operand. If no valid operation can handle the expression, Python normally raises a TypeError.

18. Common Mistakes in Operator Overloading

• Returning the wrong type: An arithmetic method should return a result consistent with the class's intended behavior.
• Ignoring operand types: Unsupported operand combinations can cause confusing errors if they are not handled appropriately.
• Using NotImplemented incorrectly: Return the special value NotImplemented for unsupported binary operations instead of raising it as an exception.
• Confusing NotImplemented and NotImplementedError: The former participates in operator dispatch; the latter is an exception.
• Changing operator meaning unexpectedly: Use familiar operators in ways that match their normal meaning.
• Ignoring division by zero: Check for invalid divisors when the class needs to provide a specific error message.
• Forgetting comparison consistency: Equality and ordering operations should follow a clear, documented rule.
• Overloading every operator unnecessarily: Implement only operations that make sense for the class.

19. Difference Between Custom Exceptions and Operator Overloading

20. Combined Example: Bank Account with Custom Exceptions

This example combines a custom exception with class methods and basic validation to demonstrate how application-specific failures can be communicated clearly.

class BankAccountError(Exception):
    pass

class InsufficientBalanceError(BankAccountError):
    pass

class InvalidAmountError(BankAccountError):
    pass

class BankAccount:
    def __init__(self, owner, balance=0):
        if balance < 0:
            raise InvalidAmountError("Initial balance cannot be negative")
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise InvalidAmountError("Deposit must be positive")
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if amount <= 0:
            raise InvalidAmountError("Withdrawal must be positive")
        if amount > self.balance:
            raise InsufficientBalanceError("Insufficient balance")
        self.balance -= amount
        return self.balance

account = BankAccount("Aarav", 1000)

try:
    account.withdraw(1500)
except InsufficientBalanceError as error:
    print("Transaction failed:", error)

print("Current balance:", account.balance)

Output:

Transaction failed: Insufficient balance
Current balance: 1000

The transaction fails before the balance is changed. This demonstrates why custom exceptions are useful for enforcing application rules and making failure conditions easy to identify.

21. Mini Project: Vector Calculator

Objective: Create a two-dimensional vector class that supports vector addition and subtraction, calculates vector magnitude, and raises custom exceptions for invalid operations.

Requirements

• Create a custom VectorOperationError exception.
• Create a Vector class with horizontal and vertical coordinates.
• Overload the + operator using __add__().
• Overload the - operator using __sub__().
• Provide a readable object representation using __repr__().
• Calculate the magnitude using a method or property.
• Reject unsupported operands appropriately.

Sample Implementation

import math

class VectorOperationError(Exception):
    pass

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x - other.x, self.y - other.y)

    @property
    def magnitude(self):
        return math.sqrt(self.x ** 2 + self.y ** 2)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(4, 5)

print("Addition:", v1 + v2)
print("Subtraction:", v1 - v2)
print("Magnitude:", v1.magnitude)

try:
    result = v1 + 10
except TypeError as error:
    print("Invalid operation:", error)

Example output:

Addition: Vector(6, 8)
Subtraction: Vector(-2, -2)
Magnitude: 3.605551275463989
Invalid operation: unsupported operand type(s) for +: 'Vector' and 'int'

Project extension: Use VectorOperationError for a genuine vector-specific error condition, such as an invalid coordinate supplied by a dedicated validation method. Keep Python's standard TypeError behavior for unsupported operand types when that is the most appropriate choice.

22. Practice Exercises

Exercise 1: Custom Age Exception

Create an InvalidAgeError class. Write a function that raises this exception when a supplied age is negative or does not meet the minimum age requirement for a particular activity.

Exercise 2: Custom Marks Exception

Create a MarksValidationError exception and validate that student marks fall between 0 and 100.

Exercise 3: Product Price Addition

Create a Price class and overload the + operator to add two compatible price objects.

Exercise 4: Time Comparison

Create a Time class and implement __lt__() to compare two time values based on their total number of seconds.

Exercise 5: Fraction Arithmetic

Create a Fraction class that overloads addition and subtraction. Consider how to normalize fractions and handle division by zero in any division operation you implement.

Exercise 6: Custom Inventory Exception

Create an OutOfStockError exception and use it in an inventory class when a customer requests more items than are available.

23. Interview Questions and Answers

Q1. What is a custom exception in Python?

Answer: A custom exception is a developer-defined exception class used to represent a specific error condition in an application.

Q2. Why should custom exceptions inherit from Exception?

Answer: Inheriting from Exception makes the custom exception suitable for normal error handling using try and except.

Q3. What is the purpose of the raise statement?

Answer: The raise statement explicitly raises an exception when a condition prevents an operation from completing normally.

Q4. What is an exception hierarchy?

Answer: It is a structure of related exception classes connected through inheritance, allowing errors to be handled individually or through a shared base class.

Q5. What is operator overloading?

Answer: Operator overloading lets a class define the behavior of operators for its objects by implementing special methods.

Q6. Which method overloads the addition operator?

Answer: The __add__() method normally handles the addition operator when the custom object is the left operand.

Q7. What is the difference between __str__() and __repr__()?

Answer: __str__() provides a user-friendly string representation, while __repr__() provides a developer-oriented representation.

Q8. What is the purpose of __radd__()?

Answer: It supports reflected addition when the custom object is the right operand and Python dispatches to the reflected operation.

Q9. What does NotImplemented mean?

Answer: It is a special value returned by an operator method to indicate that the operation is not supported for the supplied operand types.

Q10. What is the difference between NotImplemented and NotImplementedError?

Answer: NotImplemented is a special return value used in operator dispatch. NotImplementedError is an exception that can indicate an operation has not been implemented.

Q11. Can comparison operators be overloaded?

Answer: Yes. Methods such as __eq__(), __lt__(), and __gt__() can define comparisons between objects.

Q12. When should operator overloading be avoided?

Answer: Avoid it when an operator's meaning would be confusing, inconsistent with normal expectations, or less clear than an ordinary method call.

24. Quick Revision Notes

• Custom exceptions represent application-specific errors.
• Define custom exceptions by inheriting from Exception or a suitable subclass.
• Use raise to signal errors and try/except to handle them.
• Custom exception classes can store extra diagnostic information.
• Exception hierarchies group related errors together.
• Operator overloading customizes operator behavior for class instances.
• __add__(), __sub__(), and __mul__() implement common arithmetic operations.
• __eq__() and __lt__() implement equality and less-than comparisons.
• __str__() and __repr__() define string representations.
• Reverse methods support operations when the custom object is the right operand.
• NotImplemented allows Python to try alternative operator handling.
• Operators should have predictable meanings and appropriate return values.

25. Final Checklist

• Understand built-in exceptions and exception handling.
• Create custom exceptions and raise them appropriately.
• Handle custom exceptions using specific exception handlers.
• Create a base exception and related subclasses.
• Implement arithmetic special methods in a custom class.
• Overload comparison and representation methods.
• Understand reverse and in-place operator methods.
• Handle unsupported operand types appropriately.
• Complete the vector calculator project and practice exercises.
• Test normal cases, invalid inputs, and edge cases.

Conclusion

Creating custom exceptions and implementing operator overloading are valuable Python programming skills. Custom exceptions make applications easier to debug and maintain by providing meaningful, structured error handling. Operator overloading allows custom objects to interact with Python operators in intuitive and consistent ways.

By combining these concepts with classes, inheritance, encapsulation, and special methods, developers can build more robust object-oriented applications. Practice the examples and mini project to strengthen your understanding and prepare for Python programming interviews.

Learn More with JustAcademy

Explore the Python Training Course to strengthen your knowledge of Python fundamentals, object-oriented programming, exception handling, and advanced programming concepts.

To learn more about the course, register for a course demo.

Visit the JustAcademy website to explore additional training resources and courses.