pandas 按组生成嵌套 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}
                    ]
          }
}

Don

Answer 1

我知道这个问题已经很老了，但我最近也遇到了同样的情况。这是我的解决方案。我借鉴了很多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')

第一个参数也可以是一个数据数组，甚至不需要用到pandas。

Answer 2

这里有一个通用的递归解决方案来处理这个问题：

def df_to_dict(df):
    if df.ndim == 1:
        return df.to_dict()

    ret = {}
    for key in df.index.get_level_values(0):
        sub_df = df.xs(key)
        ret[key] = df_to_dict(sub_df)
    return ret

Answer 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 4

我觉得pandas里面没有直接的功能可以用来创建一个嵌套字典。不过，下面有一段代码，应该可以在处理带有多重索引的序列时用得上，它使用了一个叫defaultdict的工具。

这段嵌套的代码会逐层遍历多重索引，往字典里添加层级，直到最里面的一层被赋值为序列中的数据。

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
        }
    }
}