# Operator overloading

**Hey there!** 🌟 Today, we’re going to learn about something super cool in Python called **operator overloading**. Think of it like giving special powers to our normal math symbols like ‘`+'`

, `'-`

‘, ‘`*'`

, and more. With these powers, we can teach them to do different things depending on what they’re working with. Ready? Let’s dive in!

#### What is Operator Overloading?

Imagine you have a magical toolbox 🧰. Inside, you have tools that can do different things based on what you tell them to do. In Python, these tools are our operators (like ‘`+'`

, ‘`-'`

, ‘`*'`

, etc.). Operator overloading is like teaching these tools new tricks!

Normally, when you use the ‘`+'`

operator, it adds numbers:

`3 + 4 # This gives us 7`

But what if we want to add other things, like two baskets of apples? We can use operator overloading to teach ‘`+'`

how to add our custom objects, like baskets of apples!

#### How to Overload Operators

To overload an operator in Python, we use special methods. These methods start and end with double underscores, like ‘`__add__'`

for the `+`

operator. Let’s see an example!

###### Example: Adding Points

Let’s say we have a class called `Point`

that represents points on a graph. Each point has an `x`

and `y`

coordinate.

```
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# Overloading the + operator
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __str__(self):
return f"({self.x}, {self.y})"
# Create two points
p1 = Point(1, 2)
p2 = Point(3, 4)
# Add the points
p3 = p1 + p2
print(p3) # Output: (4, 6)
```

In this example, we taught the `+`

operator how to add two `Point`

objects together by adding their `x`

and `y`

values.

#### Practice Questions

###### Question 1: Overload the `-`

Operator

Create a class called ‘* Vector‘ *that represents a 2D vector with ‘

`x'`

and ‘`y'`

components. Overload the ‘`-'`

operator to subtract one vector from another.**Solution:**

```
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
# Overloading the - operator
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __str__(self):
return f"({self.x}, {self.y})"
# Create two vectors
v1 = Vector(5, 7)
v2 = Vector(2, 3)
# Subtract the vectors
v3 = v1 - v2
print(v3) # Output: (3, 4)
```

###### Question 2: Overload the ‘`*'`

Operator

Create a class called * 'Number‘ *that represents a number. Overload the ‘

`*`

‘ operator to multiply two numbers.**Solution:**

```
class Number:
def __init__(self, value):
self.value = value
# Overloading the * operator
def __mul__(self, other):
return Number(self.value * other.value)
def __str__(self):
return str(self.value)
# Create two numbers
n1 = Number(4)
n2 = Number(5)
# Multiply the numbers
n3 = n1 * n2
print(n3) # Output: 20
```

#### More Special Methods

Here are some other special methods you can overload:

`__add__(self, other)`

:`+`

operator`__sub__(self, other)`

:`-`

operator`__mul__(self, other)`

:`*`

operator`__truediv__(self, other)`

:`/`

operator`__floordiv__(self, other)`

:`//`

operator`__mod__(self, other)`

:`%`

operator`__pow__(self, other)`

:`**`

operator

#### Practice More!

###### Question 3: Overload the `/`

Operator

Create a class called ‘* Fraction‘ *that represents a fraction with a numerator and denominator. Overload the ‘

`/'`

operator to divide one fraction by another.**Solution:**

```
class Fraction:
def __init__(self, numerator, denominator):
self.numerator = numerator
self.denominator = denominator
# Overloading the / operator
def __truediv__(self, other):
return Fraction(self.numerator * other.denominator, self.denominator * other.numerator)
def __str__(self):
return f"{self.numerator}/{self.denominator}"
# Create two fractions
f1 = Fraction(1, 2)
f2 = Fraction(3, 4)
# Divide the fractions
f3 = f1 / f2
print(f3) # Output: 4/6 (or simplified to 2/3)
```

Operator overloading allows us to define how operators like ‘`+'`

, ‘`-'`

, and ‘`*'`

work with our custom classes. We do this by defining special methods in our classes. This makes our code more intuitive and allows us to work with our custom objects just like we do with built-in types.

Now, you have the magical power to teach operators new tricks! 🪄✨ Keep practicing, and soon you’ll be creating even more powerful and flexible Python programs. Happy coding!