使用矩阵的一个优点是通过文本而不是嵌套的方括号更容易实例化。

你可以用矩阵来做

np.matrix("1, 1+1j, 0; 0, 1j, 0; 0, 0, 1")

并直接获得所需的输出:

matrix([[1.+0.j, 1.+1.j, 0.+0.j],
        [0.+0.j, 0.+1.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j]])

如果你使用数组，这是行不通的:

np.array("1, 1+1j, 0; 0, 1j, 0; 0, 0, 1")

输出:

array('1, 1+1j, 0; 0, 1j, 0; 0, 0, 1', dtype='<U29')

Numpy矩阵严格是2维的，而Numpy数组(ndarray)则是 n维。矩阵对象是ndarray的子类，所以它们继承了所有 ndarray的属性和方法。

numpy矩阵的主要优点是它们提供了一种方便的符号 对于矩阵乘法:如果a和b是矩阵，那么a*b就是它们的矩阵 产品。

import numpy as np

a = np.mat('4 3; 2 1')
b = np.mat('1 2; 3 4')
print(a)
# [[4 3]
#  [2 1]]
print(b)
# [[1 2]
#  [3 4]]
print(a*b)
# [[13 20]
#  [ 5  8]]

另一方面，从Python 3.5开始，NumPy支持使用@操作符进行中子星矩阵乘法，因此您可以在Python >= 3.5中使用ndarray实现同样方便的矩阵乘法。

import numpy as np

a = np.array([[4, 3], [2, 1]])
b = np.array([[1, 2], [3, 4]])
print(a@b)
# [[13 20]
#  [ 5  8]]

矩阵对象和ndarray都有。t来返回转置，但是矩阵 物体也有。h表示共轭转置，i表示逆。

相反，numpy数组始终遵守操作规则 按元素应用(除了新的@操作符)。因此，如果a和b是numpy数组，那么a*b就是数组 由元素相乘组成:

c = np.array([[4, 3], [2, 1]])
d = np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]

要获得矩阵乘法的结果，可以使用np。dot(或Python中的@ >= 3.5，如上所示):

print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]

**操作符的行为也有所不同:

print(a**2)
# [[22 15]
#  [10  7]]
print(c**2)
# [[16  9]
#  [ 4  1]]

由于a是一个矩阵，a**2返回矩阵乘积a*a。 由于c是一个ndarray, c**2返回一个包含每个分量平方的ndarray element-wise。

矩阵对象和ndarray之间还有其他技术上的区别 (与np有关。拉威尔，项目选择和序列行为)。

numpy数组的主要优点是它们比 二维矩阵。当你想要一个三维数组时会发生什么?然后 你必须使用ndarray，而不是矩阵对象。因此，学习使用矩阵 对象是更多的工作——你必须学习矩阵对象操作，还有 ndarray操作。

编写混合矩阵和数组的程序会使您的生活变得困难 因为你必须跟踪你的变量是什么类型的对象，以免 乘法会返回你意想不到的结果。

相反，如果您只坚持使用ndarray，那么您可以做任何事情 矩阵对象可以做的，而且更多，除了略有不同 函数/符号。

如果你愿意放弃NumPy矩阵产品的视觉吸引力 (在Python >= 3.5中，ndarray几乎可以优雅地实现)，那么我认为NumPy数组绝对是正确的选择。

PS.当然，你真的不必以牺牲另一个为代价来选择一个， 因为np。Asmatrix和np。Asarray允许您将一个转换为另一个(如 只要数组是二维的)。

这里简要介绍了NumPy数组与NumPy矩阵之间的区别。

正如其他人所提到的，也许矩阵的主要优点是它为矩阵乘法提供了一个方便的符号。

然而，在Python 3.5中，最终有一个专用的中缀运算符用于矩阵乘法:@。

在最近的NumPy版本中，它可以与ndarray一起使用:

A = numpy.ones((1, 3))
B = numpy.ones((3, 3))
A @ B

所以现在，当你有疑问的时候，你应该坚持使用ndarray。

Numpy数组的矩阵运算:

我愿意不断更新这个答案 关于numpy数组的矩阵运算，如果一些用户有兴趣寻找关于矩阵和numpy的信息。

作为公认的答案，numpy-ref.pdf说:

类numpy。矩阵将在未来被删除。

现在需要做矩阵代数运算 使用Numpy数组。

a = np.array([[1,3],[-2,4]])
b = np.array([[3,-2],[5,6]]) 

矩阵乘法(中缀矩阵乘法)

a@b
array([[18, 16],
       [14, 28]])

置:

ab = a@b
ab.T       
array([[18, 14],
       [16, 28]])

  

矩阵的逆:

np.linalg.inv(ab)
array([[ 0.1       , -0.05714286],
       [-0.05      ,  0.06428571]])      

ab_i=np.linalg.inv(ab) 
ab@ab_i  # proof of inverse
array([[1., 0.],
       [0., 1.]]) # identity matrix 

矩阵的行列式。

np.linalg.det(ab)
279.9999999999999

求解线性方程组:

1.   x + y = 3,
    x + 2y = -8
b = np.array([3,-8])
a = np.array([[1,1], [1,2]])
x = np.linalg.solve(a,b)
x
array([ 14., -11.])
# Solution x=14, y=-11

特征值和特征向量:

a = np.array([[10,-18], [6,-11]])
np.linalg.eig(a)
(array([ 1., -2.]), array([[0.89442719, 0.83205029],
        [0.4472136 , 0.5547002 ]])

只是在unutbu的列表中添加一个案例。

对我来说，numpy ndarray与numpy矩阵或像matlab这样的矩阵语言相比，最大的实际区别之一是在约简操作中不保留维数。矩阵总是二维的，而数组的均值，例如，有一个维度少。

例如降低矩阵或数组的行:

与矩阵

>>> m = np.mat([[1,2],[2,3]])
>>> m
matrix([[1, 2],
        [2, 3]])
>>> mm = m.mean(1)
>>> mm
matrix([[ 1.5],
        [ 2.5]])
>>> mm.shape
(2, 1)
>>> m - mm
matrix([[-0.5,  0.5],
        [-0.5,  0.5]])

与数组

>>> a = np.array([[1,2],[2,3]])
>>> a
array([[1, 2],
       [2, 3]])
>>> am = a.mean(1)
>>> am.shape
(2,)
>>> am
array([ 1.5,  2.5])
>>> a - am #wrong
array([[-0.5, -0.5],
       [ 0.5,  0.5]])
>>> a - am[:, np.newaxis]  #right
array([[-0.5,  0.5],
       [-0.5,  0.5]])

我还认为混合使用数组和矩阵会带来很多“愉快的”调试时间。 然而,scipy。稀疏矩阵总是矩阵的运算符，比如乘法。

Scipy.org建议使用数组:

*'array' or 'matrix'? Which should I use? - Short answer Use arrays. They support multidimensional array algebra that is supported in MATLAB They are the standard vector/matrix/tensor type of NumPy. Many NumPy functions return arrays, not matrices. There is a clear distinction between element-wise operations and linear algebra operations. You can have standard vectors or row/column vectors if you like. Until Python 3.5 the only disadvantage of using the array type was that you had to use dot instead of * to multiply (reduce) two tensors (scalar product, matrix vector multiplication etc.). Since Python 3.5 you can use the matrix multiplication @ operator. Given the above, we intend to deprecate matrix eventually.