pandas groupby到嵌套json

Question

我经常使用pandas groupby生成堆叠的表。但是，我通常希望将生成的嵌套关系输出到json。有没有办法从它生成的堆栈表中提取嵌套的json文件？

假设我有一个df，比如：

year office candidate  amount
2010 mayor  joe smith  100.00
2010 mayor  jay gould   12.00
2010 govnr  pati mara  500.00
2010 govnr  jess rapp   50.00
2010 govnr  jess rapp   30.00

我能做到：

grouped = df.groupby('year', 'office', 'candidate').sum()

print grouped
                       amount
year office candidate 
2010 mayor  joe smith   100
            jay gould    12
     govnr  pati mara   500
            jess rapp    80

真漂亮！当然，我真正想做的是通过命令沿着grouped.to_json行得到嵌套的json。但这个功能是不可用的。有解决办法吗？

所以，我真正想要的是：

{"2010": {"mayor": [
                    {"joe smith": 100},
                    {"jay gould": 12}
                   ]
         }, 
          {"govnr": [
                     {"pati mara":500}, 
                     {"jess rapp": 80}
                    ]
          }
}

唐

Answer 1

我看了一下上面的解决方案，发现它只适用于3个层次的嵌套。此解决方案适用于任何级别。

import json
levels = len(grouped.index.levels)
dicts = [{} for i in range(levels)]
last_index = None

for index,value in grouped.itertuples():

    if not last_index:
        last_index = index

    for (ii,(i,j)) in enumerate(zip(index, last_index)):
        if not i == j:
            ii = levels - ii -1
            dicts[:ii] =  [{} for _ in dicts[:ii]]
            break

    for i, key in enumerate(reversed(index)):
        dicts[i][key] = value
        value = dicts[i]

    last_index = index


result = json.dumps(dicts[-1])

Answer 2

我不认为熊猫有任何内置的东西来创建一个嵌套的数据字典。下面是一些代码，它们通常适用于具有多索引的序列，使用defaultdict

嵌套代码遍历MultIndex的每个级别，将层添加到字典中，直到最深的层被分配给序列值。

In  [99]: from collections import defaultdict

In [100]: results = defaultdict(lambda: defaultdict(dict))

In [101]: for index, value in grouped.itertuples():
     ...:     for i, key in enumerate(index):
     ...:         if i == 0:
     ...:             nested = results[key]
     ...:         elif i == len(index) - 1:
     ...:             nested[key] = value
     ...:         else:
     ...:             nested = nested[key]

In [102]: results
Out[102]: defaultdict(<function <lambda> at 0x7ff17c76d1b8>, {2010: defaultdict(<type 'dict'>, {'govnr': {'pati mara': 500.0, 'jess rapp': 80.0}, 'mayor': {'joe smith': 100.0, 'jay gould': 12.0}})})

In [106]: print json.dumps(results, indent=4)
{
    "2010": {
        "govnr": {
            "pati mara": 500.0, 
            "jess rapp": 80.0
        }, 
        "mayor": {
            "joe smith": 100.0, 
            "jay gould": 12.0
        }
    }
}

Answer 3

我知道这是个老问题，但我最近碰到了同样的问题。这是我的解决办法。我从chrisb的例子中借了很多东西（谢谢！）。

这样做的好处是，您可以传递一个lambda，以便从您想要的任何可枚举项以及每个组中获取最终值。

from collections import defaultdict

def dict_from_enumerable(enumerable, final_value, *groups):
    d = defaultdict(lambda: defaultdict(dict))
    group_count = len(groups)
    for item in enumerable:
        nested = d
        item_result = final_value(item) if callable(final_value) else item.get(final_value)
        for i, group in enumerate(groups, start=1):
            group_val = str(group(item) if callable(group) else item.get(group))
            if i == group_count:
                nested[group_val] = item_result
            else:
                nested = nested[group_val]
    return d

在这个问题中，您可以这样调用这个函数：

dict_from_enumerable(grouped.itertuples(), 'amount', 'year', 'office', 'candidate')

第一个参数也可以是一个数据数组，甚至不需要熊猫。