如何创建一个根据现有列选择值的新列？

问题描述：

如何color向以下数据框添加一列，以便color='green'如果Set == 'Z'，color='red'否则？

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

解决方案 1：

如果您只有两个选择，则使用np.where：

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

例如，

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)

产量

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

如果你有两个以上的条件，那么使用np.select。例如，如果你color想

• yellow什么时候(df['Set'] == 'Z') & (df['Type'] == 'A')

• 否则blue当(df['Set'] == 'Z') & (df['Type'] == 'B')

• 否则purple当(df['Type'] == 'B')

• 否则black，

然后使用

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)

得出

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

解决方案 2：

列表推导是另一种有条件地创建另一列的方法。如果您在列中使用对象数据类型（如示例中所示），列表推导通常比大多数其他方法表现更好。

列表理解示例：

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

％timeit 测试：

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

解决方案 3：

实现这一目标的另一种方法是

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

解决方案 4：

下面的方法比这里计时的方法慢，但我们可以根据多列的内容来计算额外的列，并且可以为额外的列计算两个以上的值。

仅使用“设置”列的简单示例：

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

考虑更多颜色和更多列的示例：

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

编辑（2019年6月21日）：使用 plydata

也可以使用plydata来做这类事情（但这似乎比使用assign和更慢apply）。

from plydata import define, if_else

简单的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

嵌套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

解决方案 5：

您可以简单地使用强大的.loc方法，并根据需要使用一个或多个条件（使用 pandas=1.0.5 测试）。

代码摘要：

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"

解释：

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

添加“颜色”列并将所有值设置为“红色”

df['Color'] = "red"

应用您的单一条件：

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

或者如果你想要多个条件：

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

您可以在此处阅读有关 Pandas 逻辑运算符和条件选择的内容：
Pandas 中布尔索引的逻辑运算符

解决方案 6：

这是解决此问题的另一种方法，使用字典将新值映射到列表中的键上：

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,))

它看起来像什么：

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

ifelse当您需要制作许多类型语句（即需要替换许多唯一值）时，这种方法非常有效。

当然你也可以这样做：

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

apply但是在我的计算机上，这种方法比上面的方法慢三倍多。

你也可以这样做dict.get：

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

解决方案 7：

您可以使用 pandas 方法where和mask：

df['color'] = 'green'
df['color'] = df['color'].where(df['Set']=='Z', other='red')
# Replace values where the condition is False

或者

df['color'] = 'red'
df['color'] = df['color'].mask(df['Set']=='Z', other='green')
# Replace values where the condition is True

或者，你可以将该方法transform与 lambda 函数一起使用：

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

输出：

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

来自@chai 的性能比较：

import pandas as pd
import numpy as np
df = pd.DataFrame({'Type':list('ABBC')*1000000, 'Set':list('ZZXY')*1000000})
 
%timeit df['color1'] = 'red'; df['color1'].where(df['Set']=='Z','green')
%timeit df['color2'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
%timeit df['color3'] = np.where(df['Set']=='Z', 'red', 'green')
%timeit df['color4'] = df.Set.map(lambda x: 'red' if x == 'Z' else 'green')

397 ms ± 101 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
976 ms ± 241 ms per loop
673 ms ± 139 ms per loop
796 ms ± 182 ms per loop

解决方案 8：

如果你只有2 个选择，请使用np.where()

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

如果你有超过2 个选择，也许apply()可以输入

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

并且 arr 是

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

如果你希望 E 列是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)

最后 arr 是

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

解决方案 9：

方法如下.apply()：

df['color'] = df['Set'].apply(lambda set_: 'green' if set_=='Z' else 'red')

此后，df数据框如下所示：

>>> print(df)
  Type Set  color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red

解决方案 10：

pyjanitor的case_when函数是一个包装器，它为多种条件提供了一种可链接/方便的形式：pd.Series.mask

对于单个条件：

