How to convert list of numpy arrays into single numpy array?

In general you can concatenate a whole sequence of arrays along any axis:

numpy.concatenate( LIST, axis=0 )

but you do have to worry about the shape and dimensionality of each array in the list (for a 2-dimensional 3x5 output, you need to ensure that they are all 2-dimensional n-by-5 arrays already). If you want to concatenate 1-dimensional arrays as the rows of a 2-dimensional output, you need to expand their dimensionality.

As Jorge's answer points out, there is also the function stack, introduced in numpy 1.10:

numpy.stack( LIST, axis=0 )

This takes the complementary approach: it creates a new view of each input array and adds an extra dimension (in this case, on the left, so each n-element 1D array becomes a 1-by-n 2D array) before concatenating. It will only work if all the input arrays have the same shape—even along the axis of concatenation.

vstack (or equivalently row_stack) is often an easier-to-use solution because it will take a sequence of 1- and/or 2-dimensional arrays and expand the dimensionality automatically where necessary and only where necessary, before concatenating the whole list together. Where a new dimension is required, it is added on the left. Again, you can concatenate a whole list at once without needing to iterate:

numpy.vstack( LIST )

This flexible behavior is also exhibited by the syntactic shortcut numpy.r_[ array1, ...., arrayN ] (note the square brackets). This is good for concatenating a few explicitly-named arrays but is no good for your situation because this syntax will not accept a sequence of arrays, like your LIST.

There is also an analogous function column_stack and shortcut c_[...], for horizontal (column-wise) stacking, as well as an almost-analogous function hstack—although for some reason the latter is less flexible (it is stricter about input arrays' dimensionality, and tries to concatenate 1-D arrays end-to-end instead of treating them as columns).

Finally, in the specific case of vertical stacking of 1-D arrays, the following also works:

numpy.array( LIST )

...because arrays can be constructed out of a sequence of other arrays, adding a new dimension to the beginning.

Starting in NumPy version 1.10, we have the method stack. It can stack arrays of any dimension (all equal):

# List of arrays.L = [np.random.randn(5,4,2,5,1,2) for i in range(10)]# Stack them using axis=0.M = np.stack(L)M.shape # == (10,5,4,2,5,1,2)np.all(M == L) # == TrueM = np.stack(L, axis=1)M.shape # == (5,10,4,2,5,1,2)np.all(M == L) # == False (Don't Panic)# This are all true    np.all(M[:,0,:] == L[0]) # == Trueall(np.all(M[:,i,:] == L[i]) for i in range(10)) # == True

Enjoy,

I checked some of the methods for speed performance and find that there is no difference!The only difference is that using some methods you must carefully check dimension.

Timing:

|------------|----------------|-------------------||            | shape (10000)  |  shape (1,10000)  ||------------|----------------|-------------------|| np.concat  |    0.18280     |      0.17960      ||------------|----------------|-------------------||  np.stack  |    0.21501     |      0.16465      ||------------|----------------|-------------------|| np.vstack  |    0.21501     |      0.17181      ||------------|----------------|-------------------||  np.array  |    0.21656     |      0.16833      ||------------|----------------|-------------------|

As you can see I tried 2 experiments - using np.random.rand(10000) and np.random.rand(1, 10000)And if we use 2d arrays than np.stack and np.array create additional dimension - result.shape is (1,10000,10000) and (10000,1,10000) so they need additional actions to avoid this.

Code:

from time import perf_counterfrom tqdm import tqdm_notebookimport numpy as npl = []for i in tqdm_notebook(range(10000)):    new_np = np.random.rand(10000)    l.append(new_np)start = perf_counter()stack = np.stack(l, axis=0 )print(f'np.stack: {perf_counter() - start:.5f}')start = perf_counter()vstack = np.vstack(l)print(f'np.vstack: {perf_counter() - start:.5f}')start = perf_counter()wrap = np.array(l)print(f'np.array: {perf_counter() - start:.5f}')start = perf_counter()l = [el.reshape(1,-1) for el in l]conc = np.concatenate(l, axis=0 )print(f'np.concatenate: {perf_counter() - start:.5f}')