Python 将元组列表转换为多索引

我有一个

数据帧

，看起来像这样：

    id    t_l
0   100   [('a', 1), ('b', 2)]
1   151   [('x', 4), ('y', 3)]

    id    f    g
0   100  'a'   1
1        'b'   2
2   151  'x'   4
3        'y'   3

我需要返回一个如下所示的

DataFrame

：

    id    t_l
0   100   [('a', 1), ('b', 2)]
1   151   [('x', 4), ('y', 3)]

    id    f    g
0   100  'a'   1
1        'b'   2
2   151  'x'   4
3        'y'   3

最好的方法是什么？

编辑： @ALollz在

np.concatenate

与

chain.from\u iterable（df.t\u l）

的速度方面提出了很好的观点。我

%timeit

，这是真的。因此，我使用

从_iterable（df.t_l）

原件：

我将使用

np构建一个新的
df
。将数据与
np连接起来。对索引重复
。最后，
reset_index
将
id
放回列中

pd.DataFrame(np.concatenate(df.t_l), index=np.repeat(df.id, df.t_l.str.len()), \
                                              columns=['f', 'g']).reset_index()

Out[596]:
    id  f  g
0  100  a  1
1  100  b  2
2  151  x  4
3  151  y  3

编辑：
@ALollz在
np.concatenate
与
chain.from\u iterable（df.t\u l）
的速度方面提出了很好的观点。我
%timeit
，这是真的。因此，我使用
从_iterable（df.t_l）

原件：

我将使用
np构建一个新的
df
。将数据与
np连接起来。对索引重复
。最后，
reset_index
将
id
放回列中

pd.DataFrame(np.concatenate(df.t_l), index=np.repeat(df.id, df.t_l.str.len()), \
                                              columns=['f', 'g']).reset_index()

Out[596]:
    id  f  g
0  100  a  1
1  100  b  2
2  151  x  4
3  151  y  3

或者。。为了提高效率，删除了pd.Series
方法

pd.DataFrame(df.set_index('id').apply(lambda x: pd.Series([list(i) for i in list(x.t_l)]), axis=1).stack()).rename({0:'f',1:'g'}, axis=1).reset_index(level=1, drop=True)

输出

     f  g
id       
100  a  1
100  b  2
151  x  4
151  y  3

或者。。为了提高效率，删除了pd.Series
方法

pd.DataFrame(df.set_index('id').apply(lambda x: pd.Series([list(i) for i in list(x.t_l)]), axis=1).stack()).rename({0:'f',1:'g'}, axis=1).reset_index(level=1, drop=True)

输出

     f  g
id       
100  a  1
100  b  2
151  x  4
151  y  3

使用
apply（）
和
pd.multiindex
：-

df = pd.DataFrame(data = [ [100, [('a', 1), ('b', 2)] ] , [151,[('x', 4), ('y', 3)]] 
], columns=['id', 't_1'] )


inside, outside, value = [], [], []
c = 0
def get_outside(x):
    global c
    length = len( df['t_1'][c] )
    c+=1
    for var in range(length):
        outside.append(x)

def get_inside_value(y):
    for var in y:
        inside.append(var[0])
        value.append(var[1])


df['id'].apply(get_outside)
df['t_1'].apply(get_inside_value)

hier_index = list(zip(outside,inside))
hier_index = pd.MultiIndex.from_tuples(hier_index)
new_df = pd.DataFrame(value ,index=hier_index,columns=['g',])
new_df.index.names = ['id','f']
new_df

输出

使用
apply（）
和
pd.multiindex
：-

df = pd.DataFrame(data = [ [100, [('a', 1), ('b', 2)] ] , [151,[('x', 4), ('y', 3)]] 
], columns=['id', 't_1'] )


inside, outside, value = [], [], []
c = 0
def get_outside(x):
    global c
    length = len( df['t_1'][c] )
    c+=1
    for var in range(length):
        outside.append(x)

def get_inside_value(y):
    for var in y:
        inside.append(var[0])
        value.append(var[1])


df['id'].apply(get_outside)
df['t_1'].apply(get_inside_value)

hier_index = list(zip(outside,inside))
hier_index = pd.MultiIndex.from_tuples(hier_index)
new_df = pd.DataFrame(value ,index=hier_index,columns=['g',])
new_df.index.names = ['id','f']
new_df

输出

将嵌套列表理解与
zip
一起使用：

zipped = zip(df['id'], df['t_l'])
df = pd.DataFrame([(i, y1, y2) for i, x in zipped for y1, y2 in x], columns=['id','f','g'])
print (df)
    id  f  g
0  100  a  1
1  100  b  2
2  151  x  4
3  151  y  3

如果需要多索引系列：

zipped = zip(df['id'], df['t_l'])
s = pd.Series({(i, y1):y2 for i, x in zipped for y1, y2 in x})
print (s)
100  a    1
     b    2
151  x    4
     y    3
dtype: int64

将嵌套列表理解与
zip
一起使用：

zipped = zip(df['id'], df['t_l'])
df = pd.DataFrame([(i, y1, y2) for i, x in zipped for y1, y2 in x], columns=['id','f','g'])
print (df)
    id  f  g
0  100  a  1
1  100  b  2
2  151  x  4
3  151  y  3

如果需要多索引系列：

zipped = zip(df['id'], df['t_l'])
s = pd.Series({(i, y1):y2 for i, x in zipped for y1, y2 in x})
print (s)
100  a    1
     b    2
151  x    4
     y    3
dtype: int64

这将系统地解压t_1元素，并以所需的结构输出数据帧

输出：

     id  f  g
0   100  a  1
01       b  2
1   151  x  4
11       y  3

警告：这是一种简单的方法，但是如果用于大量数据，成本可能会显著提高

这将系统地解压t_1元素，并以所需的结构输出数据帧

输出：

     id  f  g
0   100  a  1
01       b  2
1   151  x  4
11       y  3

警告：这是一种简单的方法，但是如果用于大量数据，成本可能会显著提高。
np.对于较大的数据帧，串联将大大降低速度。可以使用
chain.from\u iterable（df.t\u l）
fromitertools@ALollz：哈，很有趣。是因为numpy必须在concat？之前将元组转换为数组吗+1I与itertools
np类似。对于较大的数据帧，concatenate
将大大降低速度。可以使用
chain.from\u iterable（df.t\u l）
fromitertools@ALollz：哈，很有趣。是因为numpy必须在concat？之前将元组转换为数组吗+1我喜欢itertools