Algorithms of Joining arrays in numpy

Let's see I can illustrate some basic array operations.

First make a 2d array. Start with a 1d, [0,1,...5], and reshape it to (2,3):

In [1]: x = np.arange(6).reshape(2,3)
In [2]: x
Out[2]: 
array([[0, 1, 2],
       [3, 4, 5]])

I can join 2 copies of x along the 1st dimension (vstack, v for vertical also does this):

In [3]: np.concatenate([x,x], axis=0)
Out[3]: 
array([[0, 1, 2],
       [3, 4, 5],
       [0, 1, 2],
       [3, 4, 5]])

Note that the result is (4,3); no new dimension.

Or join them 'horizontally':

In [4]: np.concatenate([x,x], axis=1)
Out[4]: 
array([[0, 1, 2, 0, 1, 2],        # (2,6) shape
       [3, 4, 5, 3, 4, 5]])

But if I supply them to np.array I make a 3d array (2,2,3) shape:

In [5]: np.array([x,x])
Out[5]: 
array([[[0, 1, 2],
        [3, 4, 5]],

       [[0, 1, 2],
        [3, 4, 5]]])

This action of np.array is really no different from making a 2d array from nested lists, np.array([[1,2],[3,4]]). We could just add a layer of nesting, just like Out[5} without the line breaks. I tend to think of this 3d array as having 2 blocks, each with 2 rows and 3 columns. But the names are just a convenience.

stack acts like np.array, making a 3d array. It actually changes the input arrays to (1,2,3) shape, and concatenates on the first axis.

In [6]: np.stack([x,x])
Out[6]: 
array([[[0, 1, 2],
        [3, 4, 5]],

       [[0, 1, 2],
        [3, 4, 5]]])

stack lets us join the array in other ways

In [7]: np.stack([x,x], axis=1)      # expand to (2,1,3) and concatante
Out[7]: 
array([[[0, 1, 2],
        [0, 1, 2]],

       [[3, 4, 5],
        [3, 4, 5]]])
In [8]: np.stack([x,x], axis=2)       # expand to (2,3,1) and concatenate
Out[8]: 
array([[[0, 0],
        [1, 1],
        [2, 2]],

       [[3, 3],
        [4, 4],
        [5, 5]]])

concatenate and the other stack functions don't add anything new to basic numpy arrays. They just provide a way(s) of making a new array from existing ones. There aren't any special algorithms.

If it helps you could think of these join functions as creating a new "blank" array, and filling it with copies of the source arrays. For example that last stack can be done with:

In [9]: res = np.zeros((2,3,2), int)
In [10]: res
Out[10]: 
array([[[0, 0],
        [0, 0],
        [0, 0]],

       [[0, 0],
        [0, 0],
        [0, 0]]])
In [11]: res[:,:,0] = x
In [12]: res[:,:,1] = x
In [13]: res
Out[13]: 
array([[[0, 0],
        [1, 1],
        [2, 2]],

       [[3, 3],
        [4, 4],
        [5, 5]]])