df.case_when(
    df.col1 == "Z",  # condition
    "green",         # value if True
    "red",           # value if False
    column_name = "color"
    )

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

对于多个条件：

df.case_when(
    df.Set.eq('Z') & df.Type.eq('A'), 'yellow', # condition, result
    df.Set.eq('Z') & df.Type.eq('B'), 'blue',   # condition, result
    df.Type.eq('B'), 'purple',                  # condition, result
    'black',              # default if none of the conditions evaluate to True
    column_name = 'color'  
)
  Type  Set   color
1    A   Z  yellow
2    B   Z    blue
3    B   X  purple
4    C   Y   black

更多示例请见此处

解决方案 11：

当您有一个或多个条件时，可以使用以下简单的一行代码：

df['color'] = np.select(condlist=[df['Set']=="Z", df['Set']=="Y"], choicelist=["green", "yellow"], default="red")

轻松又好出发！

更多信息请见：https: //numpy.org/doc/stable/reference/generated/numpy.select.html

解决方案 12：

case when如果您有 Pandas v2.2.0（2024 年 1 月），则可以轻松完成此操作

• https://github.com/pandas-dev/pandas/issues/39154

• https://pandas.pydata.org/pandas-docs/version/2.2.0/whatsnew/v2.2.0.html#create-a-pandas-series-based-on-one-or-more-conditions

发行说明中的​​示例：

    import pandas as pd

df = pd.DataFrame(dict(a=[1, 2, 3], b=[4, 5, 6]))

default=pd.Series('default', index=df.index)

default.case_when(
     caselist=[
         (df.a == 1, 'first'),                              # condition, replacement
         (df.a.gt(1) & df.b.eq(5), 'second'),  # condition, replacement
     ],
)

Out[4]: 
0      first
1     second
2    default
dtype: object

解决方案 13：

如果您正在处理大量数据，那么最好采用记忆方法：

# First create a dictionary of manually stored values
color_dict = {'Z':'red'}

# Second, build a dictionary of "other" values
color_dict_other = {x:'green' for x in df['Set'].unique() if x not in color_dict.keys()}

# Next, merge the two
color_dict.update(color_dict_other)

# Finally, map it to your column
df['color'] = df['Set'].map(color_dict)

如果您有许多重复值，这种方法会最快。我的经验法则是记住以下情况：data_size> 10**4& n_distinct<data_size/4

例如，Memoize 中有 10,000 行，且每个值不超过 2,500 个。

解决方案 14：

一种不太冗长的方法，使用np.select：

a = np.array([['A','Z'],['B','Z'],['B','X'],['C','Y']])
df = pd.DataFrame(a,columns=['Type','Set'])

conditions = [
    df['Set'] == 'Z'
]

outputs = [
    'Green'
    ]
             # conditions Z is Green, Red Otherwise.
res = np.select(conditions, outputs, 'Red')
res 
array(['Green', 'Green', 'Red', 'Red'], dtype='<U5')
df.insert(2, 'new_column',res)    

df
    Type    Set new_column
0   A   Z   Green
1   B   Z   Green
2   B   X   Red
3   C   Y   Red

df.to_numpy()    
    
array([['A', 'Z', 'Green'],
       ['B', 'Z', 'Green'],
       ['B', 'X', 'Red'],
       ['C', 'Y', 'Red']], dtype=object)

%%timeit conditions = [df['Set'] == 'Z'] 
outputs = ['Green'] 
np.select(conditions, outputs, 'Red')

134 µs ± 9.71 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

df2 = pd.DataFrame({'Type':list('ABBC')*1000000, 'Set':list('ZZXY')*1000000})
%%timeit conditions = [df2['Set'] == 'Z'] 
outputs = ['Green'] 
np.select(conditions, outputs, 'Red')

188 ms ± 26.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

解决方案 15：

对acharuva的这个答案进行小修改

df['color'] = df.apply( lambda x: 'red' if x == 'Z' else 'green', axis=1)