I am trying to write a class that has a mutiplication operator overloading function that is used to handle matrix multiplcation.
My method is

1. Transpose a matrix(I write a transpose function inside the class) which is called T


2. Write a dot product function which handle the mutiplication for Row A and Row B(Since I already transposed matrix B).


3. Write the multiplication operator overloading function which call the transpose and dot product function.

My problem:

1. So the problem I have is when I try to call the function dot, it reminds me that "dot() takes 2 positional arguments but 3 were given". I kind of knowing why as dot(self,other) can only take one more argument besides itself? However, my method requires me to sepcifically tell the dot function that I want to input specific row of the Matrix. That's why I used self.g[i]. The thing I don't understand is my function dot is able to take two inputs which is self and other, when I specify in mul function, I also give two inputs "self.dot(self.g[i],other.g[j])", why the program counts as three arguments.


2. My second question is about the "self", I know when I want to call a function inside the class, I need to use self.functionname syntax, I was really confused here, self is the object, to me "self" represents Matrix A and "other" represents Matrix B, does the program get confused if I use self to call the function?

Honestly, I am pretty confused about the utilization of self in the class, is there any examples recommended that could help beginner like me to grasp this concept?

Thanks in advance guys.

Here are my codes

Constructor

# Constructor

def __init__(self, grid):  # I don't know if i need another input here or not like def __init__(self, grid , matrixB)

    self.g = grid

    self.h = len(grid)

    self.w = len(grid[0])

Mutiplication operator overloading

def __mul__(self, other):



    af_trans = other.T() # Transpose the second matrix

    for i in range(0,self.h):

        every_row=

        for j in range(0,self.h):

            element_product = self.dot(self.g[i],other.g[j])

            every_row.append(element_product)

    return every_row

Transpose function

def T(self):



    T_matrix = 

    for i in range(0,self.h):

        new_row = 

        for j in range(0,self.w):

            T_element = self.g[j][i]

            new_row.append(T_element)

        T_matrix.append(new_row)

    return T_matrix

Dotproduct

def dot(self,other):  

    sumproduct=0

    for i in range(0,self.h):  

        element_product = self.g[i][i]*other.g[i][i] #The first element 

                        of Matrix A times the first element of Matrix B

        sum_product = sum_product+element_product

    return sum_product