如何将一列(或一系列)可变长度列表转换成一个固定宽度的数据帧

Question

我想将具有不同长度的列表的数据帧列（或系列）转换为具有固定列数的数据帧。

数据帧将具有与最长列表一样多的列，其他列表较短的值可以是 NaN 或任何内容。

当数据以字符串形式出现时，str模块允许使用str.split中的选项expand。但我还没有找到一个可变长度列表的等价物。

在我的示例中，列表中的类型是int，但其想法是能够使用任何类型。这可以防止简单地将Series转换为str并应用提到的扩展属性。

下面我显示了使用str.split功能运行带有列表的示例的代码，并在要转换的系列的最小示例之后运行。

我找到了一个使用 apply 的解决方案，如示例所示，但速度非常慢，因此没有用处。

import numpy as np
import pandas as pd

# Example with a list as a string
A = pd.DataFrame({'lists': [
                    '[]',
                    '[360,460,160]',
                    '[360,1,2,3,4,5,6]',
                    '[10,20,30]',
                    '[100,100,100,100]',
                    ],
                  'other': [1,2,3,4,5]
                 })
print(A['lists'].astype(str).str.strip('[]').str.split(',', expand=True))

# Example with actual lists
B = pd.DataFrame({'lists': [
                    [],
                    [360,460,160],
                    [360,1,2,3,4,5,6],
                    [10,20,30],
                    [100,100,100,100],
                ],
                  'other': [1,2,3,4,5]
                 })

# Create and pre-fill expected columns
max_len = max(B['lists'].str.len())
for idx in range(max_len):
    B[f'lists_{idx}'] = np.nan

# Use .apply to fill the columns
def expand_int_list(row, col, df):
    for idx, item in enumerate(row[col]):
        df.loc[row.name, f'{col}_{idx}'] = item
        
B.apply(lambda row: expand_int_list(row, 'lists', B), axis=1)
print(B)

输出：

     0     1     2     3     4     5     6
0       None  None  None  None  None  None
1  360   460   160  None  None  None  None
2  360     1     2     3     4     5     6
3   10    20    30  None  None  None  None
4  100   100   100   100  None  None  None
                     lists  other  lists_0  lists_1  lists_2  lists_3  \
0                       []      1      NaN      NaN      NaN      NaN   
1          [360, 460, 160]      2    360.0    460.0    160.0      NaN   
2  [360, 1, 2, 3, 4, 5, 6]      3    360.0      1.0      2.0      3.0   
3             [10, 20, 30]      4     10.0     20.0     30.0      NaN   
4     [100, 100, 100, 100]      5    100.0    100.0    100.0    100.0   

   lists_4  lists_5  lists_6  
0      NaN      NaN      NaN  
1      NaN      NaN      NaN  
2      4.0      5.0      6.0  
3      NaN      NaN      NaN  
4      NaN      NaN      NaN  

编辑和最终解决方案：使在其他问题中找到的方法失败的一个重要信息是，在我的数据中，有时我有无而不是列表。

在这种情况下，使用< code>tolist()将再次生成一系列列表，Pandas不允许使用< code>B.loc[B[col]使这些单元格成为空列表。isna()，col] = []。

我找到的解决方案是只在非None的行中使用< code>tolist(),并使用原始索引使用< code>concat:

# Example with actual lists
B = pd.DataFrame({'lists': [
                    [],
                    [360,460,160],
                    None,
                    [10,20,30],
                    [100,100,100,100],
                ],
                  'other': [1,2,3,4,5]
                 })

col = 'lists'
# I need to keep the index for the concat afterwards.
extended = pd.DataFrame(B.loc[~B[col].isna(), col].tolist(),
                        index=B.loc[~B[col].isna()].index)
extended = extended.add_prefix(f'{col}_')
B = pd.concat([B, extended], axis=1)

print(B)

输出：

                  lists  other  lists_0  lists_1  lists_2  lists_3
0                    []      1      NaN      NaN      NaN      NaN
1       [360, 460, 160]      2    360.0    460.0    160.0      NaN
2                  None      3      NaN      NaN      NaN      NaN
3          [10, 20, 30]      4     10.0     20.0     30.0      NaN
4  [100, 100, 100, 100]      5    100.0    100.0    100.0    100.0

Answer 1

如果将嵌套列表转换为列表并传递到＜code＞数据帧＜/code＞构造函数，则会像最长列表一样添加缺失值，然后＜code＞DataFrame。add_prefix并通过＜code＞数据帧附加到原始数据。join：

df = B.join(pd.DataFrame(B['lists'].tolist()).add_prefix('lists_'))
print (df)
                     lists  other  lists_0  lists_1  lists_2  lists_3  \
0                       []      1      NaN      NaN      NaN      NaN   
1          [360, 460, 160]      2    360.0    460.0    160.0      NaN   
2  [360, 1, 2, 3, 4, 5, 6]      3    360.0      1.0      2.0      3.0   
3             [10, 20, 30]      4     10.0     20.0     30.0      NaN   
4     [100, 100, 100, 100]      5    100.0    100.0    100.0    100.0   

   lists_4  lists_5  lists_6  
0      NaN      NaN      NaN  
1      NaN      NaN      NaN  
2      4.0      5.0      6.0  
3      NaN      NaN      NaN  
4      NaN      NaN      NaN