Compile-time Polymorphism

Compile-time polymorphism is also known as static polymorphism. It occurs when the compiler knows which polymorphic function to call at compile-time. Compile-time polymorphism is achieved through function overloading and operator overloading.

Function Overloading

Function overloading is a feature of a programming language that allows a function to be defined more than once. The function is defined with the same name but with different parameters. The function is called based on the number of parameters passed to it. Function overloading is a type of compile-time polymorphism. It is achieved by defining multiple functions with the same name but with different parameters. The function is called based on the number of parameters passed to it. Function overloading is not supported in Python. However, it can be achieved by using default arguments and variable-length arguments. Let’s see how to achieve function overloading in Python.

def add(a, b):
    print("Two arguments\n")
    return a + b
 
def add(a, b, c):
    print("Three arguments\n")
    return a + b + c
 
def add(a, b, c, d):
    print("Four arguments\n")
    return a + b + c + d
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

def add(a, b):
    print("Two arguments\n")
    return a + b
 
def add(a, b, c):
    print("Three arguments\n")
    return a + b + c
 
def add(a, b, c, d):
    print("Four arguments\n")
    return a + b + c + d
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

Output:

C:\Users\username>python function_overloading.py
Traceback (most recent call last):
  File "function_overloading.py", line 11, in <module>
    print(add(1, 2))
TypeError: add() missing 2 required positional arguments: 'c' and 'd'

C:\Users\username>python function_overloading.py
Traceback (most recent call last):
  File "function_overloading.py", line 11, in <module>
    print(add(1, 2))
TypeError: add() missing 2 required positional arguments: 'c' and 'd'

In the above example, we have defined three functions with the same name but with different parameters. The first function takes two arguments, the second function takes three arguments, and the third function takes four arguments. We have called the add()add() function with two, three, and four arguments. The output shows that the add()add() function is called based on the number of arguments passed to it. The add()add() function is called with two arguments, three arguments, and four arguments. In Python, function overloading is achieved by using default arguments and variable-length arguments. Let’s see how to achieve function overloading in Python using default arguments and variable-length arguments.

Function Overloading using Default Arguments

def add(a, b, c=0, d=0):
    # Default arguments
    return a + b + c + d
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

def add(a, b, c=0, d=0):
    # Default arguments
    return a + b + c + d
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

Output:

C:\Users\username>python function_overloading.py
3
6
10

C:\Users\username>python function_overloading.py
3
6
10

In the above example, we have defined the add()add() function with four parameters. The cc and dd parameters have default values of 00. We have called the add()add() function with two, three, and four arguments. The output shows that the add()add() function is called based on the number of arguments passed to it. The add()add() function is called with two arguments, three arguments, and four arguments.

Function Overloading using Variable-length Arguments

def add(*args):
    # Variable-length arguments
    total = 0
    for arg in args:
        total += arg
    return total
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

def add(*args):
    # Variable-length arguments
    total = 0
    for arg in args:
        total += arg
    return total
 
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 2, 3, 4))

Output:

C:\Users\username>python function_overloading.py
3
6
10

C:\Users\username>python function_overloading.py
3
6
10

In the above example, we have defined the add()add() function with a variable-length argument. We have called the add()add() function with two, three, and four arguments. The output shows that the add()add() function is called based on the number of arguments passed to it. The add()add() function is called with two arguments, three arguments, and four arguments.

Function Overloading in class

Function overloading is a feature of a programming language that allows a function to be defined more than once. The function is defined with the same name but with different parameters. The function is called based on the number of parameters passed to it. Function overloading is a type of compile-time polymorphism. It is achieved by defining multiple functions with the same name but with different parameters. The function is called based on the number of parameters passed to it. Function overloading is not supported in Python. However, it can be achieved by using default arguments and variable-length arguments. Let’s see how to achieve function overloading in Python.

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def display(self):
        print('Name:', self.name)
        print('Roll:', self.roll)
 
    def display(self, age):
        print('Name:', self.name)
        print('Roll:', self.roll)
        print('Age:', age)
 
