# How to add an extra column to a NumPy array

## Question:

Let’s say I have a NumPy array, `a`:

``````a = np.array([
[1, 2, 3],
[2, 3, 4]
])
``````

And I would like to add a column of zeros to get an array, `b`:

``````b = np.array([
[1, 2, 3, 0],
[2, 3, 4, 0]
])
``````

How can I do this easily in NumPy?

One way, using hstack, is:

``````b = np.hstack((a, np.zeros((a.shape[0], 1), dtype=a.dtype)))
``````

I think a more straightforward solution and faster to boot is to do the following:

``````import numpy as np
N = 10
a = np.random.rand(N,N)
b = np.zeros((N,N+1))
b[:,:-1] = a
``````

And timings:

``````In [23]: N = 10

In [24]: a = np.random.rand(N,N)

In [25]: %timeit b = np.hstack((a,np.zeros((a.shape[0],1))))
10000 loops, best of 3: 19.6 us per loop

In [27]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a
100000 loops, best of 3: 5.62 us per loop
``````

`np.r_[ ... ]` and `np.c_[ ... ]`
are useful alternatives to `vstack` and `hstack`,
with square brackets [] instead of round ().
A couple of examples:

``````: import numpy as np
: N = 3
: A = np.eye(N)

: np.c_[ A, np.ones(N) ]              # add a column
array([[ 1.,  0.,  0.,  1.],
[ 0.,  1.,  0.,  1.],
[ 0.,  0.,  1.,  1.]])

: np.c_[ np.ones(N), A, np.ones(N) ]  # or two
array([[ 1.,  1.,  0.,  0.,  1.],
[ 1.,  0.,  1.,  0.,  1.],
[ 1.,  0.,  0.,  1.,  1.]])

: np.r_[ A, [A[1]] ]              # add a row
array([[ 1.,  0.,  0.],
[ 0.,  1.,  0.],
[ 0.,  0.,  1.],
[ 0.,  1.,  0.]])
: # not np.r_[ A, A[1] ]

: np.r_[ A[0], 1, 2, 3, A[1] ]    # mix vecs and scalars
array([ 1.,  0.,  0.,  1.,  2.,  3.,  0.,  1.,  0.])

: np.r_[ A[0], [1, 2, 3], A[1] ]  # lists
array([ 1.,  0.,  0.,  1.,  2.,  3.,  0.,  1.,  0.])

: np.r_[ A[0], (1, 2, 3), A[1] ]  # tuples
array([ 1.,  0.,  0.,  1.,  2.,  3.,  0.,  1.,  0.])

: np.r_[ A[0], 1:4, A[1] ]        # same, 1:4 == arange(1,4) == 1,2,3
array([ 1.,  0.,  0.,  1.,  2.,  3.,  0.,  1.,  0.])
``````

