Way back when I was learning to code, the concept of overloading operators was confusing to me. I think this was partly due to the R language not having the typical definition of classes, which made it a little less straightforward to understand why operator overloading might be useful.

“When you combine two variables with the + operator how does Python know when to add them if they’re integers or concatenate them if they’re strings?”

Basically you need to tell Python what to do with the + operator so that it knows what to do given variables of a different type.

We can accomplish this by defining a class, which allows us to bundle together objects (i.e. data attributes) and functions that allow us to interact with these objects (i.e. methods). The class below defines creates a data attribute that contains the list of numbers that the user provides when it is instantiated.

class vec0:
def __init__(self, data):
self.data = data

x = vec0([1,4,1,2,6])
print(type(x))


Suppose we want to implement element-wise addition: add an a value to each element in the list. If we try to do something like x + 3 we’ll get a TypeError. We could use list comprehension but that would look a little clunky.

x_sum = [item + 3 for item in x.data]
print(x_sum)


A more concise way to implement this is to overload the + operator. We can do this by defining the add method in the above class. Below we inherit the methods from the class defined above and overload the addition operator to implement element-wise addition.

class vec1(vec0):