Python 如何映射到pandas中列表列内的值

我有下面的场景

import pandas as pd

d = {'col1': [1, 2, 3], 'col2': [['apple'], [], ['romaine', 'potatoes']}
df = pd.DataFrame(data=d)

因此，数据帧是：

   col1   col2
0   1     [apple]
1   2     []
2   3     [romaine, potatoes]

我还有一本字典：

my_dict = {"apple" : "fruit", "potatoes" : "vegetable", "romaine" : "lettuce"}

我想创建另一列“col3”，该列将包含上面我的目录中的值列表：

   col1   col2                 col3
0   1     [apple]              [fruit]
1   2     []                   []
2   3     [romaine, potatoes]  [lettuce, vegetable]

我想使用apply、map、lambda编写一行代码来实现这一点：

df["col3"] = df.col2.apply(map(lambda x: pass if not x else condition_dict[x]))

我真的被卡住了，不知道是否可以不编写单独的函数，然后作为参数传递应用。

试试这个：

dfe = df.explode('col2')
dfe['col3'] = dfe['col2'].map(my_dict)
dfe.groupby('col1', as_index=False)[['col3']].agg(list).merge(df)

输出：

   col1                  col3                 col2
0     1               [fruit]              [apple]
1     2                 [nan]                   []
2     3  [lettuce, vegetable]  [romaine, potatoes]

或作为一个班轮：

(df.merge(df['col2'].explode()
                    .map(my_dict)
                    .groupby(df['col1'])
                    .agg(list)
                    .rename('col3'), 
           left_on='col1', 
           right_index=True)

• 对于一个有1M行的示例数据帧，

  .apply

  和

  列表理解

  比

  .explode（）

  和

  .groupby（）

  快约2.5倍，比使用

  .map（）

  快一点（1.15倍）。
  • 看
• 如果列中有

  NaN

  ，则必须使用

  .dropna

  删除该行，或者可以使用空的

  列表来填充该行。
  
  .fillna（[]）
  将不起作用
  使用
  df.col2=df.col2.fillna（{i:[]表示df.index}中的i）
  
  

df['col3']=df.col2.apply（lambda x:[my_dict.get（v）for v in x]）
#显示（df）
col1 col2 col3
1[苹果][水果]
2                  []                   []
3[生菜、土豆][生菜、蔬菜]

%timeit

测试

#有1M行的测试数据
d={'col1'：[1,2,3]，'col2'：[['apple']，[]，['romaine'，['Potations']}
df=pd.数据帧（d）
df=局部浓度（[df]*333）
%%时间
df.col2.apply（lambda x:[my_dict.get（v）for v in x]）
[out]：
每个回路453 ms±30.5 ms（7次运行的平均值±标准偏差，每个回路1次）
斯科特博士（d，我的遗嘱）：
e=d.爆炸（'col2'）
e['col3']=e['col2'].map（我的字典）
返回e.groupby（'col1'，as_index=False）['col3']].agg（list.merge（d）
%%时间
斯科特（df，我的字典）
[out]：
每个回路1.17 s±23.3 ms（7次运行的平均值±标准偏差，每个回路1次）
%%时间
map（lambda x:list（map（my_dict.get，x）））
[out]：
每个回路519 ms±16.4 ms（7次运行的平均值±标准偏差，每个回路1次）
%%时间
df['col2'].explode（）.map（my_dict）.groupby（level=0）.agg（list）
[out]：
每个回路909 ms±8.61 ms（7次运行的平均值±标准偏差，每个回路1次）

df.col2.map（lambda x:list（map（my_dict.get，x）））