student1 = Student('John', 1)
student1.display()
student1.display(20)

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def display(self):
        print('Name:', self.name)
        print('Roll:', self.roll)
 
    def display(self, age):
        print('Name:', self.name)
        print('Roll:', self.roll)
        print('Age:', age)
 
student1 = Student('John', 1)
student1.display()
student1.display(20)

Output:

C:\Users\username>python function_overloading.py
Traceback (most recent call last):
  File "function_overloading.py", line 17, in <module>
    student1.display()
TypeError: display() missing 1 required positional argument: 'age'

C:\Users\username>python function_overloading.py
Traceback (most recent call last):
  File "function_overloading.py", line 17, in <module>
    student1.display()
TypeError: display() missing 1 required positional argument: 'age'

In the above example, we have defined two display()display() methods in the StudentStudent class. The first display()display() method takes one argument, and the second display()display() method takes two arguments. We have created an object named student1student1 of the StudentStudent class. We have called the display()display() method of the student1student1 object with one argument. The output shows that the display()display() method is called with one argument. We have called the display()display() method of the student1student1 object with two arguments. The output shows that the display()display() method is called with two arguments. In Python, function overloading is achieved by using default arguments and variable-length arguments. Let’s see how to achieve function overloading in Python using default arguments and variable-length arguments.

Operator Overloading

Operator overloading is a feature of a programming language that allows an operator to be defined more than once. The operator is defined with the same name but with different parameters. The operator is called based on the number of parameters passed to it. Operator overloading is a type of compile-time polymorphism. It is achieved by defining multiple operators with the same name but with different parameters. The operator is called based on the number of parameters passed to it. Operator overloading is not supported in Python. However, it can be achieved by using magic methods. Let’s see how to achieve operator overloading in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)
 
    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)
 
    def __mul__(self, other):
        return Complex(self.real * other.real, self.imag * other.imag)
 
    def __truediv__(self, other):
        return Complex(self.real / other.real, self.imag / other.imag)
 
    def __str__(self):
        return f'{self.real} + {self.imag}j'
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
print(c1 + c2)
print(c1 - c2)
print(c1 * c2)
print(c1 / c2)

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)
 
    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)
 
    def __mul__(self, other):
        return Complex(self.real * other.real, self.imag * other.imag)
 
    def __truediv__(self, other):
        return Complex(self.real / other.real, self.imag / other.imag)
 
    def __str__(self):
        return f'{self.real} + {self.imag}j'
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
print(c1 + c2)
print(c1 - c2)
print(c1 * c2)
print(c1 / c2)

Output:

C:\Users\username>python operator_overloading.py
4 + 6j
-2 + -2j
3 + 8j
0.3333333333333333 + 0.5j

C:\Users\username>python operator_overloading.py
4 + 6j
-2 + -2j
3 + 8j
0.3333333333333333 + 0.5j

In the above example, we have defined four magic methods named __add__()__add__(), __sub__()__sub__(), __mul__()__mul__(), and __truediv__()__truediv__(). The __add__()__add__() method is called when the ++ operator is used with two ComplexComplex objects. The __sub__()__sub__() method is called when the -- operator is used with two ComplexComplex objects. The __mul__()__mul__() method is called when the ** operator is used with two ComplexComplex objects. The __truediv__()__truediv__() method is called when the // operator is used with two ComplexComplex objects. We have created two ComplexComplex objects named c1c1 and c2c2. We have added, subtracted, multiplied, and divided the c1c1 and c2c2 objects. The output shows that the __add__()__add__(), __sub__()__sub__(), __mul__()__mul__(), and __truediv__()__truediv__() methods are called when the ++, --, **, and // operators are used with two ComplexComplex objects.

Magic Methods

