numpy数组和矩阵有什么区别？我应该使用哪一个？

Question

每种方法都有什么优点和缺点？

从我所见，如果需要的话，两者都可以作为对方的替代品，那么我是应该使用两个还是只使用其中一个呢？

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

- levesque

---

我没有足够的信息来证明答案，但从我所知道的来看，主要区别在于乘法的实现方式。矩阵执行矩阵/张量乘法，而数组将执行逐元素乘法。 - Mike Axiak

Python 3.5 引入了中缀符号 @ 用于矩阵乘法（PEP 465），NumPy 1.10 也新增了对它的支持。因此，如果你使用的是 Python 3.5+ 和 NumPy 1.10+，那么你可以只写 A @ B 而不是 A.dot(B)，其中 A 和 B 是二维的 ndarray。这就消除了使用 matrix 而非普通 ndarray 的主要优势，个人认为。 - MiniQuark

Answer 1

Numpy的矩阵是严格的二维数组，而numpy的数组（ndarrays）是多维的。矩阵对象是ndarray的子类，因此它们继承了所有ndarrays的属性和方法。

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数组始终遵守操作按元素进行（除了新的 @ 运算符）。 因此，如果 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。

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

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

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

相反，如果你只使用ndarrays，那么除了稍微不同的函数/符号外，你可以做到矩阵对象所能做的一切，甚至更多。

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

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

---

这里有一个关于NumPy arrays与NumPy matrices之间差异的概要这里。

- unutbu

---

对于那些想知道，在一个矩阵中使用 mat**n 可以通过 reduce(np.dot, [arr]*n) 不太优雅地应用到一个数组上。 - askewchan

只需使用np.linalg.matrix_power(mat, n)函数即可。 - Eric

我在想矩阵是否会更快...你会认为它们需要执行比ndarray更少的检查。 - PascalVKooten

实际上，timeit测试表明，诸如np.dot(array2, array2)之类的ndarray操作比matrix1*matrix2更快。这是有道理的，因为matrix是ndarray的子类，它重写了特殊方法，如__mul__。matrix.__mul__调用np.dot。因此，在这里存在代码重用。使用matrix*matrix需要额外的函数调用，而不是执行更少的检查。因此，使用matrix的优势纯粹是语法上的，而不是更好的性能。 - unutbu

当手动输入2D数组时，我发现np.asarray(np.mat('a b; c d'))很方便。 - kjl

Answer 2

Scipy.org建议您使用数组：

* 'array'或'matrix'？我应该使用哪一个？ - 简短回答

使用数组。

• 它们支持在MATLAB中支持的多维数组代数。
• 它们是NumPy的标准向量/矩阵/张量类型。许多NumPy函数返回数组，而不是矩阵。
• 元素按操作和线性代数操作之间有明确区别。
• 如果需要，您可以拥有标准向量或行/列向量。

在Python 3.5之前，使用数组类型唯一的缺点是您必须使用dot而不是*来乘（缩小）两个张量（标量积，矩阵向量乘法等）。自Python 3.5以来，您可以使用矩阵乘法@操作符。

基于上述原因，我们打算最终弃用matrix。

- Lee

---

尽管被接受的答案提供了更多信息，但真正的答案确实是要坚持使用 ndarray。使用 matrix 的主要论点是如果您的代码涉及大量线性代数，在所有调用 dot 函数时看起来会更不清晰。但是随着 @-运算符被接受用于矩阵乘法，这个论点将在未来消失，参见 PEP 465。这需要 Python 3.5 和最新版本的 Numpy。矩阵类可能会在遥远的未来被弃用，因此最好为新代码使用 ndarray... - Bas Swinckels

那个页面优雅地忽略了 scipy.sparse 矩阵。如果你的代码中同时使用密集矩阵和稀疏矩阵，最好还是坚持使用 matrix。 - David Nemeskey

在我看来，数组的主要缺点是列切片会返回扁平数组，这可能会令人困惑，并且在数学上并不完全正确。这也导致了一个重要的缺点，即 numpy 数组不能像 scipy.sparse 矩阵那样进行处理，而 numpy 矩阵基本上可以与稀疏矩阵自由交换。在这种情况下，scipy 建议使用数组，却没有提供兼容的稀疏数组，有点荒谬。 - Radio Controlled

Answer 3

只是为unutbu的列表增加一个案例。 对于我来说，numpy ndarrays相比于numpy矩阵或类似于matlab的矩阵语言最大的实践差异之一是在reduce操作中未保留维度。矩阵始终是2D的，而例如数组的平均值则少了一个维度。 例如，使矩阵或数组的行均值为零： 使用矩阵

>>> 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稀疏矩阵在像乘法这样的运算符方面始终是矩阵。

- Josef

Answer 4

根据官方文件的说法，由于将来会被移除，不再建议使用矩阵类（matrix class）。 正如其他答案所述，您可以使用NumPy数组实现所有操作。 链接：https://numpy.org/doc/stable/reference/generated/numpy.matrix.html

- Aks

Answer 5

正如其他人所提到的，matrix的主要优点或许在于它为矩阵乘法提供了方便的符号表示。

然而，在 Python 3.5 中终于有了专门用于矩阵乘法的中缀运算符：@。具体可以参考此处。

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

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

所以现在，即使有疑问，你也应该坚持使用ndarray。

- Peque

Answer 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

Solving a Linear System:

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

- rubengavidia0x

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

- Meowf