python中的矩阵创建

在一段代码中，我发现了以下内容

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()

现在我不明白输出意味着什么以及如何解释这个。特别是上面的代码行，我无法理解

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

---

谁能给我解释一下代码的输出和上面的单行吗？

代码创建了三个1x1矩阵，即三个矩阵，其中每个矩阵包含一个元素，并打印它们。这就是您看到的

[3]

，

[4]

，

[5]

三个1x1矩阵

对于

[[M[n]]]

：矩阵构造函数希望矩阵有一个值，它是一个二维数组。这解释了

[[…]]

。您可以通过调用

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

（这是一个包含两个其他列表的列表，每个列表都有两个元素。）

在这种情况下，矩阵用单个元素初始化，每个元素恰好是

M[n]

代码可以简化为：

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

---

这使得阅读更容易

代码创建了三个1x1矩阵，即三个矩阵，其中每个矩阵包含一个元素，并打印它们。这就是您看到的

[3]

，

[4]

，

[5]

三个1x1矩阵

对于

[[M[n]]]

：矩阵构造函数希望矩阵有一个值，它是一个二维数组。这解释了

[[…]]

。您可以通过调用

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

（这是一个包含两个其他列表的列表，每个列表都有两个元素。）

在这种情况下，矩阵用单个元素初始化，每个元素恰好是

M[n]

代码可以简化为：

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

---

这使得读取更容易

最后一个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

。

最后一个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

matrix方法，该方法基本上可以很好地打印

Z

。

使用numpy matrix类会更好。。。这是来自Udacity CS373吗？您可以更好地使用numpy矩阵类。。。这是Udacity CS373的吗？