如何将Pandas DataFrame转换为指定结构的嵌套JSON？

原始数据 #

DataFrame定义 #

import pandas as pd
df = pd.DataFrame({'A': ['1', '1', '2', '3'],
                   'B': ['1.1', '1.2', '2.1', '3.1'],
                   'C': ['1.1.1', '1.2.1', '2.1.2', '3.1.5'],
                   'Value': [25, 12, 15, 19],
                   'Period': ['2015', '2018', '2010', '2019']})  

表格形式 #

目标嵌套JSON格式 #

{
  "A": [
    {
      "aCode": "1",
      "B": [
        {
          "bCode": "1.1",
          "C": [
            {
              "cCode": "1.1.1",
              "figures": [{"Value": 25, "Period": "2015"}]
            }
          ]
        },
        {
          "bCode": "1.2",
          "C": [
            {
              "cCode": "1.2.1",
              "figures": [{"Value": 12, "Period": "2018"}]
            }
          ]
        }
      ]
    },
    {
      "aCode": "2",
      "B": [
        {
          "bCode": "2.1",
          "C": [
            {
              "cCode": "2.1.2",
              "figures": [{"Value": 15, "Period": "2010"}]
            }
          ]
        }
      ]
    },
    {
      "aCode": "3",
      "B": [
        {
          "bCode": "3.1",
          "C": [
            {
              "cCode": "3.1.5",
              "figures": [{"Value": 19, "Period": "2019"}]
            }
          ]
        }
      ]
    }
  ]
}

问题 #

想把上述结构的Pandas DataFrame转换成指定格式的嵌套JSON，网上找到的实现方法都比较复杂，有没有简洁巧妙的实现方式？

简洁实现方案 #

可以用递归分组+apply的方式实现，代码简洁且扩展性强，后续调整层级只需修改参数即可：

import pandas as pd
import json

# 构造原始DataFrame
df = pd.DataFrame({'A': ['1', '1', '2', '3'],
                   'B': ['1.1', '1.2', '2.1', '3.1'],
                   'C': ['1.1.1', '1.2.1', '2.1.2', '3.1.5'],
                   'Value': [25, 12, 15, 19],
                   'Period': ['2015', '2018', '2010', '2019']})

def nest_data(df, levels, code_names, final_key):
    """
    递归实现分层嵌套
    :param df: 待处理的DataFrame
    :param levels: 分层列名列表，如['A', 'B', 'C']
    :param code_names: 对应层级的code键名，如['aCode', 'bCode', 'cCode']
    :param final_key: 最内层数据的键名，如'figures'
    """
    if len(levels) == 1:
        # 处理最内层分组，生成包含code和最终数据的字典
        return df.groupby(levels[0]).apply(
            lambda x: {
                code_names[0]: x.name,
                final_key: x[['Value', 'Period']].to_dict('records')
            }
        ).tolist()
    else:
        # 递归处理上层分组，拼接当前层级code和下一层嵌套结构
        current_level, next_levels = levels[0], levels[1:]
        current_code, next_codes = code_names[0], code_names[1:]
        return df.groupby(current_level).apply(
            lambda x: {
                current_code: x.name,
                next_levels[0]: nest_data(x, next_levels, next_codes, final_key)
            }
        ).tolist()

# 执行转换并包装外层结构
result = {'A': nest_data(df, ['A', 'B', 'C'], ['aCode', 'bCode', 'cCode'], 'figures')}

# 输出格式化后的JSON
print(json.dumps(result, indent=2))

方案说明 #

1. 递归函数nest_data负责逐层处理分组：每一层按指定列分组，生成对应code键和下一层的嵌套数据
2. 最内层将Value和Period转换为列表字典格式，作为figures的值
3. 最终将结果包装成{'A': ...}的外层结构，完全匹配目标格式

内容的提问来源于stack exchange，提问作者HabibKhan