## What are the differences between numpy arrays and matrices? Which one should I use?

numpy matrix
numpy matrix multiplication
numpy matrix to array
numpy matrix operations
python matrix
numpy matrix from list of arrays
add two matrix in python using numpy
numpy initialize matrix

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 product.

```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(a@b)
# [[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 `a` and `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 `np.dot` (or `@` in Python >= 3.5, as shown above):

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

The `**` operator also behaves differently:

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

Since `a` is a matrix, `a**2` returns the matrix product `a*a`. Since `c` is an ndarray, `c**2` returns an ndarray with each component squared element-wise.

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 ndarray operations.

Writing a program that uses 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 functions/notation.

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, since `np.asmatrix` and `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 `matrix`es here.

1. Vectors, Matrices, and Arrays, How do you convert a matrix to a vector in Python? A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension. The Python core library provided Lists. A list is the Python equivalent of an array, but is resizeable and can contain elements of different types.

What is the difference between an array and a matrix?, () function returns the matrix product of two arrays. While it returns a normal product for 2-D arrays, if dimensions of either argument is >2, it is treated as a stack of matrices residing in the last two indexes and is broadcast accordingly. This tutorial covers creating and working with NumPy Arrays. Indexing and Slicing, performing operations, joining and splitting of arrays.

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:

with matrix

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

with array

```>>> 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.

numpy.matmul(), What are the differences between numpy arrays and matrices? Which one should I use? - What are the advantages and disadvantages of each  The matrix class is a subclass of numpy's ndarray object, implemented entirely in Python. So every call you make on a matrix object is going to require a few extra Python calls, mostly to make sure that the object always remains 2D.

As others have mentioned, perhaps the main advantage of `matrix` was that it provided a convenient notation for matrix multiplication.

However, in Python 3.5 there is finally a dedicated infix operator for matrix multiplication: `@`.

With recent NumPy versions, it can be used with `ndarray`s:

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

So nowadays, even more, when in doubt, you should stick to `ndarray`.

What are the differences between numpy arrays and matrices , There is a clear distinction between element-wise operations and linear algebra Until Python 3.5 the only disadvantage of using the array type was that you had to matrix multiplication, and for element-wise multiplication one has to use the  The elements in a Numpy array are all required to be of the same data type (we can have the heterogeneous type as well but that will not gonna permit you mathematical operations) and thus will be the same size in memory. Numpy arrays are facilitated advances mathematical and other types of operations on large numbers of data.

NumPy for Matlab users, In the previous chapter of our introduction in NumPy we have demonstrated So​, the difference of the vectors x and y is equal to the sum of x and -y: If we want to perform matrix multiplication with two numpy arrays (ndarray), we have to use Text Classification, then "Python Text Processing Course" will be the right one​  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. Matrix objects are a subclass of ndarray, so they inherit all the attributes and methods of ndarrays.

Matrix Arithmetics in NumPy, What is the difference between matrices and arrays? If you use Numeric or numarray, you should upgrade; NumPy is explicitly designed to have all the  # ‘array’ or ‘matrix’? Which should I use? Historically, NumPy has provided a special matrix type, np.matrix, which is a subclass of ndarray which makes binary operations linear algebra operations. You may see it used in some existing code instead of np.array. So, which one to use? # Short answer. Use arrays.

Basic NumPy/SciPy usage, The main benefits of using NumPy arrays should be smaller memory consumption and better runtime behavior. For Python Lists - We can conclude from this that  NumPy allows you to work with high-performance arrays and matrices. Its main data object is the ndarray, an N-dimensional array type which describes a collection of “items” of the same type

• Python 3.5 added the infix @ operator for matrix multiplication (PEP 465), and NumPy 1.10 added support for it. So if you are using Python 3.5+ and NumPy 1.10+, then you can just write `A @ B` instead of `A.dot(B)`, where `A` and `B` are 2D `ndarray`s. This removes the main advantage of using `matrix` instead of plain `ndarray`s, IMHO.
• For those wondering, `mat**n` for a matrix can be inelegantly applied to an array with `reduce(np.dot, [arr]*n)`
• Or just `np.linalg.matrix_power(mat, n)`
• Actually, timeit tests show ndarray operations such as `np.dot(array2, array2)` are faster than `matrix1*matrix2`. This makes sense because `matrix` is a subclass of ndarray which overrides special methods like `__mul__`. `matrix.__mul__` calls `np.dot`. So there is code reusage here. Instead of performing fewer checks, using `matrix*matrix` requires an extra function call. So the advantage of using `matrix` is purely syntactic, not better performance.
• Even though the accepted answer provides more info, the real answer is indeed to stick with `ndarray`. The main argument for using `matrix` would be if your code is heavy in linear algebra and would look less clear with all the calls to the `dot` function. But this argument will disappear in future, now that the @-operator is accepted for use with matrix multiplication, see PEP 465. This will need Python 3.5 and the latest version of Numpy. The matrix class might be deprecated in the far future, so better to use ndarray for new code ...
• That page graciously forgets about `scipy.sparse` matrices. If you use both dense & sparse matrices in your code, it is much easier to stick to `matrix`.