# ValueError: all the input arrays must have same number of dimensions

If I start with a 3×4 array, and concatenate a 3×1 array, with axis 1, I get a 3×5 array:

```In [911]: x = np.arange(12).reshape(3,4)
In [912]: np.concatenate([x,x[:,-1:]], axis=1)
Out[912]:
array([[ 0,  1,  2,  3,  3],
[ 4,  5,  6,  7,  7],
[ 8,  9, 10, 11, 11]])
In [913]: x.shape,x[:,-1:].shape
Out[913]: ((3, 4), (3, 1))

```

Note that both inputs to concatenate have 2 dimensions.

Omit the `:`, and `x[:,-1]` is (3,) shape – it is 1d, and hence the error:

```In [914]: np.concatenate([x,x[:,-1]], axis=1)
...
ValueError: all the input arrays must have same number of dimensions

```

The code for `np.append` is (in this case where axis is specified)

```return concatenate((arr, values), axis=axis)

```

So with a slight change of syntax `append` works. Instead of a list it takes 2 arguments. It imitates the list `append` is syntax, but should not be confused with that list method.

```In [916]: np.append(x, x[:,-1:], axis=1)
Out[916]:
array([[ 0,  1,  2,  3,  3],
[ 4,  5,  6,  7,  7],
[ 8,  9, 10, 11, 11]])

```

`np.hstack` first makes sure all inputs are `atleast_1d`, and then does concatenate:

```return np.concatenate([np.atleast_1d(a) for a in arrs], 1)

```

So it requires the same `x[:,-1:]` input. Essentially the same action.

`np.column_stack` also does a concatenate on axis 1. But first it passes 1d inputs through

```array(arr, copy=False, subok=True, ndmin=2).T

```

This is a general way of turning that (3,) array into a (3,1) array.

```In [922]: np.array(x[:,-1], copy=False, subok=True, ndmin=2).T
Out[922]:
array([[ 3],
[ 7],
[11]])
In [923]: np.column_stack([x,x[:,-1]])
Out[923]:
array([[ 0,  1,  2,  3,  3],
[ 4,  5,  6,  7,  7],
[ 8,  9, 10, 11, 11]])

```

All these ‘stacks’ can be convenient, but in the long run, it’s important to understand dimensions and the base `np.concatenate`. Also know how to look up the code for functions like this. I use the `ipython` `??` magic a lot.

And in time tests, the `np.concatenate` is noticeably faster – with a small array like this the extra layers of function calls makes a big time difference.