Today we’ll do some operator overloading, or change the behavior of some infix operators (+ and *) for our own handmade classes.

There are legitimate reasons for doing so: if adding a behavior for + makes sense for your class, you can improve the readability of your code and make your classes easier to use. Of course, it’s also a power that can be abused (the creator of Java did not include operator overloading in that language because he said he saw it abused in C++, which is probably a reflection of the character of C++ programmers).

For example, let’s look at the behavior of + for built-in tuples and lists.

x_list = [2,3,4] y_list = [5,6,7] add_list = x_list + y_list print(add_list)

Using + on lists concatenates them! This is a problem if we were hoping to add the elements of the lists together.

### But, what if I want + to do vector addition and * vector multiplication?!

# we could use numpy, of course import numpy as np x = np.array((2,3,4)) y = np.array([5,6,7]) add_np_array = x+y print(add_np_array) mult_np_array = x*y print(mult_np_array)

### But using numpy isn’t so much fun, so let’s build our own vector

We’ll build our own tuple class and call it my_vector. We’ll overload + to make it do vector addition.

import numpy as np import itertools class my_tuple: '''Create my own tuple class that overloads + and * so I can get vector addition and multiplication. It may also overload some operator in some unexpected way, but I won't tell you how, muahahaha''' def __init__(self , data): self.data= tuple(data) def __iter__(self): return iter(self.data) def __repr__(self): return str(self.data) def __add__(self,other): combo = itertools.zip_longest(self,other,fillvalue=0.0) return my_tuple(a+b for a,b in combo)

What happens if you run the following code now using our new class?

tup = my_tuple((2,3,4,25)) tup2 = my_tuple((5,6,7)) add_my_tup = tup + tup2 add_my_tup

We should get the following:

(10, 18, 28, 0)

Wow, looks like our overloading worked! You can also overload other operators, including > and <. You’ll first need to know the name of the dunder method in Python (that is, __add__ for addition or __lt__ for less than), but applying it is straightforward as we saw above!