### Sample query:

I have a dataframe along the lines of the below:

```
Type Set
1 A Z
2 B Z
3 B X
4 C Y
```

I want to add another column to the dataframe (or generate a series) of the same length as the dataframe (equal number of records/rows) which sets a colour `'green'`

if `Set == 'Z'`

and `'red'`

if `Set`

equals anything else.

What’s the best way to do this?

## How to create a conditional column in pandas dataframe? Answer #1:

**If you only have two choices to select from:**

```
df['color'] = np.where(df['Set']=='Z', 'green', 'red')
```

For example,

```
import pandas as pd
import numpy as np
df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
df['color'] = np.where(df['Set']=='Z', 'green', 'red')
print(df)
```

yields

```
Set Type color
0 Z A green
1 Z B green
2 X B red
3 Y C red
```

**If you have more than two conditions then use np.select**. For example, if you want

`color`

to be`yellow`

when`(df['Set'] == 'Z') & (df['Type'] == 'A')`

- otherwise
`blue`

when`(df['Set'] == 'Z') & (df['Type'] == 'B')`

- otherwise
`purple`

when`(df['Type'] == 'B')`

- otherwise
`black`

,

then use

```
df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
conditions = [
(df['Set'] == 'Z') & (df['Type'] == 'A'),
(df['Set'] == 'Z') & (df['Type'] == 'B'),
(df['Type'] == 'B')]
choices = ['yellow', 'blue', 'purple']
df['color'] = np.select(conditions, choices, default='black')
print(df)
```

which yields

```
Set Type color
0 Z A yellow
1 Z B blue
2 X B purple
3 Y C black
```

## Pandas conditional creation of a series/dataframe column- Answer #2:

List comprehension is another way to create another column conditionally. If you are working with object dtypes in columns, like in your example, list comprehensions typically outperform most other methods.

Example list comprehension:

```
df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
```

**%timeit tests:**

```
import pandas as pd
import numpy as np
df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
%timeit df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
%timeit df['color'] = np.where(df['Set']=='Z', 'green', 'red')
%timeit df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')
1000 loops, best of 3: 239 µs per loop
1000 loops, best of 3: 523 µs per loop
1000 loops, best of 3: 263 µs per loop
```

## Apply if condition in Pandas dataframe- Answer #3:

The following is slower than the approaches timed in other answers, but we can compute the extra column based on the contents of more than one column, and more than two values can be computed for the extra column.

Simple example using just the “Set” column:

```
def set_color(row):
if row["Set"] == "Z":
return "red"
else:
return "green"
df = df.assign(color=df.apply(set_color, axis=1))
print(df)
```

```
Set Type color
0 Z A red
1 Z B red
2 X B green
3 Y C green
```

Example with more colours and more columns taken into account:

```
def set_color(row):
if row["Set"] == "Z":
return "red"
elif row["Type"] == "C":
return "blue"
else:
return "green"
df = df.assign(color=df.apply(set_color, axis=1))
print(df)
```

```
Set Type color
0 Z A red
1 Z B red
2 X B green
3 Y C blue
```

### Edit (21/06/2019): Using plydata

It is also possible to use plydata to do this kind of thing (this seems even slower than using `assign`

and `apply`

, though).

```
from plydata import define, if_else
```

Simple `if_else`

:

```
df = define(df, color=if_else('Set=="Z"', '"red"', '"green"'))
print(df)
```

```
Set Type color
0 Z A red
1 Z B red
2 X B green
3 Y C green
```

Nested `if_else`

:

```
df = define(df, color=if_else(
'Set=="Z"',
'"red"',
if_else('Type=="C"', '"green"', '"blue"')))
print(df)
```

```
Set Type color
0 Z A red
1 Z B red
2 X B blue
3 Y C green
```

## Answer #4:

Here’s yet another way to skin this cat, using a dictionary to map new values onto the keys in the list:

```
def map_values(row, values_dict):
return values_dict[row]
values_dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4}
df = pd.DataFrame({'INDICATOR': ['A', 'B', 'C', 'D'], 'VALUE': [10, 9, 8, 7]})
df['NEW_VALUE'] = df['INDICATOR'].apply(map_values, args = (values_dict,))
```

What’s it look like:

```
df
Out[2]:
INDICATOR VALUE NEW_VALUE
0 A 10 1
1 B 9 2
2 C 8 3
3 D 7 4
```

This approach can be very powerful when you have many `ifelse`

-type statements to make (i.e. many unique values to replace).

And of course you could always do this:

```
df['NEW_VALUE'] = df['INDICATOR'].map(values_dict)
```

But that approach is more than three times as slow as the `apply`

approach from above, on my machine.

And you could also do this, using `dict.get`

:

`df['NEW_VALUE'] = [values_dict.get(v, None) for v in df['INDICATOR']]`

## Answer #5:

Another way in which this could be achieved is

`df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')`

## How to create conditional columns in pandas dataframe/series? Answer #6:

You can simply use the powerful `.loc`

method and use one condition or several depending on your need (tested with pandas=1.0.5).

Code Summary:

```
df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))
df['Color'] = "red"
df.loc[(df['Set']=="Z"), 'Color'] = "green"
#practice!
df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"
```

Explanation:

```
df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))
# df so far:
Type Set
0 A Z
1 B Z
2 B X
3 C Y
```

add a ‘color’ column and set all values to “red”

```
df['Color'] = "red"
```

Apply your single condition:

```
df.loc[(df['Set']=="Z"), 'Color'] = "green"
# df:
Type Set Color
0 A Z green
1 B Z green
2 B X red
3 C Y red
```

or multiple conditions if you want:

`df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"`

## Answer #7:

This answer depends on the number of choices that you have, if you have only **2 choices**, use `np.where()`

```
df = pd.DataFrame({'A':range(3)})
df['B'] = np.where(df.A>2, 'yes', 'no')
```

if you have over **2 choices**, maybe `apply()`

could work input

```
arr = pd.DataFrame({'A':list('abc'), 'B':range(3), 'C':range(3,6), 'D':range(6, 9)})
```

and arr is

```
A B C D
0 a 0 3 6
1 b 1 4 7
2 c 2 5 8
```

if you want the column E tobe `if arr.A =='a' then arr.B elif arr.A=='b' then arr.C elif arr.A == 'c' then arr.D else something_else`

```
arr['E'] = arr.apply(lambda x: x['B'] if x['A']=='a' else(x['C'] if x['A']=='b' else(x['D'] if x['A']=='c' else 1234)), axis=1)
```

and finally, the arr is

```
A B C D E
0 a 0 3 6 0
1 b 1 4 7 4
2 c 2 5 8 8
```

Hope you learned something from this post.

Follow **Programming Articles** for more!