Pandas超宽结构重塑：JSON转多表技巧

1. 引言：超宽DataFrame的挑战与数据重构需求

在数据处理过程中，我们经常会遇到从扁平化（flattened）的JSON或类似结构中加载数据到Pandas DataFrame的情况。当原始JSON包含多层嵌套的列表或字典，并且这些嵌套结构被展开为独立的列时，DataFrame的列数可能会急剧增加，甚至超过1024列，这不仅使得数据难以直观理解和分析，也可能导致性能问题。例如，一个包含多个员工信息（每个员工有工资、多个技能ID）的JSON，在扁平化后可能产生诸如employee_0_salary, employee_0_skills_0_id, employee_0_skills_1_id, employee_1_salary等大量列。

我们的目标是将这种超宽的DataFrame重构为更合理、更规范的格式，例如，将每个员工的信息拆分成独立的行，形成一个包含id、员工索引、工资、技能ID等列的表格，从而便于后续的数据分析和处理。

2. 核心工具：pandas.melt()实现宽到长转换

解决超宽DataFrame问题的首要步骤是将其从宽格式（wide format）转换为长格式（long format）。Pandas库中的melt()函数是实现这一转换的强大工具。melt()函数可以将DataFrame中的一列或多列“融化”为两列：一列存储原始的列名（通常命名为variable），另一列存储对应的值（通常命名为value）。

2.1 melt()函数详解

• id_vars: 一个列表，指定哪些列是标识符变量，它们在转换后会保持不变，作为新的长格式DataFrame的标识列。
• value_vars: 一个列表，指定哪些列是要被“融化”的变量。如果省略此参数，melt()将融化所有非id_vars的列。
• var_name: 一个字符串，用于指定存储原始列名的新列的名称（默认为variable）。
• value_name: 一个字符串，用于指定存储原始列值的新列的名称（默认为value）。

2.2 示例：应用melt()

假设我们有以下一个模拟的超宽DataFrame：

import pandas as pd

# 模拟超宽DataFrame
df = pd.DataFrame({
    'id': [1, 2, 1],
    'name': ['joe','sue', 'fred'],
    'employee_0_salary': [30000, 35000, 40000],
    'employee_0_skills_0_id': [101, 102, 103],
    'employee_0_skills_1_id': [103, 104, 105],
    'employee_1_salary': [32000, 36000, 37000],
    'employee_1_skills_0_id': [105, 106, 107],
    'employee_1_skills_1_id': [108, 109, 110], # 增加一个技能列以便后续演示
})

print("原始DataFrame:")
print(df)

输出：

原始DataFrame:
   id  name  employee_0_salary  employee_0_skills_0_id  employee_0_skills_1_id  employee_1_salary  employee_1_skills_0_id  employee_1_skills_1_id
0   1   joe              30000                     101                     103              32000                     105                     108
1   2   sue              35000                     102                     104              36000                     106                     109
2   1  fred              40000                     103                     105              37000                     107                     110

现在，我们使用melt()函数将其转换为长格式。我们将id和name作为标识符变量：

meltdf = df.melt(id_vars=['id', 'name'])

print("\n使用melt()转换后的DataFrame:")
print(meltdf.head(10)) # 只显示前10行

输出：

使用melt()转换后的DataFrame:
   id  name                variable  value
0   1   joe       employee_0_salary  30000
1   2   sue       employee_0_salary  35000
2   1  fred       employee_0_salary  40000
3   1   joe  employee_0_skills_0_id    101
4   2   sue  employee_0_skills_0_id    102
5   1  fred  employee_0_skills_0_id    103
6   1   joe  employee_0_skills_1_id    103
7   2   sue  employee_0_skills_1_id    104
8   1  fred  employee_0_skills_1_id    105
9   1   joe       employee_1_salary  32000

可以看到，原始的员工相关列被“融化”成了variable和value两列。

3. 解析variable列：提取嵌套实体信息

melt操作后，所有的关键嵌套信息（例如“哪个员工”和“哪个属性”）都被编码在variable列的字符串中。我们需要从这些字符串中提取结构化的信息，例如员工的索引（0, 1, ...）和具体的属性名称（salary, skills_0_id, skills_1_id）。

