Python 伊皮顿+；熊猫一行不行

我试图在IPython上做一个oneliner，但是我得到了

语法错误：无效语法
。代码如下：

 for zzz in ddd.index: zzz1 = zzz.split('///'); zzz3 = [zzz2.strip() for zzz2 in zzz1 if len(zzz1) > 1]; for zzz4 in zzz3: ddd.ix[zzz4]['Class'] = ddd.ix[zzz]['Class']; del ddd.ix[zzz]

我可以这样解释：
对于数据帧
ddd
索引上的每个值，我使用
//
作为分隔符将其拆分。然后，如果返回了多个值，我将为每个值创建一行并删除原始行。
例如，我有：

             Class
lal          1
eri /// iii  2
aks          3

我想获得

             Class
lal          1
eri          2
iii          2
aks          3

第一列（`lal'，'eri'，…）是数据帧的索引

我怎样才能做到这一点？我已经翻遍了文档，但没有找到方法

谢谢
我不知道你想在这里做什么

In [13]: df
Out[13]: 
             A  B
0          lal  1
1  eri /// iii  2
2          aks  3

下面是一个非常长的表达式。好消息是，这将是相当快的

In [56]: split = df['A'].str.split('\s+\/\/\/\s+').apply(Series)

In [57]: split
Out[57]: 
     0    1
0  lal  NaN
1  eri  iii
2  aks  NaN

In [58]: indexed = split.unstack().dropna()

In [59]: indexed
Out[59]: 
0  0    lal
   1    eri
   2    aks
1  1    iii
dtype: object

 In [61]: grouped = indexed.groupby(level=1).apply(
           lambda x: Series(x.values,index=list(x.index.get_level_values(1))))

In [62]: grouped
Out[62]: 
0  0    lal
1  1    eri
   1    iii
2  2    aks
dtype: object

In [63]: grouped.reset_index().set_index('level_1')
Out[63]: 
         level_0    0
level_1              
0              0  lal
1              1  eri
1              1  iii
2              2  aks

不知道你在这里想做什么

In [13]: df
Out[13]: 
             A  B
0          lal  1
1  eri /// iii  2
2          aks  3

下面是一个非常长的表达式。好消息是，这将是相当快的

In [56]: split = df['A'].str.split('\s+\/\/\/\s+').apply(Series)

In [57]: split
Out[57]: 
     0    1
0  lal  NaN
1  eri  iii
2  aks  NaN

In [58]: indexed = split.unstack().dropna()

In [59]: indexed
Out[59]: 
0  0    lal
   1    eri
   2    aks
1  1    iii
dtype: object

 In [61]: grouped = indexed.groupby(level=1).apply(
           lambda x: Series(x.values,index=list(x.index.get_level_values(1))))

In [62]: grouped
Out[62]: 
0  0    lal
1  1    eri
   1    iii
2  2    aks
dtype: object

In [63]: grouped.reset_index().set_index('level_1')
Out[63]: 
         level_0    0
level_1              
0              0  lal
1              1  eri
1              1  iii
2              2  aks

不知道你在这里想做什么

In [13]: df
Out[13]: 
             A  B
0          lal  1
1  eri /// iii  2
2          aks  3

下面是一个非常长的表达式。好消息是，这将是相当快的

In [56]: split = df['A'].str.split('\s+\/\/\/\s+').apply(Series)

In [57]: split
Out[57]: 
     0    1
0  lal  NaN
1  eri  iii
2  aks  NaN

In [58]: indexed = split.unstack().dropna()

In [59]: indexed
Out[59]: 
0  0    lal
   1    eri
   2    aks
1  1    iii
dtype: object

 In [61]: grouped = indexed.groupby(level=1).apply(
           lambda x: Series(x.values,index=list(x.index.get_level_values(1))))

In [62]: grouped
Out[62]: 
0  0    lal
1  1    eri
   1    iii
2  2    aks
dtype: object

In [63]: grouped.reset_index().set_index('level_1')
Out[63]: 
         level_0    0
level_1              
0              0  lal
1              1  eri
1              1  iii
2              2  aks

不知道你在这里想做什么

In [13]: df
Out[13]: 
             A  B
0          lal  1
1  eri /// iii  2
2          aks  3

下面是一个非常长的表达式。好消息是，这将是相当快的

In [56]: split = df['A'].str.split('\s+\/\/\/\s+').apply(Series)

In [57]: split
Out[57]: 
     0    1
0  lal  NaN
1  eri  iii
2  aks  NaN

In [58]: indexed = split.unstack().dropna()

In [59]: indexed
Out[59]: 
0  0    lal
   1    eri
   2    aks
1  1    iii
dtype: object

 In [61]: grouped = indexed.groupby(level=1).apply(
           lambda x: Series(x.values,index=list(x.index.get_level_values(1))))

In [62]: grouped
Out[62]: 
0  0    lal
1  1    eri
   1    iii
2  2    aks
dtype: object

In [63]: grouped.reset_index().set_index('level_1')
Out[63]: 
         level_0    0
level_1              
0              0  lal
1              1  eri
1              1  iii
2              2  aks

这里有一个与@Jeff's相反的版本：速度非常慢，但我认为非常清晰

index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
old_i, new_i = zip(*index_pairs)
df2 = df.ix[list(old_i)]
df2.index = new_i

请注意，这假设原始索引是唯一的


从我们的框架开始：

>>> df
             Class
lal              1
eri /// iii      2
aks              3

列出将原始索引与所需数量的新子索引连接起来的对：

>>> index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
>>> index_pairs
[('lal', 'lal'), ('eri /// iii', 'eri'), ('eri /// iii', 'iii'), ('aks', 'aks')]

转置：

>>> old_i, new_i = zip(*index_pairs)
>>> old_i
('lal', 'eri /// iii', 'eri /// iii', 'aks')
>>> new_i
('lal', 'eri', 'iii', 'aks')

使用旧索引索引到
df
：

>>> df2 = df.ix[list(old_i)]
>>> df2
             Class
lal              1
eri /// iii      2
eri /// iii      2
aks              3

重置索引：

>>> df2.index = new_i
>>> df2
     Class
lal      1
eri      2
iii      2
aks      3

这里有一个与@Jeff's相反的版本：速度非常慢，但我认为非常清晰

index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
old_i, new_i = zip(*index_pairs)
df2 = df.ix[list(old_i)]
df2.index = new_i

请注意，这假设原始索引是唯一的


从我们的框架开始：

>>> df
             Class
lal              1
eri /// iii      2
aks              3

列出将原始索引与所需数量的新子索引连接起来的对：

>>> index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
>>> index_pairs
[('lal', 'lal'), ('eri /// iii', 'eri'), ('eri /// iii', 'iii'), ('aks', 'aks')]

转置：

>>> old_i, new_i = zip(*index_pairs)
>>> old_i
('lal', 'eri /// iii', 'eri /// iii', 'aks')
>>> new_i
('lal', 'eri', 'iii', 'aks')

使用旧索引索引到
df
：

>>> df2 = df.ix[list(old_i)]
>>> df2
             Class
lal              1
eri /// iii      2
eri /// iii      2
aks              3

重置索引：

>>> df2.index = new_i
>>> df2
     Class
lal      1
eri      2
iii      2
aks      3

这里有一个与@Jeff's相反的版本：速度非常慢，但我认为非常清晰

index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
old_i, new_i = zip(*index_pairs)
df2 = df.ix[list(old_i)]
df2.index = new_i

请注意，这假设原始索引是唯一的


从我们的框架开始：

>>> df
             Class
lal              1
eri /// iii      2
aks              3

列出将原始索引与所需数量的新子索引连接起来的对：

>>> index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
>>> index_pairs
[('lal', 'lal'), ('eri /// iii', 'eri'), ('eri /// iii', 'iii'), ('aks', 'aks')]

转置：

>>> old_i, new_i = zip(*index_pairs)
>>> old_i
('lal', 'eri /// iii', 'eri /// iii', 'aks')
>>> new_i
('lal', 'eri', 'iii', 'aks')

使用旧索引索引到
df
：

>>> df2 = df.ix[list(old_i)]
>>> df2
             Class
lal              1
eri /// iii      2
eri /// iii      2
aks              3

重置索引：

>>> df2.index = new_i
>>> df2
     Class
lal      1
eri      2
iii      2
aks      3

这里有一个与@Jeff's相反的版本：速度非常慢，但我认为非常清晰

index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
old_i, new_i = zip(*index_pairs)
df2 = df.ix[list(old_i)]
df2.index = new_i

请注意，这假设原始索引是唯一的


从我们的框架开始：

>>> df
             Class
lal              1
eri /// iii      2
aks              3

列出将原始索引与所需数量的新子索引连接起来的对：

>>> index_pairs = [(ind, subind.strip()) for ind in df.index for subind in ind.split("///")]
>>> index_pairs
[('lal', 'lal'), ('eri /// iii', 'eri'), ('eri /// iii', 'iii'), ('aks', 'aks')]

转置：

>>> old_i, new_i = zip(*index_pairs)
>>> old_i
('lal', 'eri /// iii', 'eri /// iii', 'aks')
>>> new_i
('lal', 'eri', 'iii', 'aks')

使用旧索引索引到
df
：

>>> df2 = df.ix[list(old_i)]
>>> df2
             Class
lal              1
eri /// iii      2
eri /// iii      2
aks              3

重置索引：

>>> df2.index = new_i
>>> df2
     Class
lal      1
eri      2
iii      2
aks      3

这个的副本：，使用
ddd.ix[zzz4，'Class`]=ddd.ix[zzz，'Class']
它不起作用。。也许它不允许用这种语法在一行上写两个for？出于好奇：为什么要写这一行？你有某种反垂直的偏见吗？在Python中这将是一个问题，因为编写好的代码涉及到
if/elif/else
和
try/except
，不能将它们放在一行上。哈哈，我的错。我也是，我只是在玩IPython，以增量方式创建一个管道，看看如何做一些事情。重复这个：，使用
ddd.ix[zzz4，'Class`]=ddd.ix[zzz，'Class']
它不起作用。。也许它不允许用这种语法在一行上写两个for？出于好奇：为什么要写这一行？你有某种反垂直的偏见吗？在Python中这将是一个问题，因为编写好的代码涉及到
if/elif/else
和
try/except
，不能将它们放在一行上。哈哈，我的错。我也是，我只是在玩IPython，以增量方式创建一个管道，看看如何做一些事情。重复这个：，使用
ddd.ix[zzz4，'Class`]=ddd.ix[zzz，'Class']
它不起作用。。也许它不允许用这种语法在一行上写两个for？出于好奇：为什么要写这一行？你有某种反垂直的偏见吗？在Python中这将是一个问题，因为编写好的代码涉及到
if/elif/else
和
try/except
，不能将它们放在一行上。哈哈，我的错。我也是，我只是在玩IPython，以增量方式创建一个管道，看看如何做一些事情。重复这个：，使用
ddd.ix[zzz4，'Class`]=ddd.ix[zzz，'Class']
它不起作用。。也许它不允许用这种语法在一行上写两个for？出于好奇：为什么要写这一行？你有某种反垂直的偏见吗？在Python中这将是一个问题，因为编写好的代码涉及到
if/elif/else
和
try/except
，不能将它们放在一行上。哈哈，我的错。我也是，我只是在玩IPython，以增量方式创建一个管道，看看如何做一些事情..我认为OP是在
pd.DataFrame（{“Index”：[“lal”，“eri”，“iii”，“aks”]，“Class:[1,2,2,3]}）
，尽管我不知道
Index
是指列还是指索引。@DSM你说得对，而
Index
是索引。。我将更新问题我认为OP是在
pd.DataFrame（{“Index”：[“lal”，“eri”，“iii”，“aks”]，“Class:[1,2,2,3]}）之后的
，尽管我不知道
Index
是指列还是指索引。@DSM你是对的，
Index
是指索引。。我将更新问题我认为OP是在
pd.DataFrame（{“Index”：[“lal”，“eri”，“iii”，“aks”]，“Class:[1,2,2,3]}）之后的
，尽管我不知道
Index
是指列还是指索引。@DSM你是对的，
Index
是指索引。。我会更新t