Magic methods are special methods that are used to perform some special operations. They are also known as dunder methods. They are always surrounded by double underscores. They are called automatically when certain operations are performed on objects. For example, the __init__()__init__() method is called automatically when an object is created. Magic methods are also known as dunder methods because they are surrounded by double underscores. Let’s see how to use magic methods in Python.

List of Magic Methods

init() Method

The __init__()__init__() method is called automatically when an object is created. It is used to initialize the instance variables of an object. It is also known as the constructor method. Let’s see how to use the __init__()__init__() method in Python.

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
student1 = Student('John', 1)
print('Name:', student1.name)
print('Roll:', student1.roll)

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
student1 = Student('John', 1)
print('Name:', student1.name)
print('Roll:', student1.roll)

Output:

C:\Users\username>python init.py
Name: John
Roll: 1

C:\Users\username>python init.py
Name: John
Roll: 1

In the above example, we have created two instance variables named namename and rollroll. We have initialized the namename and rollroll variables to the namename and rollroll parameters of the __init__()__init__() method. We have printed the namename and rollroll variables using the student1student1 object. The output shows that the namename and rollroll variables are unique to the object.

str() Method

The __str__()__str__() method is called when the str()str() function is called on an object. It is used to return a string representation of an object. Let’s see how to use the __str__()__str__() method in Python. It also called when the print()print() function is called on an object.

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def __str__(self):
        return f'Name: {self.name}\nRoll: {self.roll}'
 
student1 = Student('John', 1)
print(str(student1))
print(student1)

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def __str__(self):
        return f'Name: {self.name}\nRoll: {self.roll}'
 
student1 = Student('John', 1)
print(str(student1))
print(student1)

Output:

C:\Users\username>python str.py
Name: John
Roll: 1
Name: John
Roll: 1

C:\Users\username>python str.py
Name: John
Roll: 1
Name: John
Roll: 1

In the above example, we have defined the __str__()__str__() method in the StudentStudent class. The __str__()__str__() method returns a string representation of the StudentStudent object. We have created an object named student1student1 of the StudentStudent class. We have printed the student1student1 object using the str()str() function. The output shows that the __str__()__str__() method is called when the str()str() function is called on the student1student1 object.

repr() Method

The __repr__()__repr__() method is called when the repr()repr() function is called on an object. It is used to return a string representation of an object. Let’s see how to use the __repr__()__repr__() method in Python. It also called when the print()print() function is called on an object.

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def __repr__(self):
        return f'Name: {self.name}\nRoll: {self.roll}'
 
student1 = Student('John', 1)
print(student1)

class Student:
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
 
    def __repr__(self):
        return f'Name: {self.name}\nRoll: {self.roll}'
 
student1 = Student('John', 1)
print(student1)

Output:

C:\Users\username>python repr.py
Name: John
Roll: 1

C:\Users\username>python repr.py
Name: John
Roll: 1

In the above example, we have defined the __repr__()__repr__() method in the StudentStudent class. The __repr__()__repr__() method returns a string representation of the StudentStudent object. We have created an object named student1student1 of the StudentStudent class. We have printed the student1student1 object using the print()print() function. The output shows that the __repr__()__repr__() method is called when the print()print() function is called on the student1student1 object.

len() Method

The __len__()__len__() method is called when the len()len() function is called on an object. It is used to return the length of an object. Let’s see how to use the __len__()__len__() method in Python.

class Store:
    def __init__(self, items):
        self.items = items
 
    def __len__(self):
        return len(self.items)
 
store1 = Store(['Apple', 'Banana', 'Orange'])
print(len(store1))

class Store:
    def __init__(self, items):
        self.items = items
 
    def __len__(self):
        return len(self.items)
 
store1 = Store(['Apple', 'Banana', 'Orange'])
print(len(store1))

Output:

C:\Users\username>python len.py
3

C:\Users\username>python len.py
3

