# Numpy matrix to array

Each Answer to this Q is separated by one/two green lines.

I am using numpy. I have a matrix with 1 column and N rows and I want to get an array from with N elements.

For example, if i have `M = matrix([, , , ])`, I want to get `A = array([1,2,3,4])`.

To achieve it, I use `A = np.array(M.T)`. Does anyone know a more elegant way to get the same result?

Thanks!

If you’d like something a bit more readable, you can do this:

``````A = np.squeeze(np.asarray(M))
``````

Equivalently, you could also do: `A = np.asarray(M).reshape(-1)`, but that’s a bit less easy to read.

``````result = M.A1
``````

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

``````matrix.A1
1-d base array
``````

``````A, = np.array(M.T)
``````

depends what you mean by elegance i suppose but thats what i would do

You can try the following variant:

``````result=np.array(M).flatten()
``````

``````np.array(M).ravel()
``````

If you care for speed; But if you care for memory:

``````np.asarray(M).ravel()
``````

Or you could try to avoid some temps with

``````A = M.view(np.ndarray)
A.shape = -1
``````

First, `Mv = numpy.asarray(M.T)`, which gives you a 4×1 but 2D array.

Then, perform `A = Mv[0,:]`, which gives you what you want. You could put them together, as `numpy.asarray(M.T)[0,:]`.

This will convert the matrix into array

``````A = np.ravel(M).T
``````

ravel() and flatten() functions from numpy are two techniques that I would try here. I will like to add to the posts made by Joe, Siraj, bubble and Kevad.

Ravel:

``````A = M.ravel()
print A, A.shape
>>> [1 2 3 4] (4,)
``````

Flatten:

``````M = np.array([, , , ])
A = M.flatten()
print A, A.shape
>>> [1 2 3 4] (4,)
``````

`numpy.ravel()` is faster, since it is a library level function which does not make any copy of the array. However, any change in array A will carry itself over to the original array M if you are using `numpy.ravel()`.

`numpy.flatten()` is slower than `numpy.ravel()`. But if you are using `numpy.flatten()` to create A, then changes in A will not get carried over to the original array M.

`numpy.squeeze()` and `M.reshape(-1)` are slower than `numpy.flatten()` and `numpy.ravel()`.

``````%timeit M.ravel()
>>> 1000000 loops, best of 3: 309 ns per loop

%timeit M.flatten()
>>> 1000000 loops, best of 3: 650 ns per loop

%timeit M.reshape(-1)
>>> 1000000 loops, best of 3: 755 ns per loop

%timeit np.squeeze(M)
>>> 1000000 loops, best of 3: 886 ns per loop
``````

Came in a little late, hope this helps someone,

``````np.array(M.flat)
`````` The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .