问题描述：

每种方式有何优点和缺点？

据我所见，如果需要的话，其中任何一个都可以替代另一个，所以我应该同时使用两者还是只使用其中之一？

程序的风格会影响我的选择吗？我正在使用 numpy 进行一些机器学习，因此确实有很多矩阵，但也有很多向量（数组）。

解决方案 1：

Numpy矩阵是严格的二维的，而 numpy数组(ndarrays) 是 N 维的。 Matrix对象是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 中使用 ndarrays 实现矩阵乘法的相同便利。

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]]

矩阵对象和 ndarrays 都必须.T返回转置，但矩阵对象还具有.H共轭转置和.I逆。

相比之下，numpy 数组始终遵循按元素应用操作的规则（new@运算符除外）。因此，如果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。

np.ravel矩阵对象和 ndarrays 之间还存在其他技术差异（与项目选择和序列行为有关）。

numpy 数组的主要优势在于它们比二维矩阵更通用。当你需要三维数组时会发生什么？那么你必须使用 ndarray，而不是矩阵对象。因此，学习使用矩阵对象需要做更多的工作——你必须学习矩阵对象操作和 ndarray 操作。

编写一个混合矩阵和数组的程序会让你的生活变得困难，因为你必须跟踪变量的对象类型，以免乘法返回你不期望的东西。

相反，如果你只坚持使用 ndarrays，那么你可以做矩阵对象可以做的所有事情，甚至更多，只是函数/符号略有不同。

如果您愿意放弃 NumPy 矩阵乘积符号的视觉吸引力（可以使用 Python >= 3.5 中的 ndarrays 几乎同样优雅地实现），那么我认为 NumPy 数组绝对是最佳选择。

PS.当然，你真的不必以牺牲另一个为代价来选择其中一个，因为np.asmatrix和np.asarray允许你将一个转换为另一个（只要数组是二维的）。

这里arrays是 NumPy与 NumPy matrixes之间差异的概要。

解决方案 2：

Scipy.org 建议您使用数组：

• '数组' 还是 '矩阵'？我应该使用哪一个？ - 简答

使用数组。

• 它们支持 MATLAB 中支持的多维数组代数

• 它们是 NumPy 的标准向量/矩阵/张量类型。许多 NumPy 函数返回数组，而不是矩阵。

• 元素运算和线性代数运算之间有明显的区别。

• 如果您愿意，您可以拥有标准向量或行/列向量。

直到 Python 3.5 版本，使用数组类型的唯一缺点是您必须使用dot而不是*来乘以（减少）两个张量（标量积、矩阵向量乘法等）。从 Python 3.5 版本开始，您可以使用矩阵乘法@运算符。

鉴于上述情况，我们打算matrix最终弃用它。

解决方案 3：

根据官方文件，不再建议使用矩阵类，因为它将来会被删除。

https://numpy.org/doc/stable/reference/ generated/numpy.matrix.html

正如其他答案已经指出的那样，您可以使用 NumPy 数组实现所有操作。

解决方案 4：

仅向 unutbu 的列表中添加一个案例。

对我来说，numpy ndarrays 与 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.sparse 矩阵始终是矩阵。

解决方案 5：

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

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

使用最新的 NumPy 版本，它可以与 s 一起使用ndarray：

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

因此，如今，当您有疑问时，更应该坚持ndarray。

解决方案 6：

使用 Numpy 数组进行矩阵运算：

如果某些用户有兴趣寻找有关矩阵和 numpy 的信息，我愿意继续更新有关使用 numpy 数组的矩阵运算的答案。

正如接受的答案和 numpy-ref.pdf 所说：

numpy.matrix 类将来会被删除。

因此现在矩阵代数运算必须使用 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 ]])

解决方案 7：

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

使用矩阵你可以做到

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