Basic Pandas: How to add a column to a DataFrame
Tags: python, pandas
Published: 2020-09-10 22:32:26

---
title: Basic Pandas: How to add a column to a DataFrame
published: true
date: 2020-09-10 22:07:39 UTC
tags: Python,pandas,python
canonical_url: https://www.wrighters.io/2020/09/10/basic-pandas-how-to-add-a-column-to-a-dataframe/
---

[Pandas](https://pandas.pydata.org) is one of my favorite Python libraries, and I use it every day. A very common action is to add a column to a DataFrame. This is a pretty basic task. I’m going to look at a few examples to better show what is happening when we add a column, and how we need to think about the index of our data when we add it.

Let’s start with a very simple DataFrame. This DataFrame has 4 columns of random floating point values. The index of this DataFrame will also be the default, a RangeIndex of the size of the DataFrame. I’ll assume this python code is run in either a Jupyter notebook or ipython session with pandas installed. I used version 1.1.0 when I wrote this.

```
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(6,4), columns=['a', 'b', 'c', 'd'])
display(df)

          a         b         c         d
0  0.028948  0.613221  0.122755  0.754660
1  0.880772  0.581651  0.968752  0.551583
2  0.107115  0.511918  0.574167  0.871300
3  0.830062  0.622413  0.118231  0.444581
4  0.264822  0.370572  0.001680  0.394488
5  0.749247  0.412359  0.092063  0.350451

```

Let’s start with the simplest way to add a column, such as a single value. This will be applied to all rows in the DataFrame.

```
df['e'] = .5
display(df['e'])

0    0.5
1    0.5
2    0.5
3    0.5
4    0.5
5    0.5
Name: e, dtype: float64
```

Now, under the hood, pandas is making life easier for you and taking your scalar value (the 0.5) and turning it into an array and using it to build a Series with the index (in this case a `RangeIndex`) of your DataFrame.

This is sort of the equivalent:

```
df['e_prime'] = pd.Series(.5, index=pd.RangeIndex(6))
```

You can also pass in an array yourself without an index, but it must match the dimensions of your DataFrame

```
df['f'] = np.random.rand(6,1)
```

If you try to do this with a non-matching shape, it won’t work. This is because the DataFrame won’t know where to put the values. You can try it and see the Exception that pandas raises.

Now what happens when the data you want to add doesn’t match your current DataFrame, but it does have an index? Specifically, what if the index is different on the right hand side?

```
df['g'] = pd.Series(np.random.rand(50), index=pd.RangeIndex(2,52))
display(df[['e', 'e_prime', 'f', 'g']])

     e  e_prime         f         g
0  0.5      0.5  0.777879       NaN
1  0.5      0.5  0.621390       NaN
2  0.5      0.5  0.294869  0.283777
3  0.5      0.5  0.024411  0.695215
4  0.5      0.5  0.173954  0.585524
5  0.5      0.5  0.276633  0.751469
```

So what happened here? Our column `g` only has values at rows 2 through 5, even though we assigned a series with 50 values. Well, these were the rows that matched our index. For the rows that didn’t have values, a `NaN` was inserted. You can try doing this where none of the data matches on the index and see what happens. You’ll end up with a full column of `NaN`s. Another way to think of this is that we could use the `loc` method to select the rows we wanted to update, but unless we set the index on the right hand side, we still need to align with the shape of the DataFrame.

```
df.loc[2:5, 'g_prime'] = np.random.rand(4)
display(df['g_prime'])

0         NaN
1         NaN
2    0.130246
3    0.419122
4    0.312587
5    0.101704
Name: g_prime, dtype: float64
```

The main lesson here is to realize that assigning a column to a DataFrame can lead to some surprising results if you don’t realize whether what you are assigning has a matching index or not.