In the above example, we have defined the __len__()__len__() method in the StoreStore class. The __len__()__len__() method returns the length of the itemsitems list. We have created an object named store1store1 of the StoreStore class. We have printed the store1store1 object using the len()len() function. The output shows that the __len__()__len__() method is called when the len()len() function is called on the store1store1 object.

add() Method

The __add__()__add__() method is called when the ++ operator is used with two objects. It is used to add two objects. Let’s see how to use the __add__()__add__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 + c2
print(f'{c1.real} + {c1.imag}j + {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 + c2
print(f'{c1.real} + {c1.imag}j + {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python add.py
1 + 2j + 3 + 4j = 4 + 6j

C:\Users\username>python add.py
1 + 2j + 3 + 4j = 4 + 6j

In the above example, we have defined the __add__()__add__() method in the ComplexComplex class. The __add__()__add__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have added the c1c1 and c2c2 objects using the ++ operator. The output shows that the __add__()__add__() method is called when the ++ operator is used with two ComplexComplex objects.

sub() Method

The __sub__()__sub__() method is called when the -- operator is used with two objects. It is used to subtract two objects. Let’s see how to use the __sub__()__sub__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 - c2
print(f'{c1.real} + {c1.imag}j - {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 - c2
print(f'{c1.real} + {c1.imag}j - {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python sub.py
1 + 2j - 3 + 4j = -2 + -2j

C:\Users\username>python sub.py
1 + 2j - 3 + 4j = -2 + -2j

In the above example, we have defined the __sub__()__sub__() method in the ComplexComplex class. The __sub__()__sub__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have subtracted the c1c1 and c2c2 objects using the -- operator. The output shows that the __sub__()__sub__() method is called when the -- operator is used with two ComplexComplex objects.

mul() Method

The __mul__()__mul__() method is called when the ** operator is used with two objects. It is used to multiply two objects. Let’s see how to use the __mul__()__mul__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __mul__(self, other):
        return Complex(self.real * other.real, self.imag * other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 * c2
print(f'{c1.real} + {c1.imag}j * {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __mul__(self, other):
        return Complex(self.real * other.real, self.imag * other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 * c2
print(f'{c1.real} + {c1.imag}j * {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python mul.py
1 + 2j * 3 + 4j = 3 + 8j

C:\Users\username>python mul.py
1 + 2j * 3 + 4j = 3 + 8j

In the above example, we have defined the __mul__()__mul__() method in the ComplexComplex class. The __mul__()__mul__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have multiplied the c1c1 and c2c2 objects using the ** operator. The output shows that the __mul__()__mul__() method is called when the ** operator is used with two ComplexComplex objects.

truediv() Method

The __truediv__()__truediv__() method is called when the // operator is used with two objects. It is used to divide two objects. Let’s see how to use the __truediv__()__truediv__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __truediv__(self, other):
        return Complex(self.real / other.real, self.imag / other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 / c2
print(f'{c1.real} + {c1.imag}j / {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __truediv__(self, other):
        return Complex(self.real / other.real, self.imag / other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 / c2
print(f'{c1.real} + {c1.imag}j / {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python truediv.py
1 + 2j / 3 + 4j = 0.3333333333333333 + 0.5j

C:\Users\username>python truediv.py
1 + 2j / 3 + 4j = 0.3333333333333333 + 0.5j

In the above example, we have defined the __truediv__()__truediv__() method in the ComplexComplex class. The __truediv__()__truediv__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have divided the c1c1 and c2c2 objects using the // operator. The output shows that the __truediv__()__truediv__() method is called when the // operator is used with two ComplexComplex objects.

floordiv() Method

The __floordiv__()__floordiv__() method is called when the //// operator is used with two objects. It is used to divide two objects. Let’s see how to use the __floordiv__()__floordiv__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __floordiv__(self, other):
        return Complex(self.real // other.real, self.imag // other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 // c2
print(f'{c1.real} + {c1.imag}j // {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __floordiv__(self, other):
        return Complex(self.real // other.real, self.imag // other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 // c2
print(f'{c1.real} + {c1.imag}j // {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python floordiv.py
1 + 2j // 3 + 4j = 0 + 0j

C:\Users\username>python floordiv.py
1 + 2j // 3 + 4j = 0 + 0j

In the above example, we have defined the __floordiv__()__floordiv__() method in the ComplexComplex class. The __floordiv__()__floordiv__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have divided the c1c1 and c2c2 objects using the //// operator. The output shows that the __floordiv__()__floordiv__() method is called when the //// operator is used with two ComplexComplex objects.

mod() Method

The __mod__()__mod__() method is called when the %% operator is used with two objects. It is used to find the remainder of two objects. Let’s see how to use the __mod__()__mod__() method in Python.

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __mod__(self, other):
        return Complex(self.real % other.real, self.imag % other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 % c2
print(f'{c1.real} + {c1.imag}j % {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
 
    def __mod__(self, other):
        return Complex(self.real % other.real, self.imag % other.imag)
 
c1 = Complex(1, 2)
c2 = Complex(3, 4)
c3 = c1 % c2
print(f'{c1.real} + {c1.imag}j % {c2.real} + {c2.imag}j = {c3.real} + {c3.imag}j')

Output:

C:\Users\username>python mod.py
1 + 2j % 3 + 4j = 1 + 2j

C:\Users\username>python mod.py
1 + 2j % 3 + 4j = 1 + 2j

In the above example, we have defined the __mod__()__mod__() method in the ComplexComplex class. The __mod__()__mod__() method returns a ComplexComplex object. We have created two ComplexComplex objects named c1c1 and c2c2. We have found the remainder of the c1c1 and c2c2 objects using the %% operator. The output shows that the __mod__()__mod__() method is called when the %% operator is used with two ComplexComplex objects.

pow() Method

The __pow__()__pow__() method is called when the **** operator is used with two objects. It is used to find the power of two objects. Let’s see how to use the __pow__()__pow__() method in Python.

class Number:
    def __init__(self, num):
        self.num = num
 
    def __pow__(self, other):
        return Number(self.num ** other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 ** n2
print(f'{n1.num} ** {n2.num} = {n3.num}')

class Number:
    def __init__(self, num):
        self.num = num
 
    def __pow__(self, other):
        return Number(self.num ** other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 ** n2
print(f'{n1.num} ** {n2.num} = {n3.num}')

Output:

C:\Users\username>python pow.py
2 ** 3 = 8

C:\Users\username>python pow.py
2 ** 3 = 8

In the above example, we have defined the __pow__()__pow__() method in the NumberNumber class. The __pow__()__pow__() method returns a NumberNumber object. We have created two NumberNumber objects named n1n1 and n2n2. We have found the power of the n1n1 and n2n2 objects using the **** operator. The output shows that the __pow__()__pow__() method is called when the **** operator is used with two NumberNumber objects.

and() Method

The __and__()__and__() method is called when the && operator is used with two objects. It is used to perform the bitwise AND operation on two objects. Let’s see how to use the __and__()__and__() method in Python.

class Number:
    def __init__(self, num):
        self.num = num
 
    def __and__(self, other):
        return Number(self.num & other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 & n2
print(f'{n1.num} & {n2.num} = {n3.num}')

class Number:
    def __init__(self, num):
        self.num = num
 
    def __and__(self, other):
        return Number(self.num & other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 & n2
print(f'{n1.num} & {n2.num} = {n3.num}')

Output:

C:\Users\username>python and.py
2 & 3 = 2

C:\Users\username>python and.py
2 & 3 = 2

In the above example, we have defined the __and__()__and__() method in the NumberNumber class. The __and__()__and__() method returns a NumberNumber object. We have created two NumberNumber objects named n1n1 and n2n2. We have performed the bitwise AND operation on the n1n1 and n2n2 objects using the && operator. The output shows that the __and__()__and__() method is called when the && operator is used with two NumberNumber objects.

or() Method

The __or__()__or__() method is called when the || operator is used with two objects. It is used to perform the bitwise OR operation on two objects. Let’s see how to use the __or__()__or__() method in Python.

class Number:
    def __init__(self, num):
        self.num = num
 
    def __or__(self, other):
        return Number(self.num | other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 | n2
print(f'{n1.num} | {n2.num} = {n3.num}')

class Number:
    def __init__(self, num):
        self.num = num
 
    def __or__(self, other):
        return Number(self.num | other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 | n2
print(f'{n1.num} | {n2.num} = {n3.num}')

Output:

C:\Users\username>python or.py
2 | 3 = 3

C:\Users\username>python or.py
2 | 3 = 3

In the above example, we have defined the __or__()__or__() method in the NumberNumber class. The __or__()__or__() method returns a NumberNumber object. We have created two NumberNumber objects named n1n1 and n2n2. We have performed the bitwise OR operation on the n1n1 and n2n2 objects using the || operator. The output shows that the __or__()__or__() method is called when the || operator is used with two NumberNumber objects.

xor() Method

The __xor__()__xor__() method is called when the ^^ operator is used with two objects. It is used to perform the bitwise XOR operation on two objects. Let’s see how to use the __xor__()__xor__() method in Python.

class Number:
    def __init__(self, num):
        self.num = num
 
    def __xor__(self, other):
        return Number(self.num ^ other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 ^ n2
print(f'{n1.num} ^ {n2.num} = {n3.num}')

class Number:
    def __init__(self, num):
        self.num = num
 
    def __xor__(self, other):
        return Number(self.num ^ other.num)
 
n1 = Number(2)
n2 = Number(3)
n3 = n1 ^ n2
print(f'{n1.num} ^ {n2.num} = {n3.num}')

Output:

C:\Users\username>python xor.py
2 ^ 3 = 1

C:\Users\username>python xor.py
2 ^ 3 = 1

In the above example, we have defined the __xor__()__xor__() method in the NumberNumber class. The __xor__()__xor__() method returns a NumberNumber object. We have created two NumberNumber objects named n1n1 and n2n2. We have performed the bitwise XOR operation on the n1n1 and n2n2 objects using the ^^ operator. The output shows that the __xor__()__xor__() method is called when the ^^ operator is used with two NumberNumber objects.

lt() Method

The __lt__()__lt__() method is called when the << operator is used with two objects. It is used to compare two objects. It returns TrueTrue if the first object is less than the second object. Otherwise, it returns FalseFalse. Let’s see how to use the __lt__()__lt__() method in Python.

class Number:
    def __init__(self, num):
        self.num = num
 
    def __lt__(self, other):
        return self.num < other.num
 
n1 = Number(2)
n2 = Number(3)
print(f'{n1.num} < {n2.num} = {n1 < n2}')
print(f'{n2.num} < {n1.num} = {n2 < n1}')

class Number:
    def __init__(self, num):
        self.num = num
 
    def __lt__(self, other):
        return self.num < other.num
 
n1 = Number(2)
n2 = Number(3)
print(f'{n1.num} < {n2.num} = {n1 < n2}')
print(f'{n2.num} < {n1.num} = {n2 < n1}')

Output:

C:\Users\username>python lt.py
2 < 3 = True
3 < 2 = False

C:\Users\username>python lt.py
2 < 3 = True
3 < 2 = False

In the above example, we have defined the __lt__()__lt__() method in the NumberNumber class. The __lt__()__lt__() method returns TrueTrue if the first object is less than the second object. Otherwise, it returns FalseFalse. We have created two NumberNumber objects named n1n1 and n2n2. We have compared the n1n1 and n2n2 objects using the << operator. The output shows that the __lt__()__lt__() method is called when the << operator is used with two NumberNumber objects.