无 numpy 的标量矩阵乘法

Question

I simply want to multiply a matrix with a scalar and have a correct output. My code works but it updates the old matrix with the new output. I've used slices as copies but I can't seem to get it to work. Numpy is not allowed for this.

I simply want to run this code multiple times on the same matrix and get the same output everytime.

class Matrix:                             
    def __init__(self, rows):             
        self.rows = rows[:]               
        self.copy = self.rows[:]          

def scale(self, w):                                                                                          
    copy = self.copy[:]                                                                                      
    for i in range(len(copy)):                                                                               
        for j in range(len(copy)):                                                                           
                                                                                                             
            copy[i][j] = copy[i][j]*w                                                                        
                                                                                                             
                                                                                       
                                                                                                             
    return copy                                                                                         
                                                                                                             

c = Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
print(c.scale(10))  
print(c.scale(10))  

Output should be:
[[10, 0, 0], [0, 10, 0], [0, 0, 10]]

[[10, 0, 0], [0, 10, 0], [0, 0, 10]]

Instead it's

[[10, 0, 0], [0, 10, 0], [0, 0, 10]]

[[100, 0, 0], [0, 100, 0], [0, 0, 100]]

Answer 1

Since the OP says that he is not allowed to use imports, the following alternative has its own implementation of deepcopy:

class Matrix:
    def __init__(self, rows):
        self.rows = rows[:]

    def deepcopy(self):
        rows = [[elem for elem in row]
             for row in self.rows
        ]
        return Matrix(rows)


    def scale(self, w):
        copy = self.deepcopy()
        copyr = copy.rows
        for i in range(len(copyr)):
            for j in range(len(copyr)):
                copyr[i][j] = copyr[i][j] * w

        return copyr

c = Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
print(c.scale(10))
print(c.scale(10))

Answer 2

This is one of those subtleties of Python. Your code only creates one object containing the data. When you assign self.copy = self.rows[:] , you don't get a new copy of the data, you only create a new reference to the same object. Python has a built-in facility for making a deep copy.

from copy import deepcopy


class Matrix:
    def __init__(self, rows):
        self.rows = rows[:]


    def scale(self, w):
        copy = deepcopy(self.rows)
        for i in range(len(copy)):
            for j in range(len(copy)):
                copy[i][j] = copy[i][j] * w

        return copy

c = Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
print(c.scale(10))
print(c.scale(10))

Output:

[[10, 0, 0], [0, 10, 0], [0, 0, 10]]
[[10, 0, 0], [0, 10, 0], [0, 0, 10]]