Python 多索引的字典键字典

我有一个嵌套的dictionary对象，我想转换为多索引数据帧，如何实现它

例如

所以我想转换成一个具有索引的数据帧

a
   1        0      1  
      0    1.0    2.0 
      1    3.0    4.0
   2  
      0    5.0    6.0
      1    7.0    8.0
b
   1
      0    1.0    2.0
      1    3.0    4.0
   2
      0    5.0    6.0
      1    7.0    8.0

---

我想我可以使用

多索引（levels=[['a'，'b'，[1,2]]）

但是我不知道如何构造标签。我也不知道如何将dict值作为数据数组传递。

一个dict帧组成一个面板，

到_frame

转换为一个2级索引， 您需要一个额外的级别，当通过dict时concat将形成该级别

从理论上讲，如果你需要更多的层次，你可以做一些类似于递归还原的事情，但这会炸毁大脑。要获得准确的输出，可以执行

sortlevel

In [36]: concat( dict([ (k,Panel(v).to_frame()) for k,v in t.items() ]) , names= ['level'])
Out[36]: 
                   1  2
level major minor      
a     0     0      1  5
            1      2  6
      1     0      3  7
            1      4  8
b     0     0      1  5
            1      2  6
      1     0      3  7
            1      4  8

---

我发现从元组列表中获取多索引是最容易的，如前所述

使用您的示例，我们有一个嵌套字典，如

In [25]: t
Out[25]: 
{'a': {'1':    0  1
0  1  2
1  3  4, '2':    0  1
0  5  6
1  7  8},
 'b': {'1':    0  1
0  1  2
1  3  4, '2':    0  1
0  5  6
1  7  8}}

如果你想让你的头受点伤，你可以使用以下列表：

In [50]: tuples = [(x, y, z) for x in t for y in t[x] for z in t[x][y]]

In [51]: tuples
Out[51]: 
[('a', '1', 0),
 ('a', '1', 1),
 ('a', '2', 0),
 ('a', '2', 1),
 ('b', '1', 0),
 ('b', '1', 1),
 ('b', '2', 0),
 ('b', '2', 1)]

然后，

idx=pd.MultiIndex.from_tuples（tuples）

将用作索引

将这些值解压缩需要做更多的工作

编辑：你真的应该去杰夫的答案，但为了完整性：

In [114]: df = pd.concat([x for z in t for x in t[z].values()])

In [115]: df.index = idx

In [118]: df
Out[118]: 
       0  1
a 1 0  1  2
    1  3  4
  2 0  5  6
    1  7  8
b 1 0  1  2
    1  3  4
  2 0  5  6
    1  7  8

---

不幸的是，我有3个级别。我提出了这个

pd.concat（dict（[（k，pd.concat（dict（[（x，pd.Panel（y）.to_frame（））代表x，y代表v.items（））））代表k，v代表t.items（））

但是结果看起来不正确上面的输出有三个级别：级别，主要，次要。我相信这就是你问的理论，我的意思是我只给出了两个级别（字典字典）为了说明这一情况，您的解决方案在这种情况下非常有效。但实际上我有3个级别的字典。即

t['a'][1]['f']=pd.DataFrame（…）

。因此，我将您的解决方案扩展了一个级别，但我的理解是错误的，因为结果看起来不正确。

In [114]: df = pd.concat([x for z in t for x in t[z].values()])

In [115]: df.index = idx

In [118]: df
Out[118]: 
       0  1
a 1 0  1  2
    1  3  4
  2 0  5  6
    1  7  8
b 1 0  1  2
    1  3  4
  2 0  5  6
    1  7  8