这通常可以通过字符串操作或正则表达式来完成。考虑到列名模式通常是employee_X_attribute_Y，我们可以使用正则表达式来精确提取。

# 使用正则表达式从variable列中提取员工索引和属性名称
# 模式：'employee_(\d+)_(.*)' 匹配 'employee_' 后跟数字（员工索引），再跟 '_' 后所有内容（属性名称）
extracted_data = meltdf['variable'].str.extract(r'employee_(\d+)_(.*)')

# 将提取的数据添加到meltdf中，并命名新列
meltdf['employee_idx'] = extracted_data[0].astype(int) # 员工索引
meltdf['attribute'] = extracted_data[1] # 属性名称

print("\n解析variable列后的DataFrame:")
print(meltdf.head(10))

输出：

解析variable列后的DataFrame:
   id  name                variable  value  employee_idx      attribute
0   1   joe       employee_0_salary  30000             0         salary
1   2   sue       employee_0_salary  35000             0         salary
2   1  fred       employee_0_salary  40000             0         salary
3   1   joe  employee_0_skills_0_id    101             0  skills_0_id
4   2   sue  employee_0_skills_0_id    102             0  skills_0_id
5   1  fred  employee_0_skills_0_id    103             0  skills_0_id
6   1   joe  employee_0_skills_1_id    103             0  skills_1_id
7   2   sue  employee_0_skills_1_id    104             0  skills_1_id
8   1  fred  employee_0_skills_1_id    105             0  skills_1_id
9   1   joe       employee_1_salary  32000             1         salary

现在，meltdf中有了id、name、employee_idx、attribute和value这些列，数据结构变得清晰。

4. 使用pivot_table()重塑数据：构建规范化表格

有了id、name、employee_idx、attribute和value这些列，我们就可以使用pivot_table()函数将数据重塑为最终的目标格式：每行代表一个员工的详细信息。

pivot_table()函数与pivot()类似，但功能更强大，可以处理重复索引，并支持聚合功能。在这里，我们希望以id、name和employee_idx作为新的行标识符，以attribute作为新的列名，并以value填充单元格。

# 使用pivot_table将数据重塑为每行一个员工的格式
# index: 定义新DataFrame的行索引
# columns: 定义新DataFrame的列名
# values: 定义填充单元格的值
normalized_df = meltdf.pivot_table(
    index=['id', 'name', 'employee_idx'],
    columns='attribute',
    values='value'
)

# 重置索引，将id, name, employee_idx从MultiIndex转换为普通列
normalized_df = normalized_df.reset_index()

# 清理列名：pivot_table后columns会变成MultiIndex，需要扁平化
normalized_df.columns.name = None # 移除columns的名称
# 如果需要，可以进一步重命名列
# normalized_df = normalized_df.rename(columns={'skills_0_id': 'skill_id_0', 'skills_1_id': 'skill_id_1'})

print("\n最终规范化后的DataFrame:")
print(normalized_df)

输出：

最终规范化后的DataFrame:
   id  name  employee_idx  salary  skills_0_id  skills_1_id
0   1   fred             0   40000          103          105
1   1   fred             1   37000          107          110
2   1    joe             0   30000          101          103
3   1    joe             1   32000          105          108
4   2    sue             0   35000          102          104
5   2    sue             1   36000          106          109

现在，我们成功地将一个超宽的DataFrame转换成了一个更易于管理和分析的规范化表格。每一行代表一个特定的员工（由id和employee_idx共同标识），其工资和技能ID都作为独立的列呈现。

5. 注意事项与最佳实践

• 列名模式的统一性： 这种重构方法高度依赖于原始DataFrame列名的一致性和可解析性。确保所有需要重构的列都遵循相同的命名模式（如entity_index_attribute）。
• 数据类型转换： melt()操作会将value列的数据类型统一为object，因为原始列可能包含不同类型的数据。在pivot_table()之后，可能需要手动将相关列（如salary, skills_id）转换回数值类型，例如normalized_df['salary'] = pd.to_numeric(normalized_df['salary'])。
• 性能考量： 对于包含数百万行或更多数据的超大型DataFrame，melt()和pivot_table()操作可能会消耗大量内存和CPU资源。在这种情况下，可以考虑使用Dask DataFrame进行分布式计算，或者分块处理数据。