Реализация класса Matrix (ООП на Python)

from sys import stdin
class matrix():
    def __init__(self,list_of_lists):
        self.mat = list_of_lists
    def str(self):
        string = ''
        for i in self.mat:
            for j in i:
                string = string+'%s\t' %(j)
            string = string[:-1]
            string = string+'\n'
        string = string[:-1]
        return string
 
a = [[1,2,3],[4,5,6],[7,8,9]]
m = matrix(a)
print(m.str())
 
exec(stdin.read())

class Matrix(object):
    def __init__(self, matrix):
        self.matrix = matrix
 
    def __str__(self):
        return '\n'.join([''.join(['%d\t' % i for i in row]) for row in matrix])
 
    @property
    def size(self):
        rows = len(self.matrix)
        cols = 0
        for row in self.matrix:
            if len(row) > cols:
                cols = len(row)
 
        return (rows, cols)

import random
 
matrix = [[i for i in range(random.randrange(0, 9))] for i in range(random.randrange(0, 9))]
inst = Matrix(matrix)
print(inst)
print(inst.size)

 def __str__(self):
        return '\n'.join([''.join(['%d\t' % i for i in row]) for row in self.matrix])

def __init__(self,list_of_lists):
    self.mat = list_of_lists

def __mul__(self, other):
        if isinstance(other, int) or isinstance(other, float):
            result = [[other * x for x in y] for y in self.list2D]
            return matrix(result)
        elif self.dim_C != other.dim_R:
            return 'Нельзя перемножить матрицы таких размерностей'
        else:
            a = range(self.dim_C)
            b = range(self.dim_R)
            c = range(other.dim_C)
            result = []
            for i in b:
                res = []
                for j in c:
                    el, m = 0, 0
                    for k in a:
                        m = self.list2D[i][k] * other.list2D[k][j]
                        el += m
                    res.append(el)
                result.append(res)
            return matrix(result)
    def __rmul__(self, other):
        return self.__mul__(other)

from sys import stdin
from copy import deepcopy
 
 
class MatrixError(BaseException):
    def __init__(self, Matrix, other):
        self.matrix1 = Matrix
        self.matrix2 = other
 
 
class Matrix():
    def __init__(self, matrix):
        self.matrix = deepcopy(matrix)
 
    def __str__(self):
        string = ''
        for i in self.matrix:
            for j in i:
                string += '%s\t' % j
            string = string[:-1]
            string += '\n'
        string = string[:-1]
        return string
 
    def size(self):
        rows = len(self.matrix)
        cols = 0
        for row in self.matrix:
            if len(row) > cols:
                cols = len(row)
        return (rows, cols)
 
    def __getitem__(self, idx):
        return self.matrix[idx]
 
    def __add__(self, other):
        if len(self.matrix) == len(other.matrix):
            lenght = len(self.matrix[0])
            for row in self.matrix:
                if len(row) != lenght:
                    raise MatrixError(self, other)
            for row2 in other.matrix:
                if len(row2) != lenght:
                    raise MatrixError(self, other)
            result = []
            numbers = []
            for i in range(len(self.matrix)):
                for j in range(len(self.matrix[0])):
                    summa = other.matrix[i][j] + self.matrix[i][j]
                    numbers.append(summa)
                    if len(numbers) == len(self.matrix[0]):
                        result.append(numbers)
                        numbers = []
            return Matrix(result)
        else:
            raise MatrixError(self, other)
 
    def __mul__(self, other):
        if isinstance(other, int) or isinstance(other, float):
            result = [[other * j for j in i] for i in self.matrix]
            return Matrix(result)
 
    __rmul__ = __mul__
 
    def transpose(self):
        transMatrix = list(zip(*self.matrix))
        self.matrix = transMatrix
        return Matrix(transMatrix)
 
    def transposed(self):
        transMatrix = list(zip(*self.matrix))
        return Matrix(transMatrix)
 
 
exec(stdin.read())

from sys import stdin
from copy import deepcopy
 
 
class Matrix:
    def __init__(self, matrix):
        self.matrix = deepcopy(matrix)
 
    def __str__(self):  # без аргументов
        return '\n'.join(['\t'.join(map(str, list)) for list in self.matrix])
 
    def __add__(self, other):
        return Matrix()
 
    def size(self):  # без аргументов!
        return (len(self.matrix), len(self.matrix[0]))
 
    def __add__(self, other):
        return Matrix(list(map(
                        lambda x, y: list(map(lambda z, w: z + w, x, y)),
                        self.matrix, other.matrix)))
 
    def __mul__(self, other):
        return Matrix([[i * other for i in list] for list in self.matrix])
 
    __rmul__ = __mul__
 
 
exec(stdin.read())