假设我有一个嵌套字典'user_dict'，结构为：
等级1： UserId（长整数）
等级2：类别（字符串）
等级3：各种属性（浮点数，整数等等）
例如，此词典的条目是：
user_dict[12] = {
"Category 1": {"att_1": 1,
"att_2": "whatever"},
"Category 2": {"att_1": 23,
"att_2": "another"}}
“user_dict”中的每个项目具有相同的结构，“user_dict”包含大量项目，我想将这些项目提供给pandas DataFrame，从属性构建系列。在这种情况下，分层索引对此非常有用。
具体来说，我的问题是，是否存在一种方法来帮助DataFrame构造函数理解该系列应该从字典中“级别3”的值构建？
如果我尝试这样的话：
df = pandas.DataFrame(users_summary)
“级别1”中的项目（用户ID）被视为列，这与我想要实现的目标相反（将用户ID作为索引）。
我知道我可以在遍历字典条目后构建系列，但如果有更直接的方法，这将非常有用。类似的问题是询问是否可以从文件中列出的json对象构造pandas DataFrame。
答案 0 :(得分：89)
pandas MultiIndex由一系列元组组成。因此，最自然的方法是重新整形输入dict，使其键是与您需要的多索引值对应的元组。然后，您可以使用pd.DataFrame.from_dict：
orient='index'构建数据框
user_dict = {12: {'Category 1': {'att_1': 1, 'att_2': 'whatever'},
'Category 2': {'att_1': 23, 'att_2': 'another'}},
15: {'Category 1': {'att_1': 10, 'att_2': 'foo'},
'Category 2': {'att_1': 30, 'att_2': 'bar'}}}
pd.DataFrame.from_dict({(i,j): user_dict[i][j]
for i in user_dict.keys()
for j in user_dict[i].keys()},
orient='index')
att_1 att_2
12 Category 1 1 whatever
Category 2 23 another
15 Category 1 10 foo
Category 2 30 bar
另一种方法是通过连接组件数据帧来构建数据帧：
user_ids = []
frames = []
for user_id, d in user_dict.iteritems():
user_ids.append(user_id)
frames.append(pd.DataFrame.from_dict(d, orient='index'))
pd.concat(frames, keys=user_ids)
att_1 att_2
12 Category 1 1 whatever
Category 2 23 another
15 Category 1 10 foo
Category 2 30 bar
答案 1 :(得分：11)
所以我过去常常使用for循环遍历字典，但我发现有一点可以更快地转换为面板然后转换为数据帧。 假设你有一本字典d
import pandas as pd
d
{'RAY Index': {datetime.date(2014, 11, 3): {'PX_LAST': 1199.46,
'PX_OPEN': 1200.14},
datetime.date(2014, 11, 4): {'PX_LAST': 1195.323, 'PX_OPEN': 1197.69},
datetime.date(2014, 11, 5): {'PX_LAST': 1200.936, 'PX_OPEN': 1195.32},
datetime.date(2014, 11, 6): {'PX_LAST': 1206.061, 'PX_OPEN': 1200.62}},
'SPX Index': {datetime.date(2014, 11, 3): {'PX_LAST': 2017.81,
'PX_OPEN': 2018.21},
datetime.date(2014, 11, 4): {'PX_LAST': 2012.1, 'PX_OPEN': 2015.81},
datetime.date(2014, 11, 5): {'PX_LAST': 2023.57, 'PX_OPEN': 2015.29},
datetime.date(2014, 11, 6): {'PX_LAST': 2031.21, 'PX_OPEN': 2023.33}}}
命令
pd.Panel(d)
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 2 (major_axis) x 4 (minor_axis)
Items axis: RAY Index to SPX Index
Major_axis axis: PX_LAST to PX_OPEN
Minor_axis axis: 2014-11-03 to 2014-11-06
其中pd.Panel（d）[item]产生数据帧
pd.Panel(d)['SPX Index']
2014-11-03 2014-11-04 2014-11-05 2014-11-06
PX_LAST 2017.81 2012.10 2023.57 2031.21
PX_OPEN 2018.21 2015.81 2015.29 2023.33
然后，您可以点击命令to_frame（）将其转换为数据帧。我也使用reset_index将主轴和次轴转换为列而不是将它们作为索引。
pd.Panel(d).to_frame().reset_index()
major minor RAY Index SPX Index
PX_LAST 2014-11-03 1199.460 2017.81
PX_LAST 2014-11-04 1195.323 2012.10
PX_LAST 2014-11-05 1200.936 2023.57
PX_LAST 2014-11-06 1206.061 2031.21
PX_OPEN 2014-11-03 1200.140 2018.21
PX_OPEN 2014-11-04 1197.690 2015.81
PX_OPEN 2014-11-05 1195.320 2015.29
PX_OPEN 2014-11-06 1200.620 2023.33
最后，如果您不喜欢框架的外观，可以在调用to_frame（）之前使用面板的转置功能来更改外观 http://pandas.pydata.org/pandas-docs/dev/generated/pandas.Panel.transpose.html
就像一个例子
pd.Panel(d).transpose(2,0,1).to_frame().reset_index()
major minor 2014-11-03 2014-11-04 2014-11-05 2014-11-06
RAY Index PX_LAST 1199.46 1195.323 1200.936 1206.061
RAY Index PX_OPEN 1200.14 1197.690 1195.320 1200.620
SPX Index PX_LAST 2017.81 2012.100 2023.570 2031.210
SPX Index PX_OPEN 2018.21 2015.810 2015.290 2023.330
希望这有帮助。
答案 2 :(得分：7)
pd.concat接受字典。考虑到这一点，有可能通过使用dictionary comprehension构建将键映射到子帧的字典来简化和提高当前接受的答案。
pd.concat({k: pd.DataFrame(v).T for k, v in user_dict.items()}, axis=0)
或者，
pd.concat({
k: pd.DataFrame.from_dict(v, 'index') for k, v in user_dict.items()
},
axis=0)
att_1 att_2
12 Category 1 1 whatever
Category 2 23 another
15 Category 1 10 foo
Category 2 30 bar
答案 3 :(得分：6)
如果有人想要获取没有长索引的“长格式”（叶值具有相同类型）的数据帧，则可以执行以下操作：
pd.DataFrame.from_records(
[
(level1, level2, level3, leaf)
for level1, level2_dict in user_dict.items()
for level2, level3_dict in level2_dict.items()
for level3, leaf in level3_dict.items()
],
columns=['UserId', 'Category', 'Attribute', 'value']
)
UserId Category Attribute value
0 12 Category 1 att_1 1
1 12 Category 1 att_2 whatever
2 12 Category 2 att_1 23
3 12 Category 2 att_2 another
4 15 Category 1 att_1 10
5 15 Category 1 att_2 foo
6 15 Category 2 att_1 30
7 15 Category 2 att_2 bar
（我知道最初的问题可能希望（I.）将级别1和2作为多索引，将Level 3作为列，并且（II。）询问除字典中的值迭代之外的其他方法。但是我希望这个答案仍然是相关且有用的（I.）：对于像我这样试图找到将嵌套的dict变成这种形状的方法的人，谷歌只返回此问题，（II。）：因为其他答案也涉及一些迭代，并且我发现这种方法灵活且易于阅读；不过，不确定性能。）
答案 4 :(得分：2)
对于表示数据的其他方式，您不需要做太多事情。例如，如果您只想将“外部”键作为索引，将“内部”键作为列，将值作为单元格值，则可以这样做：
df = pd.DataFrame.from_dict(user_dict, orient='index')
答案 5 :(得分：1)
这个解决方案应该通过将字典键扁平化为元组链来适用于任意深度
def flatten_dict(nested_dict):
res = {}
if isinstance(nested_dict, dict):
for k in nested_dict:
flattened_dict = flatten_dict(nested_dict[k])
for key, val in flattened_dict.items():
key = list(key)
key.insert(0, k)
res[tuple(key)] = val
else:
res[()] = nested_dict
return res
def nested_dict_to_df(values_dict):
flat_dict = flatten_dict(values_dict)
df = pd.DataFrame.from_dict(flat_dict, orient="index")
df.index = pd.MultiIndex.from_tuples(df.index)
df = df.unstack(level=-1)
df.columns = df.columns.map("{0[1]}".format)
return df
答案 6 :(得分：0)
以经过验证的答案为基础，对我来说，效果最好：
ab = pd.concat({k: pd.DataFrame(v).T for k, v in data.items()}, axis=0)
ab.T