用Python为两个列中的每个列表值创建新行

Question

我正在尝试比较数据框中两列中的列表值，因此想要为每列中列表的每个索引创建单独的行，并且新行的名字包含该列表的索引。我的原始数据框是这样的：

 File    Color         File Value              True Value
    1       blue    ['123', 'abc', 'tvr']    ['123', 'abc', 'tvr']
    2       green   ['jlak', 'abc', 'vds']   ['123', 'ffs', 'tvr']
    3       red     ['vssf', 'blue', '15a']  ['15a', 'asd', '15a', '234']
    4       black      'fvg'                     'fvg'

我希望数据框转换后呈现如下形式：

  File     Color         File Value              True Value
    1       blue_0          '123'                    '123'
    1       blue_1          'abc'                    'abc'
    1       blue_2          'tvr'                    'tvr'
    2       green_0         'jlak'                   '123'
    2       green_1         'abc'                    'ffs'
    2       green_2         'vds'                    'tvr'
    3       red_0           'vssf'                   '15a'
    3       red_1           'blue'                   'asd'
    3       red_2           '15a'                    '15a'
    3       red_3            None                    '234'
    4       black           'fvg'                    'fvg'

我已经尝试使用来自Stack Overflow上的解决方案[链接]来为每列中的逗号分隔值创建新行，但在某些行不是列表的情况下总是得到null值，而且我不知道在这种情况下该如何应用此方法。

(data.assign(category=data['File Value'].explode('File Value').reset_index(drop=True)))

我还尝试对数据框进行子集化，以获取仅包含列表的行：

sub = data[~data.Color == 'black']
(sub.assign(category=sub['File Value'].explode('File Value').reset_index(drop=True)))

但是再次得到了全是null值的一列。

更新：

我正在使用explode函数将列值分离成单独的行，但是不知道如何修改'File'和'Color'列以保持与各个值的对应关系。

sub = data[~data.Color == 'black']
sub['File Value'].explode()

player0 · Answer

因此，虽然可能有一种更巧妙的方法通过连接和爆炸来完成这个任务，但我认为可以采取两次规范化数据的步骤，然后再使用.explode方法：

In [107]: df = pd.DataFrame(
     ...:     dict(
     ...:         file=[1, 2, 3, 4],
     ...:         color=["blue", "green", "red", "black"],
     ...:         file_value=[
     ...:             ["123", "abc", "tvr"],
     ...:             ["jlak", "abc", "vds"],
     ...:             ["vssf", "blue", "15a"],
     ...:             "fvg",
     ...:         ],
     ...:         true_value=[
     ...:             ["123", "abc", "tvr"],
     ...:             ["123", "ffs", "tvr"],
     ...:             ["15a", "asd", "15a", "234"],
     ...:             "fvg",
     ...:         ],
     ...:     )
     ...: )

因此，定义以下这些函数是为了将列表规范化至相同的长度（并确保它们首先始终是列表）。

In [108]: def normalize_to_list(x):
     ...:     if not isinstance(x, list):
     ...:         x = [x]
     ...:     return x
     ...:

In [109]: def normalize_list_lengths(S):
     ...:     # this could all probably be more elegant
     ...:     file_value = S['file_value']
     ...:     true_value = S['true_value']
     ...:     if len(file_value) == len(true_value):
     ...:         return S
     ...:     elif len(file_value) > len(true_value):
     ...:         diff = len(file_value) - len(true_value)
     ...:         true_value += [None]*diff
     ...:     else:
     ...:         diff = len(true_value) - len(file_value)
     ...:         file_value += [None]*diff
     ...:     return S
     ...:

In [110]: df
Out[110]:
   file  color         file_value            true_value
0     1   blue    [123, abc, tvr]       [123, abc, tvr]
1     2  green   [jlak, abc, vds]       [123, ffs, tvr]
2     3    red  [vssf, blue, 15a]  [15a, asd, 15a, 234]
3     4  black                fvg                   fvg

In [111]: df[['file_value', 'true_value']] = df[['file_value','true_value']].applymap(normalize_to_list)

In [112]: df
Out[112]:
   file  color         file_value            true_value
0     1   blue    [123, abc, tvr]       [123, abc, tvr]
1     2  green   [jlak, abc, vds]       [123, ffs, tvr]
2     3    red  [vssf, blue, 15a]  [15a, asd, 15a, 234]
3     4  black              [fvg]                 [fvg]

In [113]: df[['file_value', 'true_value']] = df[['file_value','true_value']].apply(normalize_list_lengths, axis=1)

In [114]: df
Out[114]:
   file  color               file_value            true_value
0     1   blue          [123, abc, tvr]       [123, abc, tvr]
1     2  green         [jlak, abc, vds]       [123, ffs, tvr]
2     3    red  [vssf, blue, 15a, None]  [15a, asd, 15a, 234]
3     4  black                    [fvg]                 [fvg]

最后，对这两列使用 df.explode 方法。

In [115]: df.explode(column=['file_value','true_value'])
Out[115]:
   file  color file_value true_value
0     1   blue        123        123
0     1   blue        abc        abc
0     1   blue        tvr        tvr
1     2  green       jlak        123
1     2  green        abc        ffs
1     2  green        vds        tvr
2     3    red       vssf        15a
2     3    red       blue        asd
2     3    red        15a        15a
2     3    red       None        234
3     4  black        fvg        fvg

Shubham Khatri · Answer

首先，您可以从内部对两列中（如果有）的列表使用zip_longest函数，然后应用explode和join操作：

import itertools
from itertools import zip_longest

# 指定需要处理的列名
cols = ["File Value", "True Value"]  # 如果有更多列，可在此添加

# 将非列表转换为列表并使用zip_longest填充不足项
expl = (
    df[cols]
        .applymap(lambda v: v if isinstance(v, list) else [v])  # 对于pandas >= 2.1.0版本适用
        .apply(lambda x: list(zip(*zip_longest(*x))), axis=1, result_type="expand")
        .explode(list(range(len(cols))))
        .set_axis(cols, axis=1)
)

# 将处理过的列与原DataFrame重新组合，并为'Color'列添加下标后缀
out = (
    df.drop(columns=cols).join(expl)
        .assign(Color=lambda x: x["Color"]
            .str.cat(x.groupby(level=0).cumcount().astype(str), sep="_")
            .where(x.index.duplicated(keep=False), x["Color"]))
)

# 输出结果：
#   File    Color File Value True Value
# 0     1   blue_0        123        123
# 0     1   blue_1        abc        abc
# 0     1   blue_2        tvr        tvr
# 1     2  green_0       jlak        123
# 1     2  green_1        abc        ffs
# 1     2  green_2        vds        tvr
# 2     3    red_0       vssf        15a
# 2     3    red_1       blue        asd
# 2     3    red_2        15a        15a
# 2     3    red_3       None        234
# 3     4    black        fvg        fvg

结果是一个11行×4列的DataFrame