矩阵构建在Python

Question

在一个代码块，我发现下面的东西

M = [3,4,5] 

from math import * 

class matrix: 

    # implements basic operations of a matrix class 

    def __init__(self, value): 
     self.value = value 
     self.dimx = len(value) 
     self.dimy = len(value[0]) 
     if value == [[]]: 
      self.dimx = 0 

    def zero(self, dimx, dimy): 
     # check if valid dimensions 
     if dimx < 1 or dimy < 1: 
      raise ValueError, "Invalid size of matrix" 
     else: 
      self.dimx = dimx 
      self.dimy = dimy 
      self.value = [[0 for row in range(dimy)] for col in range(dimx)] 

    def identity(self, dim): 
     # check if valid dimension 
     if dim < 1: 
      raise ValueError, "Invalid size of matrix" 
     else: 
      self.dimx = dim 
      self.dimy = dim 
      self.value = [[0 for row in range(dim)] for col in range(dim)] 
      for i in range(dim): 
       self.value[i][i] = 1 

    def show(self): 
     for i in range(self.dimx): 
      print self.value[i] 
     print ' ' 

    def __add__(self, other): 
     # check if correct dimensions 
     if self.dimx != other.dimx or self.dimy != other.dimy: 
      raise ValueError, "Matrices must be of equal dimensions to add" 
     else: 
      # add if correct dimensions 
      res = matrix([[]]) 
      res.zero(self.dimx, self.dimy) 
      for i in range(self.dimx): 
       for j in range(self.dimy): 
        res.value[i][j] = self.value[i][j] + other.value[i][j] 
      return res 

    def __sub__(self, other): 
     # check if correct dimensions 
     if self.dimx != other.dimx or self.dimy != other.dimy: 
      raise ValueError, "Matrices must be of equal dimensions to subtract" 
     else: 
      # subtract if correct dimensions 
      res = matrix([[]]) 
      res.zero(self.dimx, self.dimy) 
      for i in range(self.dimx): 
       for j in range(self.dimy): 
        res.value[i][j] = self.value[i][j] - other.value[i][j] 
      return res 

    def __mul__(self, other): 
     # check if correct dimensions 
     if self.dimy != other.dimx: 
      raise ValueError, "Matrices must be m*n and n*p to multiply" 
     else: 
      # subtract if correct dimensions 
      res = matrix([[]]) 
      res.zero(self.dimx, other.dimy) 
      for i in range(self.dimx): 
       for j in range(other.dimy): 
        for k in range(self.dimy): 
         res.value[i][j] += self.value[i][k] * other.value[k][j] 
      return res 

    def transpose(self): 
     # compute transpose 
     res = matrix([[]]) 
     res.zero(self.dimy, self.dimx) 
     for i in range(self.dimx): 
      for j in range(self.dimy): 
       res.value[j][i] = self.value[i][j] 
     return res 

    # Thanks to Ernesto P. Adorio for use of Cholesky and CholeskyInverse functions 

    def Cholesky(self, ztol=1.0e-5): 
     # Computes the upper triangular Cholesky factorization of 
     # a positive definite matrix. 
     res = matrix([[]]) 
     res.zero(self.dimx, self.dimx) 

     for i in range(self.dimx): 
      S = sum([(res.value[k][i])**2 for k in range(i)]) 
      d = self.value[i][i] - S 
      if abs(d) < ztol: 
       res.value[i][i] = 0.0 
      else: 
       if d < 0.0: 
        raise ValueError, "Matrix not positive-definite" 
       res.value[i][i] = sqrt(d) 
      for j in range(i+1, self.dimx): 
       S = sum([res.value[k][i] * res.value[k][j] for k in range(self.dimx)]) 
       if abs(S) < ztol: 
        S = 0.0 
       res.value[i][j] = (self.value[i][j] - S)/res.value[i][i] 
     return res 

    def CholeskyInverse(self): 
     # Computes inverse of matrix given its Cholesky upper Triangular 
     # decomposition of matrix. 
     res = matrix([[]]) 
     res.zero(self.dimx, self.dimx) 

     # Backward step for inverse. 
     for j in reversed(range(self.dimx)): 
      tjj = self.value[j][j] 
      S = sum([self.value[j][k]*res.value[j][k] for k in range(j+1, self.dimx)]) 
      res.value[j][j] = 1.0/tjj**2 - S/tjj 
      for i in reversed(range(j)): 
       res.value[j][i] = res.value[i][j] = -sum([self.value[i][k]*res.value[k][j] for k in range(i+1, self.dimx)])/self.value[i][i] 
     return res 

    def inverse(self): 
     aux = self.Cholesky() 
     res = aux.CholeskyInverse() 
     return res 

    def __repr__(self): 
     return repr(self.value) 

for n in range(len(M)): 
    Z = matrix([[M[n]]]) 
    Z.show() 

现在，如果我跑我得到了下面的输出代码：

[3] 
[4] 
[5] 

现在，我不明白是什么输出手段以及如何解释这一点。具体的代码在上面的下面一行我不明白

Z = matrix([[M[n]]]) 

谁能请解释我的代码和上面的一行的输出？

Answer 1

该代码创建三个1x1矩阵，即三个矩阵，其中每个矩阵包含一个单独的元素并打印出来。这就是你看到的[3],[4],[5]：三个1x1矩阵。

对于[[M[n]]]：矩阵构造函数需要矩阵的值，该矩阵是一个二维数组。这解释了[[ .. ]]。你可以通过调用

data = [ [1,0], [0,1] ] 
matrix(data) 

构造一个2×2单位矩阵（即是包含其他两个列表，其中的每一个具有两个单元的明细表。）

在这种情况下，矩阵被初始化与单个元素，这恰好是M[n]。

的代码可以简化为：

for n in M: 
    Z = matrix([[n]]) 
    Z.show() 

这使得它更易于阅读

Answer 2

最后一个for循环是一个决定性的输出：

for n in range(len(M)): 
    Z = matrix([[M[n]]]) 
    Z.show() 

由于M=[3,4,5]，这再次拨打第二条线三次：

Z = matrix([[3]]) 
Z.show() 
Z = matrix([[4]]) 
Z.show() 
Z = matrix([[5]]) 
Z.show() 

每次我们将Z设置为1x1矩阵，例如， [[3]]，并应用show矩阵方法，其实质上以良好的方式打印Z。