What are the advantages and disadvantages of each?
From what I’ve seen, either one can work as a replacement for the other if need be, so should I bother using both or should I stick to just one of them?
Will the style of the program influence my choice? I am doing some machine learning using numpy, so there are indeed lots of matrices, but also lots of vectors (arrays).
Numpy matrices are strictly 2-dimensional, while numpy arrays (ndarrays) are
N-dimensional. Matrix objects are a subclass of ndarray, so they inherit all
the attributes and methods of ndarrays.
The main advantage of numpy matrices is that they provide a convenient notation
for matrix multiplication: if a and b are matrices, then
a*b is their matrix
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]]
On the other hand, as of Python 3.5, NumPy supports infix matrix multiplication using the
@ operator, so you can achieve the same convenience of matrix multiplication with ndarrays in Python >= 3.5.
import numpy as np a = np.array([[4, 3], [2, 1]]) b = np.array([[1, 2], [3, 4]]) print([email protected]) # [[13 20] # [ 5 8]]
Both matrix objects and ndarrays have
.T to return the transpose, but matrix
objects also have
.H for the conjugate transpose, and
.I for the inverse.
In contrast, numpy arrays consistently abide by the rule that operations are
applied element-wise (except for the new
@ operator). Thus, if
b are numpy arrays, then
a*b is the array
formed by multiplying the components element-wise:
c = np.array([[4, 3], [2, 1]]) d = np.array([[1, 2], [3, 4]]) print(c*d) # [[4 6] # [6 4]]
To obtain the result of matrix multiplication, you use
@ in Python >= 3.5, as shown above):
print(np.dot(c,d)) # [[13 20] # [ 5 8]]
** operator also behaves differently:
print(a**2) # [[22 15] # [10 7]] print(c**2) # [[16 9] # [ 4 1]]
a is a matrix,
a**2 returns the matrix product
c is an ndarray,
c**2 returns an ndarray with each component squared
There are other technical differences between matrix objects and ndarrays
(having to do with
np.ravel, item selection and sequence behavior).
The main advantage of numpy arrays is that they are more general than
2-dimensional matrices. What happens when you want a 3-dimensional array? Then
you have to use an ndarray, not a matrix object. Thus, learning to use matrix
objects is more work — you have to learn matrix object operations, and
Writing a program that mixes both matrices and arrays makes your life difficult
because you have to keep track of what type of object your variables are, lest
multiplication return something you don’t expect.
In contrast, if you stick solely with ndarrays, then you can do everything
matrix objects can do, and more, except with slightly different
If you are willing to give up the visual appeal of NumPy matrix product
notation (which can be achieved almost as elegantly with ndarrays in Python >= 3.5), then I think NumPy arrays are definitely the way to go.
PS. Of course, you really don’t have to choose one at the expense of the other,
np.asarray allow you to convert one to the other (as
long as the array is 2-dimensional).
There is a synopsis of the differences between NumPy
arrays vs NumPy
Just to add one case to unutbu’s list.
One of the biggest practical differences for me of numpy ndarrays compared to numpy matrices or matrix languages like matlab, is that the dimension is not preserved in reduce operations. Matrices are always 2d, while the mean of an array, for example, has one dimension less.
For example demean rows of a matrix or array:
>>> 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]])
I also think that mixing arrays and matrices gives rise to many “happy” debugging hours.
However, scipy.sparse matrices are always matrices in terms of operators like multiplication.
*‘array’ or ‘matrix’? Which should I use? – Short answer
- They support multidimensional array algebra that is supported in
- 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
- You can have standard vectors or row/column vectors if you
Until Python 3.5 the only disadvantage of using the array type
was that you had to use
*to multiply (reduce) two
tensors (scalar product, matrix vector multiplication etc.). Since
Python 3.5 you can use the matrix multiplication
Given the above, we intend to deprecate
As others have mentioned, perhaps the main advantage of
matrix was that it provided a convenient notation for matrix multiplication.
With recent NumPy versions, it can be used with
A = numpy.ones((1, 3)) B = numpy.ones((3, 3)) A @ B
So nowadays, even more, when in doubt, you should stick to
As per the official documents, it’s not anymore advisable to use matrix class since it will be removed in the future.
As other answers already state that you can achieve all the operations with NumPy arrays.
An advantage of using matrices is for easier instantiation through text rather than nested square brackets.
With matrices you can do
np.matrix("1, 1+1j, 0; 0, 1j, 0; 0, 0, 1")
and get the desired output directly:
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]])
If you use arrays, this does not work:
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')
I would like to keep updating this answer
about matrix operations with numpy arrays if some users are interested looking for information about matrices and numpy.
As the accepted answer, and the numpy-ref.pdf said:
class numpy.matrix will be removed in the future.
So now matrix algebra operations has to be done
with Numpy Arrays.
a = np.array([[1,3],[-2,4]]) b = np.array([[3,-2],[5,6]])
Matrix Multiplication (infix matrix multiplication)
[email protected] array([[18, 16], [14, 28]])
ab = [email protected] ab.T array([[18, 14], [16, 28]])
Inverse of a matrix:
np.linalg.inv(ab) array([[ 0.1 , -0.05714286], [-0.05 , 0.06428571]]) ab_i=np.linalg.inv(ab) [email protected]_i # proof of inverse array([[1., 0.], [0., 1.]]) # identity matrix
Determinant of a matrix.
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
Eigenvalues and Eigenvectors:
a = np.array([[10,-18], [6,-11]]) np.linalg.eig(a) (array([ 1., -2.]), array([[0.89442719, 0.83205029], [0.4472136 , 0.5547002 ]])