(The reason for square brackets [] instead of round ()
is that Python expands e.g. 1:4 in square —

I find the following most elegant:

``````b = np.insert(a, 3, values=0, axis=1) # Insert values before column 3
``````

An advantage of `insert` is that it also allows you to insert columns (or rows) at other places inside the array. Also instead of inserting a single value you can easily insert a whole vector, for instance duplicate the last column:

``````b = np.insert(a, insert_index, values=a[:,2], axis=1)
``````

``````array([[1, 2, 3, 3],
[2, 3, 4, 4]])
``````

For the timing, `insert` might be slower than JoshAdel’s solution:

``````In [1]: N = 10

In [2]: a = np.random.rand(N,N)

In [3]: %timeit b = np.hstack((a, np.zeros((a.shape[0], 1))))
100000 loops, best of 3: 7.5 µs per loop

In [4]: %timeit b = np.zeros((a.shape[0], a.shape[1]+1)); b[:,:-1] = a
100000 loops, best of 3: 2.17 µs per loop

In [5]: %timeit b = np.insert(a, 3, values=0, axis=1)
100000 loops, best of 3: 10.2 µs per loop
``````

I think:

``````np.column_stack((a, zeros(shape(a)[0])))
``````

is more elegant.

Use `numpy.append`:

``````>>> a = np.array([[1,2,3],[2,3,4]])
>>> a
array([[1, 2, 3],
[2, 3, 4]])

>>> z = np.zeros((2,1), dtype=int64)
>>> z
array([[0],
[0]])

>>> np.append(a, z, axis=1)
array([[1, 2, 3, 0],
[2, 3, 4, 0]])
``````

I like JoshAdel’s answer because of the focus on performance. A minor performance improvement is to avoid the overhead of initializing with zeros, only to be overwritten. This has a measurable difference when N is large, empty is used instead of zeros, and the column of zeros is written as a separate step:

``````In [1]: import numpy as np

In [2]: N = 10000

In [3]: a = np.ones((N,N))

In [4]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a
1 loops, best of 3: 492 ms per loop

In [5]: %timeit b = np.empty((a.shape[0],a.shape[1]+1)); b[:,:-1] = a; b[:,-1] = np.zeros((a.shape[0],))
1 loops, best of 3: 407 ms per loop
``````

A bit late to the party, but nobody posted this answer yet, so for the sake of completeness: you can do this with list comprehensions, on a plain Python array:

``````source = a.tolist()
result = [row + [0] for row in source]
b = np.array(result)
``````

np.concatenate also works

``````>>> a = np.array([[1,2,3],[2,3,4]])
>>> a
array([[1, 2, 3],
[2, 3, 4]])
>>> z = np.zeros((2,1))
>>> z
array([[ 0.],
[ 0.]])
>>> np.concatenate((a, z), axis=1)
array([[ 1.,  2.,  3.,  0.],
[ 2.,  3.,  4.,  0.]])
``````

I was also interested in this question and compared the speed of

``````numpy.c_[a, a]
numpy.stack([a, a]).T
numpy.vstack([a, a]).T
numpy.ascontiguousarray(numpy.stack([a, a]).T)
numpy.ascontiguousarray(numpy.vstack([a, a]).T)
numpy.column_stack([a, a])
numpy.concatenate([a[:,None], a[:,None]], axis=1)
numpy.concatenate([a[None], a[None]], axis=0).T
``````

which all do the same thing for any input vector `a`. Timings for growing `a`:

Note that all non-contiguous variants (in particular `stack`/`vstack`) are eventually faster than all contiguous variants. `column_stack` (for its clarity and speed) appears to be a good option if you require contiguity.

Code to reproduce the plot:

``````import numpy as np
import perfplot

b = perfplot.bench(
setup=np.random.rand,
kernels=[
lambda a: np.c_[a, a],
lambda a: np.ascontiguousarray(np.stack([a, a]).T),
lambda a: np.ascontiguousarray(np.vstack([a, a]).T),
lambda a: np.column_stack([a, a]),
lambda a: np.concatenate([a[:, None], a[:, None]], axis=1),
lambda a: np.ascontiguousarray(np.concatenate([a[None], a[None]], axis=0).T),
lambda a: np.stack([a, a]).T,
lambda a: np.vstack([a, a]).T,
lambda a: np.concatenate([a[None], a[None]], axis=0).T,
],
labels=[
"c_",
"ascont(stack)",
"ascont(vstack)",
"column_stack",
"concat",
"ascont(concat)",
"stack (non-cont)",
"vstack (non-cont)",
"concat (non-cont)",
],
n_range=[2 ** k for k in range(23)],
xlabel="len(a)",
)
b.save("out.png")
``````

Assuming `M` is a (100,3) ndarray and `y` is a (100,) ndarray `append` can be used as follows:

``````M=numpy.append(M,y[:,None],1)
``````

The trick is to use

``````y[:, None]
``````

This converts `y` to a (100, 1) 2D array.

``````M.shape
``````

now gives

``````(100, 4)
``````

In my case, I had to add a column of ones to a NumPy array

``````X = array([ 6.1101, 5.5277, ... ])
X.shape => (97,)
X = np.concatenate((np.ones((m,1), dtype=np.int), X.reshape(m,1)), axis=1)
``````

After
X.shape => (97, 2)

``````array([[ 1. , 6.1101],
[ 1. , 5.5277],
...
``````

`np.insert` also serves the purpose.

``````matA = np.array([[1,2,3],
[2,3,4]])
idx = 3
new_col = np.array([0, 0])
np.insert(matA, idx, new_col, axis=1)

array([[1, 2, 3, 0],
[2, 3, 4, 0]])
``````

It inserts values, here `new_col`, before a given index, here `idx` along one axis. In other words, the newly inserted values will occupy the `idx` column and move what were originally there at and after `idx` backward.

There is a function specifically for this. It is called numpy.pad

``````a = np.array([[1,2,3], [2,3,4]])
b = np.pad(a, ((0, 0), (0, 1)), mode='constant', constant_values=0)
print b
>>> array([[1, 2, 3, 0],
[2, 3, 4, 0]])
``````

Here is what it says in the docstring:

``````Pads an array.

Parameters
----------
array : array_like of rank N
Input array
Number of values padded to the edges of each axis.
((before_1, after_1), ... (before_N, after_N)) unique pad widths
for each axis.
((before, after),) yields same before and after pad for each axis.
(pad,) or int is a shortcut for before = after = pad width for all
axes.
mode : str or function
One of the following string values or a user supplied function.

'constant'
'edge'
Pads with the edge values of array.
'linear_ramp'
Pads with the linear ramp between end_value and the
array edge value.
'maximum'
Pads with the maximum value of all or part of the
vector along each axis.
'mean'
Pads with the mean value of all or part of the
vector along each axis.
'median'
Pads with the median value of all or part of the
vector along each axis.
'minimum'
Pads with the minimum value of all or part of the
vector along each axis.
'reflect'
Pads with the reflection of the vector mirrored on
the first and last values of the vector along each
axis.
'symmetric'
Pads with the reflection of the vector mirrored
along the edge of the array.
'wrap'
Pads with the wrap of the vector along the axis.
The first values are used to pad the end and the
end values are used to pad the beginning.
<function>
stat_length : sequence or int, optional
Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
values at edge of each axis used to calculate the statistic value.

((before_1, after_1), ... (before_N, after_N)) unique statistic
lengths for each axis.

((before, after),) yields same before and after statistic lengths
for each axis.

(stat_length,) or int is a shortcut for before = after = statistic
length for all axes.

Default is ``None``, to use the entire axis.
constant_values : sequence or int, optional
Used in 'constant'.  The values to set the padded values for each
axis.

((before_1, after_1), ... (before_N, after_N)) unique pad constants
for each axis.

((before, after),) yields same before and after constants for each
axis.

(constant,) or int is a shortcut for before = after = constant for
all axes.

Default is 0.
end_values : sequence or int, optional
Used in 'linear_ramp'.  The values used for the ending value of the
linear_ramp and that will form the edge of the padded array.

((before_1, after_1), ... (before_N, after_N)) unique end values
for each axis.

((before, after),) yields same before and after end values for each
axis.

(constant,) or int is a shortcut for before = after = end value for
all axes.

Default is 0.
reflect_type : {'even', 'odd'}, optional
Used in 'reflect', and 'symmetric'.  The 'even' style is the
default with an unaltered reflection around the edge value.  For
the 'odd' style, the extented part of the array is created by
subtracting the reflected values from two times the edge value.

Returns
-------
Padded array of rank equal to `array` with shape increased

Notes
-----

For an array with rank greater than 1, some of the padding of later
axes is calculated from padding of previous axes.  This is easiest to
think about with a rank 2 array where the corners of the padded array
are calculated by using padded values from the first axis.

The padding function, if used, should return a rank 1 array equal in
length to the vector argument with padded values replaced. It has the
following signature::

where

vector : ndarray
A 2-tuple of ints, iaxis_pad_width[0] represents the number of
values padded at the beginning of vector where
the end of vector.
iaxis : int
The axis currently being calculated.
kwargs : dict
Any keyword arguments the function requires.

Examples
--------
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2,3), 'constant', constant_values=(4, 6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])

array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])

