这是一个相当直接的消息，它使用pandas str访问器的split方法，然后使用NumPy将每一行平铺成一个数组。

通过使用np.repeat以正确的次数重复未分割的列来检索相应的值。

var1 = df.var1.str.split(',', expand=True).values.ravel()
var2 = np.repeat(df.var2.values, len(var1) / len(df))

pd.DataFrame({'var1': var1,
              'var2': var2})

  var1  var2
0    a     1
1    b     1
2    c     1
3    d     2
4    e     2
5    f     2

博士TL;

import pandas as pd
import numpy as np

def explode_str(df, col, sep):
    s = df[col]
    i = np.arange(len(s)).repeat(s.str.count(sep) + 1)
    return df.iloc[i].assign(**{col: sep.join(s).split(sep)})

def explode_list(df, col):
    s = df[col]
    i = np.arange(len(s)).repeat(s.str.len())
    return df.iloc[i].assign(**{col: np.concatenate(s)})

---

示范

explode_str(a, 'var1', ',')

  var1  var2
0    a     1
0    b     1
0    c     1
1    d     2
1    e     2
1    f     2

让我们创建一个包含列表的新数据框架d

d = a.assign(var1=lambda d: d.var1.str.split(','))

explode_list(d, 'var1')

  var1  var2
0    a     1
0    b     1
0    c     1
1    d     2
1    e     2
1    f     2

---

一般的评论

我用np。使用repeat来生成我可以用iloc使用的数据框架索引位置。

FAQ

为什么不用loc?

因为索引可能不是唯一的，使用loc将返回与查询索引匹配的每一行。

为什么不用values属性切片呢?

当调用值时，如果整个数据框架在一个内聚的“块”中，Pandas将返回该“块”数组的视图。否则熊猫将不得不拼凑一个新的阵列。补码时，该数组必须是统一的dtype。这通常意味着返回一个dtype为object的数组。通过使用iloc而不是对values属性进行切片，我减轻了不得不处理这个问题的负担。

为什么使用赋值?

当我使用与爆炸相同的列名进行赋值时，我将覆盖现有的列并保持其在数据框架中的位置。

为什么索引值重复?

通过在重复位置上使用iloc，得到的索引显示相同的重复模式。对列表或字符串中的每个元素重复一次。 这可以用reset_index(drop=True)重置

---

为字符串

我不想过早地把弦分开。因此，我计算sep参数的出现次数，假设我要分割，结果列表的长度将比分隔符的数量多1。

然后我使用sep来连接字符串，然后分裂。

def explode_str(df, col, sep):
    s = df[col]
    i = np.arange(len(s)).repeat(s.str.count(sep) + 1)
    return df.iloc[i].assign(**{col: sep.join(s).split(sep)})

为列表

与字符串类似，只是我不需要计算sep的出现次数，因为它已经分裂了。

我使用Numpy的concatenate将列表阻塞在一起。

import pandas as pd
import numpy as np

def explode_list(df, col):
    s = df[col]
    i = np.arange(len(s)).repeat(s.str.len())
    return df.iloc[i].assign(**{col: np.concatenate(s)})

---

熊猫>= 0.25

Series和DataFrame方法定义了. explosion()方法，该方法将列表分解为单独的行。请参阅文档部分关于分解一个类似列表的列。

因为您有一个由逗号分隔的字符串列表，用逗号分隔字符串以获得元素列表，然后在该列上调用explosion。

df = pd.DataFrame({'var1': ['a,b,c', 'd,e,f'], 'var2': [1, 2]})
df
    var1  var2
0  a,b,c     1
1  d,e,f     2

df.assign(var1=df['var1'].str.split(',')).explode('var1')

  var1  var2
0    a     1
0    b     1
0    c     1
1    d     2
1    e     2
1    f     2

注意，爆炸只对单列有效(目前)。要同时爆炸多个列，请参见下面。

nan和空列表得到了他们应得的待遇，而不需要你跳圈来得到正确的。

df = pd.DataFrame({'var1': ['d,e,f', '', np.nan], 'var2': [1, 2, 3]})
df
    var1  var2
