提问人：Marius 提问时间：12/3/2014 最后编辑：cs95Marius 更新时间：4/1/2021 访问量：277840
Pandas 列表列，为每个列表元素创建一行
Pandas column of lists, create a row for each list element
问：
我有一个数据帧，其中某些单元格包含多个值的列表。而不是存储多个 值，我想展开数据帧，以便列表中的每个项目都有自己的行（在所有其他列中具有相同的值）。因此，如果我有：
import pandas as pd
import numpy as np
df = pd.DataFrame(
{'trial_num': [1, 2, 3, 1, 2, 3],
'subject': [1, 1, 1, 2, 2, 2],
'samples': [list(np.random.randn(3).round(2)) for i in range(6)]
}
)
df
Out[10]:
samples subject trial_num
0 [0.57, -0.83, 1.44] 1 1
1 [-0.01, 1.13, 0.36] 1 2
2 [1.18, -1.46, -0.94] 1 3
3 [-0.08, -4.22, -2.05] 2 1
4 [0.72, 0.79, 0.53] 2 2
5 [0.4, -0.32, -0.13] 2 3
如何转换为长格式，例如：
subject trial_num sample sample_num
0 1 1 0.57 0
1 1 1 -0.83 1
2 1 1 1.44 2
3 1 2 -0.01 0
4 1 2 1.13 1
5 1 2 0.36 2
6 1 3 1.18 0
# etc.
索引不重要，设置现有索引是可以的 列作为索引，最终排序不是 重要。
答：
150赞
Roman Pekar
12/3/2014
#1
比我预期的要长一点：
>>> df
samples subject trial_num
0 [-0.07, -2.9, -2.44] 1 1
1 [-1.52, -0.35, 0.1] 1 2
2 [-0.17, 0.57, -0.65] 1 3
3 [-0.82, -1.06, 0.47] 2 1
4 [0.79, 1.35, -0.09] 2 2
5 [1.17, 1.14, -1.79] 2 3
>>>
>>> s = df.apply(lambda x: pd.Series(x['samples']),axis=1).stack().reset_index(level=1, drop=True)
>>> s.name = 'sample'
>>>
>>> df.drop('samples', axis=1).join(s)
subject trial_num sample
0 1 1 -0.07
0 1 1 -2.90
0 1 1 -2.44
1 1 2 -1.52
1 1 2 -0.35
1 1 2 0.10
2 1 3 -0.17
2 1 3 0.57
2 1 3 -0.65
3 2 1 -0.82
3 2 1 -1.06
3 2 1 0.47
4 2 2 0.79
4 2 2 1.35
4 2 2 -0.09
5 2 3 1.17
5 2 3 1.14
5 2 3 -1.79
如果需要顺序索引，可以应用于结果。reset_index(drop=True)
更新：
>>> res = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack()
>>> res = res.reset_index()
>>> res.columns = ['subject','trial_num','sample_num','sample']
>>> res
subject trial_num sample_num sample
0 1 1 0 1.89
1 1 1 1 -2.92
2 1 1 2 0.34
3 1 2 0 0.85
4 1 2 1 0.24
5 1 2 2 0.72
6 1 3 0 -0.96
7 1 3 1 -2.72
8 1 3 2 -0.11
9 2 1 0 -1.33
10 2 1 1 3.13
11 2 1 2 -0.65
12 2 2 0 0.10
13 2 2 1 0.65
14 2 2 2 0.15
15 2 3 0 0.64
16 2 3 1 -0.10
17 2 3 2 -0.76
评论
0赞
Marius
12/3/2014
谢谢，即使是申请将每个项目放在自己的列中的第一步也是一个巨大的帮助。我能够想出一种稍微不同的方法来做到这一点，但仍然涉及相当多的步骤。显然，这在 Pandas 中并不简单！
1赞
Dennis Golomazov
7/12/2017
很好的答案。您可以通过将其替换为 来缩短它。df.apply(lambda x: pd.Series(x['samples']),axis=1)df.samples.apply(pd.Series)
1赞
cs95
3/13/2018
读者注意：这严重影响了性能问题。请参阅此处，了解使用 numpy 的更高性能的解决方案。
2赞
SarahData
6/8/2018
当所有行的样本数不相同时，解决方案是什么？
9赞
Marius
12/3/2014
#2
为了更好地理解 Roman Pekar 的解决方案，我提出了自己的解决方案，用于避免一些令人困惑的堆叠和索引重置。不过，我不能说这显然是一个更清晰的解决方案：melt
items_as_cols = df.apply(lambda x: pd.Series(x['samples']), axis=1)
# Keep original df index as a column so it's retained after melt
items_as_cols['orig_index'] = items_as_cols.index
melted_items = pd.melt(items_as_cols, id_vars='orig_index',
var_name='sample_num', value_name='sample')
melted_items.set_index('orig_index', inplace=True)
df.merge(melted_items, left_index=True, right_index=True)
输出（显然我们现在可以删除原始样本列）：
samples subject trial_num sample_num sample
0 [1.84, 1.05, -0.66] 1 1 0 1.84
0 [1.84, 1.05, -0.66] 1 1 1 1.05
0 [1.84, 1.05, -0.66] 1 1 2 -0.66
1 [-0.24, -0.9, 0.65] 1 2 0 -0.24
1 [-0.24, -0.9, 0.65] 1 2 1 -0.90
1 [-0.24, -0.9, 0.65] 1 2 2 0.65
2 [1.15, -0.87, -1.1] 1 3 0 1.15
2 [1.15, -0.87, -1.1] 1 3 1 -0.87
2 [1.15, -0.87, -1.1] 1 3 2 -1.10
3 [-0.8, -0.62, -0.68] 2 1 0 -0.80
3 [-0.8, -0.62, -0.68] 2 1 1 -0.62
3 [-0.8, -0.62, -0.68] 2 1 2 -0.68
4 [0.91, -0.47, 1.43] 2 2 0 0.91
4 [0.91, -0.47, 1.43] 2 2 1 -0.47
4 [0.91, -0.47, 1.43] 2 2 2 1.43
5 [-1.14, -0.24, -0.91] 2 3 0 -1.14
5 [-1.14, -0.24, -0.91] 2 3 1 -0.24
5 [-1.14, -0.24, -0.91] 2 3 2 -0.91
12赞
behzad.nouri
12/3/2014
#3
为此，您还可以使用 pd.concat 和 pd.melt：
>>> objs = [df, pd.DataFrame(df['samples'].tolist())]
>>> pd.concat(objs, axis=1).drop('samples', axis=1)
subject trial_num 0 1 2
0 1 1 -0.49 -1.00 0.44
1 1 2 -0.28 1.48 2.01
2 1 3 -0.52 -1.84 0.02
3 2 1 1.23 -1.36 -1.06
4 2 2 0.54 0.18 0.51
5 2 3 -2.18 -0.13 -1.35
>>> pd.melt(_, var_name='sample_num', value_name='sample',
... value_vars=[0, 1, 2], id_vars=['subject', 'trial_num'])
subject trial_num sample_num sample
0 1 1 0 -0.49
1 1 2 0 -0.28
2 1 3 0 -0.52
3 2 1 0 1.23
4 2 2 0 0.54
5 2 3 0 -2.18
6 1 1 1 -1.00
7 1 2 1 1.48
8 1 3 1 -1.84
9 2 1 1 -1.36
10 2 2 1 0.18
11 2 3 1 -0.13
12 1 1 2 0.44
13 1 2 2 2.01
14 1 3 2 0.02
15 2 1 2 -1.06
16 2 2 2 0.51
17 2 3 2 -1.35
最后，如果需要，您可以根据前三列的第一列进行排序。
评论
2赞
Chill2Macht
12/7/2017
这只有在您先验地知道列表的长度和/或它们是否具有相同的长度时才有效？
8赞
Charles Davis
10/28/2017
#4
对于那些正在寻找避免手动列命名的 Roman Pekar 答案版本的人：
column_to_explode = 'samples'
res = (df
.set_index([x for x in df.columns if x != column_to_explode])[column_to_explode]
.apply(pd.Series)
.stack()
.reset_index())
res = res.rename(columns={
res.columns[-2]:'exploded_{}_index'.format(column_to_explode),
res.columns[-1]: '{}_exploded'.format(column_to_explode)})
78赞
MaxU - stand with Ukraine
1/31/2018
#5
更新：下面的解决方案对较旧的 Pandas 版本很有帮助，因为 DataFrame.explode（） 不可用。从 Pandas 0.25.0 开始，您可以简单地使用 .DataFrame.explode()
lst_col = 'samples'
r = pd.DataFrame({
col:np.repeat(df[col].values, df[lst_col].str.len())
for col in df.columns.drop(lst_col)}
).assign(**{lst_col:np.concatenate(df[lst_col].values)})[df.columns]
结果：
In [103]: r
Out[103]:
samples subject trial_num
0 0.10 1 1
1 -0.20 1 1
2 0.05 1 1
3 0.25 1 2
4 1.32 1 2
5 -0.17 1 2
6 0.64 1 3
7 -0.22 1 3
8 -0.71 1 3
9 -0.03 2 1
10 -0.65 2 1
11 0.76 2 1
12 1.77 2 2
13 0.89 2 2
14 0.65 2 2
15 -0.98 2 3
16 0.65 2 3
17 -0.30 2 3
更新：一些解释：IMO 理解此代码的最简单方法是尝试逐步执行它：
在下一行中，我们将在一列中重复值，其中 - 是相应列表的长度：NN
In [10]: np.repeat(df['trial_num'].values, df[lst_col].str.len())
Out[10]: array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3], dtype=int64)
这可以泛化为包含标量值的所有列：
In [11]: pd.DataFrame({
...: col:np.repeat(df[col].values, df[lst_col].str.len())
...: for col in df.columns.drop(lst_col)}
...: )
Out[11]:
trial_num subject
0 1 1
1 1 1
2 1 1
3 2 1
4 2 1
5 2 1
6 3 1
.. ... ...
11 1 2
12 2 2
13 2 2
14 2 2
15 3 2
16 3 2
17 3 2
[18 rows x 2 columns]
使用我们可以展平列 （） 中的所有值并得到一个一维向量：np.concatenate()listsamples
In [12]: np.concatenate(df[lst_col].values)
Out[12]: array([-1.04, -0.58, -1.32, 0.82, -0.59, -0.34, 0.25, 2.09, 0.12, 0.83, -0.88, 0.68, 0.55, -0.56, 0.65, -0.04, 0.36, -0.31])
把所有这些放在一起：
In [13]: pd.DataFrame({
...: col:np.repeat(df[col].values, df[lst_col].str.len())
...: for col in df.columns.drop(lst_col)}
...: ).assign(**{lst_col:np.concatenate(df[lst_col].values)})
Out[13]:
trial_num subject samples
0 1 1 -1.04
1 1 1 -0.58
2 1 1 -1.32
3 2 1 0.82
4 2 1 -0.59
5 2 1 -0.34
6 3 1 0.25
.. ... ... ...
11 1 2 0.68
12 2 2 0.55
13 2 2 -0.56
14 2 2 0.65
15 3 2 -0.04
16 3 2 0.36
17 3 2 -0.31
[18 rows x 3 columns]
using 将保证我们按原始顺序选择列...pd.DataFrame()[df.columns]
评论
3赞
irene
8/7/2018
这应该是公认的答案。与此相比，目前接受的答案要慢得多。
1赞
Greg
10/12/2018
我不知道如何解决这个问题：TypeError：无法根据规则“safe”将数组数据从 dtype（'float64'） 转换为 dtype（'int64'）
1赞
olisteadman
10/26/2018
这是在搜索堆栈整整一个小时后发现的 10+ 中唯一对我有用的答案。谢谢MaxU 🙏
1赞
Charles Davis
3/15/2019
请注意，这会完全删除具有空列表的行;要保留这些行并用 填充它们，您可以在使用此方法之前执行此操作。显然不会返回列表，因此 .lst_collst_colnp.nandf[lst_col] = df[lst_col].apply(lambda x: x if len(x) > 0 else [np.nan]).mask.apply
1赞
ifly6
5/1/2019
这是一个很好的答案，应该是公认的答案。虽然，这是一个黑魔法级别的答案，我，就我而言，希望能解释一下这些步骤实际上做了什么。
6赞
Michael Silverstein
5/24/2018
#6
我发现最简单的方法是：
- 将列转换为 DataFrame
samples - 与原始 df 联接
- 融化
此处显示：
df.samples.apply(lambda x: pd.Series(x)).join(df).\
melt(['subject','trial_num'],[0,1,2],var_name='sample')
subject trial_num sample value
0 1 1 0 -0.24
1 1 2 0 0.14
2 1 3 0 -0.67
3 2 1 0 -1.52
4 2 2 0 -0.00
5 2 3 0 -1.73
6 1 1 1 -0.70
7 1 2 1 -0.70
8 1 3 1 -0.29
9 2 1 1 -0.70
10 2 2 1 -0.72
11 2 3 1 1.30
12 1 1 2 -0.55
13 1 2 2 0.10
14 1 3 2 -0.44
15 2 1 2 0.13
16 2 2 2 -1.44
17 2 3 2 0.73
值得注意的是，这可能只是因为每个试验都有相同数量的样本 （3）。对于不同样本量的试验，可能需要一些更聪明的东西。
3赞
Khris
7/1/2019
#7
很晚的回答，但我想补充一下：
一个使用普通 Python 的快速解决方案，它也处理了 OP 示例中的列。在我自己的大型数据集上，有超过 1000 万行，结果有 2800 万行，这只需要大约 38 秒。公认的解决方案完全分解了这么多数据，并导致我的系统具有 128GB 的 RAM。sample_nummemory error
df = df.reset_index(drop=True)
lstcol = df.lstcol.values
lstcollist = []
indexlist = []
countlist = []
for ii in range(len(lstcol)):
lstcollist.extend(lstcol[ii])
indexlist.extend([ii]*len(lstcol[ii]))
countlist.extend([jj for jj in range(len(lstcol[ii]))])
df = pd.merge(df.drop("lstcol",axis=1),pd.DataFrame({"lstcol":lstcollist,"lstcol_num":countlist},
index=indexlist),left_index=True,right_index=True).reset_index(drop=True)
168赞
cs95
7/20/2019
#8
熊猫>= 0.25
Series 和 DataFrame 方法定义一个 .explode（） 方法，该方法将列表分解为单独的行。请参阅分解类似列表的列的文档部分。
df = pd.DataFrame({
'var1': [['a', 'b', 'c'], ['d', 'e',], [], np.nan],
'var2': [1, 2, 3, 4]
})
df
var1 var2
0 [a, b, c] 1
1 [d, e] 2
2 [] 3
3 NaN 4
df.explode('var1')
var1 var2
0 a 1
0 b 1
0 c 1
1 d 2
1 e 2
2 NaN 3 # empty list converted to NaN
3 NaN 4 # NaN entry preserved as-is
# to reset the index to be monotonically increasing...
df.explode('var1').reset_index(drop=True)
var1 var2
0 a 1
1 b 1
2 c 1
3 d 2
4 e 2
5 NaN 3
6 NaN 4
请注意，这也适当地处理列表和标量的混合列，以及空列表和 NaN（这是基于 的解决方案的缺点）。repeat
但是，您应该注意，explode 仅适用于单个列（目前）。
P.S.：如果你想分解一列字符串，你需要先在分隔符上拆分，然后使用 .看到我这个（非常）相关的答案。explode
评论
18赞
Kai
8/6/2019
最后，Pandas 的 explode（）！
2赞
addicted
5/12/2020
最后！太震撼了！上面@MaxU很好的答案，但这使事情变得更加简单。
2赞
Kevin Languasco
3/15/2021
这是当前熊猫的正确答案
1赞
minimalpop
4/1/2021
这应该是正确的答案——如此简单，如此优雅，如此熊猫式。
0赞
Umar Yusuf
12/13/2022
explode（） 函数现在可以处理多个列，如下所示： df.explode（['var1'， 'var2']）
4赞
Tapas
8/20/2019
#9
import pandas as pd
df = pd.DataFrame([{'Product': 'Coke', 'Prices': [100,123,101,105,99,94,98]},{'Product': 'Pepsi', 'Prices': [101,104,104,101,99,99,99]}])
print(df)
df = df.assign(Prices=df.Prices.str.split(',')).explode('Prices')
print(df)
在 pandas >=0.25 版本中尝试这个
评论
2赞
Oren
8/30/2019
不需要，因为已经是一个列表。.str.split(',')Prices
2赞
DoRemy95
1/15/2020
#10
也很晚，但这是 Karvy1 的答案，如果您没有熊猫 >=0.25 版本，它对我来说效果很好：https://stackoverflow.com/a/52511166/10740287
对于上面的例子，你可以这样写：
data = [(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples]
data = pd.DataFrame(data, columns=['subject', 'trial_num', 'samples'])
速度测试：
%timeit data = pd.DataFrame([(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples], columns=['subject', 'trial_num', 'samples'])
每个环路 1.33 ms ± 74.8 μs（7 次运行，每次 1000 个环路的平均值±标准开发）
%timeit data = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack().reset_index()
每个环路 4.9 ms ± 189 μs（平均 ± 标准开发 7 次运行，每次 100 个环路）
%timeit data = pd.DataFrame({col:np.repeat(df[col].values, df['samples'].str.len())for col in df.columns.drop('samples')}).assign(**{'samples':np.concatenate(df['samples'].values)})
每个环路 1.38 ms ± 25 μs（平均 7 次运行，每次 1000 个环路的标准开发±）
评论
df.explode（'samples'）来解决这个问题。 目前只能支持爆破一列。explode