>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])

array([5, 5, 1, 2, 3, 4, 5, 5, 5])

array([3, 3, 1, 2, 3, 4, 5, 3, 3])

array([3, 3, 1, 2, 3, 4, 5, 3, 3])

>>> a = [[1, 2], [3, 4]]
>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[3, 3, 3, 4, 3, 3, 3],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1]])

>>> a = [1, 2, 3, 4, 5]
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])

>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])

>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])

array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])

...     return vector
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
array([[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10,  0,  1,  2, 10, 10],
[10, 10,  3,  4,  5, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10]])
array([[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100,   0,   1,   2, 100, 100],
[100, 100,   3,   4,   5, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100]])
``````

For me, the next way looks pretty intuitive and simple.

``````zeros = np.zeros((2,1)) #2 is a number of rows in your array.
b = np.hstack((a, zeros))
``````

## Add an extra column to a numpy array:

Numpy’s `np.append` method takes three parameters, the first two are 2D numpy arrays and the 3rd is an axis parameter instructing along which axis to append:

``````import numpy as np
x = np.array([[1,2,3], [4,5,6]])
print("Original x:")
print(x)

y = np.array([[1], [1]])
print("Original y:")
print(y)

print("x appended to y on axis of 1:")
print(np.append(x, y, axis=1))
``````

Prints:

``````Original x:
[[1 2 3]
[4 5 6]]
Original y:
[[1]
[1]]
y appended to x on axis of 1:
[[1 2 3 1]
[4 5 6 1]]
``````

I liked this:

``````new_column = np.zeros((len(a), 1))
b = np.block([a, new_column])
``````
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.