0  d,e,f     1
1            2
2    NaN     3

df['var1'].str.split(',')

0    [d, e, f]
1           []
2          NaN

df.assign(var1=df['var1'].str.split(',')).explode('var1')

  var1  var2
0    d     1
0    e     1
0    f     1
1          2  # empty list entry becomes empty string after exploding 
2  NaN     3  # NaN left un-touched

这相对于基于ravel/repeat的解决方案(后者完全忽略空列表，并阻塞在nan上)是一个很大的优势。

---

多列爆炸

熊猫1.3更新

df。从pandas 1.3开始，explosion在多个列上工作:

df = pd.DataFrame({'var1': ['a,b,c', 'd,e,f'], 
                   'var2': ['i,j,k', 'l,m,n'], 
                   'var3': [1, 2]})
df
    var1   var2  var3
0  a,b,c  i,j,k     1
1  d,e,f  l,m,n     2

(df.set_index(['var3']) 
       .apply(lambda col: col.str.split(','))
       .explode(['var1', 'var2'])
       .reset_index()
       .reindex(df.columns, axis=1))

  var1 var2  var3
0    a    i     1
1    b    j     1
2    c    k     1
3    d    l     2
4    e    m     2
5    f    n     2

在旧版本中，你会将爆炸列移动到应用程序内部，这是一个性能差得多的应用程序:

(df.set_index(['var3']) 
   .apply(lambda col: col.str.split(',').explode())
   .reset_index()
   .reindex(df.columns, axis=1))

其思想是将所有不应该被分解的列设置为索引，然后通过apply分解剩余的列。当列表大小相等时，这种方法效果很好。

在最近的熊猫版本中，你可以使用分裂和爆炸

a.assign(var1=a['var1'].str.split(',')).explode('var1')

a

   var1 var2
0   a   1
0   b   1
0   c   1
1   d   2
1   e   2
1   f   2

这里有很多答案，但我很惊讶没有人提到内置的熊猫爆炸功能。看看下面的链接: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.explode.html#pandas.DataFrame.explode

由于某种原因，我无法访问该函数，所以我使用下面的代码:

import pandas_explode
pandas_explode.patch()
df_zlp_people_cnt3 = df_zlp_people_cnt2.explode('people')

以上是我的数据样本。如你所见，人物栏有一系列人物，我试图把它炸开。我给出的代码适用于列表类型数据。因此，请尝试将逗号分隔的文本数据转换为列表格式。此外，由于我的代码使用内置函数，它比自定义/应用函数快得多。

注意:你可能需要用pip安装pandas_explosion。

有可能在不改变数据框架结构的情况下拆分和爆炸数据框架

拆分和展开特定列的数据

输入:

    var1    var2
0   a,b,c   1
1   d,e,f   2



#Get the indexes which are repetative with the split 
df['var1'] = df['var1'].str.split(',')
df = df.explode('var1')

Out:

    var1    var2
0   a   1
0   b   1
0   c   1
1   d   2
1   e   2
1   f   2

Edit-1

对多列的行进行拆分和展开

Filename    RGB                                             RGB_type
0   A   [[0, 1650, 6, 39], [0, 1691, 1, 59], [50, 1402...   [r, g, b]
1   B   [[0, 1423, 16, 38], [0, 1445, 16, 46], [0, 141...   [r, g, b]

基于参考列重新索引，并将列值信息与堆栈对齐

df = df.reindex(df.index.repeat(df['RGB_type'].apply(len)))
df = df.groupby('Filename').apply(lambda x:x.apply(lambda y: pd.Series(y.iloc[0])))
df.reset_index(drop=True).ffill()

Out:

                Filename    RGB_type    Top 1 colour    Top 1 frequency Top 2 colour    Top 2 frequency
    Filename                            
 A  0       A   r   0   1650    6   39
    1       A   g   0   1691    1   59
    2       A   b   50  1402    49  187
 B  0       B   r   0   1423    16  38
    1       B   g   0   1445    16  46
    2       B   b   0   1419    16  39