当前位置：首页 > 文章列表 > 文章 > python教程 > Python处理嵌套JSON数据技巧

Python处理嵌套JSON数据技巧

2025-07-11 18:42:30 0浏览收藏

还在为处理Python中复杂的JSON嵌套数据而烦恼吗？本文将带你掌握`json_normalize`这一利器，轻松将多层嵌套的JSON数据“拍平”成易于分析的表格形式。我们将深入探讨`record_path`和`meta`参数的灵活运用，教你如何指定展开的列表路径，并保留关键的父级字段信息。此外，针对JSON数据中常见的缺失值和不规则结构，本文还将提供实用的应对技巧。最后，我们将介绍如何结合Pandas对`json_normalize`处理后的数据进行高效清洗、转换和聚合，释放数据的潜在价值，助力你的数据分析工作。

json_normalize处理多层嵌套JSON的关键在于record_path和meta参数的配合使用。1. record_path用于指定要展开的列表路径，可以是字符串或列表形式，如'orders'或['orders', 'items']，表示逐层展开；2. meta用于保留父级字段信息，可指定单层或多层路径，如['contact', 'email']；3. 处理不规则结构时，可通过errors='ignore'忽略缺失键，用NaN填充；4. 拍平后的DataFrame可结合Pandas进行数据类型转换、列重命名、缺失值处理、数据聚合等操作，实现高效分析与清洗。

如何用Python处理JSON嵌套数据？json_normalize技巧

Python处理JSON嵌套数据，json_normalize是一个非常实用的工具，它能将复杂的嵌套结构“拍平”成表格形式，便于数据分析和处理，尤其在处理API返回或日志数据时，效率极高。

解决方案

在数据处理的日常中，我们经常会遇到JSON数据，尤其是那些层层嵌套、结构复杂的JSON。直接用字典方式去一层层取值，不仅代码臃肿，还容易出错，特别是当某个键可能不存在时。这时候，json_normalize就显得非常方便了，它能把这种树状结构转换成扁平的Pandas DataFrame，就像把一张立体地图摊平了看。

我们来看一个典型的场景：一份包含用户、订单及其商品详情的JSON数据。

[
  {
    "user_id": "U001",
    "user_name": "Alice",
    "contact": {
      "email": "alice@example.com",
      "phone": "123-456-7890"
    },
    "orders": [
      {
        "order_id": "O101",
        "date": "2023-01-15",
        "items": [
          {"item_id": "P001", "name": "Laptop", "price": 1200, "qty": 1},
          {"item_id": "P002", "name": "Mouse", "price": 25, "qty": 2}
        ]
      },
      {
        "order_id": "O102",
        "date": "2023-01-20",
        "items": [
          {"item_id": "P003", "name": "Keyboard", "price": 75, "qty": 1}
        ]
      }
    ]
  },
  {
    "user_id": "U002",
    "user_name": "Bob",
    "contact": {
      "email": "bob@example.com",
      "phone": "987-654-3210"
    },
    "orders": [
      {
        "order_id": "O201",
        "date": "2023-02-01",
        "items": [
          {"item_id": "P004", "name": "Monitor", "price": 300, "qty": 1}
        ]
      }
    ]
  }
]

要将上述数据“拍平”，尤其是提取orders和items中的信息，同时保留用户和订单的基本信息，json_normalize的record_path和meta参数就派上用场了。

import pandas as pd
from pandas import json_normalize
import json

data = [
  {
    "user_id": "U001",
    "user_name": "Alice",
    "contact": {
      "email": "alice@example.com",
      "phone": "123-456-7890"
    },
    "orders": [
      {
        "order_id": "O101",
        "date": "2023-01-15",
        "items": [
          {"item_id": "P001", "name": "Laptop", "price": 1200, "qty": 1},
          {"item_id": "P002", "name": "Mouse", "price": 25, "qty": 2}
        ]
      },
      {
        "order_id": "O102",
        "date": "2023-01-20",
        "items": [
          {"item_id": "P003", "name": "Keyboard", "price": 75, "qty": 1}
        ]
      }
    ]
  },
  {
    "user_id": "U002",
    "user_name": "Bob",
    "contact": {
      "email": "bob@example.com",
      "phone": "987-654-3210"
    },
    "orders": [
      {
        "order_id": "O201",
        "date": "2023-02-01",
        "items": [
          {"item_id": "P004", "name": "Monitor", "price": 300, "qty": 1}
        ]
      }
    ]
  }
]

# 第一次拍平：将用户和订单关联起来
# record_path 指定要展开的列表路径
# meta 指定要保留的父级键
orders_df = json_normalize(
    data,
    record_path='orders',
    meta=['user_id', 'user_name', ['contact', 'email'], ['contact', 'phone']],
    sep='_' # 用于连接meta中多层嵌套键的名称
)

# 第二次拍平：将订单和商品关联起来
# 此时的输入数据是orders_df，但我们需要操作的是其中的'items'列
# 这一步稍微有点技巧，因为json_normalize通常直接处理list of dicts
# 这里需要对orders_df的每一行进行迭代或再次应用json_normalize
# 更直接的方法是先将所有items提取出来，再normalize
all_items = []
for idx, row in orders_df.iterrows():
    order_items = row['items']
    # 将订单ID和日期等信息添加到每个item中，以便后续关联
    for item in order_items:
        item['order_id'] = row['order_id']
        item['order_date'] = row['date']
        item['user_id'] = row['user_id'] # 再次添加用户ID，方便最终合并
    all_items.extend(order_items)

items_df = json_normalize(all_items)

# 最后，将用户、订单、商品信息合并成一个宽表
# 通常我们会选择一个合适的键进行合并，这里是user_id和order_id
# 但由于第二次拍平已经包含了这些信息，我们只需要选择需要的列
# 也可以考虑先将所有数据normalize到最细粒度（item），再选择列
final_df = items_df[[
    'user_id', 'order_id', 'order_date',
    'item_id', 'name', 'price', 'qty'
]]

print(final_df)

这段代码会输出一个扁平化的DataFrame，每一行代表一个商品，并附带了其所属订单和用户的相关信息。这种分步处理的方式，在面对多层嵌套时，能让逻辑更清晰。

处理复杂多层嵌套JSON时，json_normalize的record_path和meta参数怎么用？

json_normalize的核心魅力，确实在于record_path和meta这两个参数的灵活运用。它们像是两把钥匙，一把用来打开你要展开的“列表之门”，另一把则帮你把“门外”的上下文信息带进来。

record_path参数是用来指定JSON中哪个列表（或列表中的字典）应该被展开成新的行。它可以是一个字符串，比如'orders'，表示直接展开顶层下的orders列表。如果嵌套更深，比如要展开orders列表中的每个订单里的items列表，那么record_path就应该是一个路径列表，例如['orders', 'items']。这表示json_normalize会先进入orders，然后对orders里的每个元素（也就是每个订单字典）再进入items列表进行展开。

举个例子，如果我们想直接从原始数据中获取所有商品的信息，同时保留其所属的用户ID和订单ID，record_path和meta的组合就会是这样：

# 假设我们想直接从最顶层的数据中，一步到位地获取所有商品的详细信息，
# 并关联上用户ID、用户姓名、订单ID和订单日期。
# 这就需要record_path指向['orders', 'items']
# meta则需要包含 user_id, user_name, 以及 orders下的 order_id 和 date

# 注意：当record_path指向一个多层路径时，meta中的路径也需要相应调整
# 比如，如果record_path是 ['orders', 'items']，那么meta中的 'order_id'
# 实际上是从 'orders' 这一层级获取的，所以需要写成 ['orders', 'order_id']
# 但json_normalize在处理这种多层record_path时，meta参数的解读会有些不同
# 它会默认你提供的meta字段是相对于record_path的“父级”层级。
# 简单来说，如果record_path是A->B，那么meta中的字段就是从A这个层级取的。
# 但如果meta字段本身也是嵌套的，比如 contact.email，就需要用列表表示 ['contact', 'email']

# 实际操作中，直接用['orders', 'items']作为record_path，并把所有父级信息都放进meta，
# 可能会有点复杂，因为meta的路径是相对于record_path的父级而言的。
# 通常更推荐分步处理，或者先将数据结构预处理一下。
# 但如果结构允许，可以这样尝试：

items_flat_df = json_normalize(
    data,
    record_path=['orders', 'items'], # 展开到最细粒度的items
    meta=[
        'user_id',
        'user_name',
        ['contact', 'email'],
        ['contact', 'phone'],
        ['orders', 'order_id'], # 从orders层级获取order_id
        ['orders', 'date']      # 从orders层级获取date
    ],
    errors='ignore' # 忽略可能存在的路径错误，避免中断
)

# 这样处理后，你会发现['orders', 'order_id']和['orders', 'date']可能会出现重复，
# 因为json_normalize会为每个item重复其父级orders的信息。
# 实际输出时，它会尝试将这些父级信息关联到每个展开的子项上。
# 但需要注意的是，当record_path是多层嵌套时，meta的路径是相对于record_path的*直接父级*而言的。
# 也就是说，如果record_path是 ['orders', 'items']，那么 meta 里的 'order_id' 
# 是从 'orders' 这个层级取出来的，而不是从最顶层。
# 这也是为什么我个人倾向于分步拍平，或者在第二次拍平前，先将第一次拍平的结果进行预处理，
# 把需要保留的父级信息直接注入到子级列表的每个字典中。
# 比如，在上面第一次拍平后，迭代`orders_df`，把`order_id`和`user_id`加到每个`item`字典里，
# 这样第二次拍平`items`时，它们就自然成为列了。这种手动注入的方式，虽然多了一步，
# 但在处理逻辑上会更直观，尤其在JSON结构非常复杂且不规则时。

`meta`参数则负责从原始JSON的父级层中提取你想要保留的字段。它可以是一个字符串（如`'user_id'`），也可以是一个路径列表（如`['contact', 'email']`），用于提取嵌套的父级字段。`json_normalize`会把这些`meta`字段的值复制到每个展开的行中，确保你不会丢失上下文信息。当你需要将不同层级的数据关联起来时，`meta`是必不可少的。

### json_normalize遇到缺失值或不规则结构时如何应对？

实际工作中，我们拿到的JSON数据很少是完美的。键可能缺失，或者某些字段的结构突然变了，这在日志数据或者第三方API返回中尤其常见。`json_normalize`在处理这些“不完美”时，默认行为是相当稳健的。

当`json_normalize`在尝试访问`record_path`或`meta`中指定的键，而该键不存在时，它会默认用`NaN`（Not a Number）或`None`来填充对应的列。这通常是可接受的，因为它避免了程序崩溃，并清晰地标识了数据缺失的位置。

如果你希望在遇到这种缺失或不规则情况时，`json_normalize`的行为有所不同，可以使用`errors`参数。
*   `errors='ignore'` (默认值): 这是最常用的选项，它会忽略错误，将无法解析的字段填充为`NaN`，然后继续处理。这对于数据质量不高的场景非常有用，因为它能让你尽可能多地提取出有效数据。
*   `errors='raise'`: 如果你对数据结构有严格要求，任何一个指定路径的键缺失都应该被视为错误并中断程序，那么可以选择这个选项。它会抛出一个`KeyError`或其他相关异常。这在开发和测试阶段，或者你确信数据应该总是符合特定结构时很有用，能帮助你快速发现数据源的问题。

举个例子，如果我们的JSON数据中，有的用户没有`contact`信息，或者`orders`列表是空的：

```json
[
  {
    "user_id": "U003",
    "user_name": "Charlie",
    "orders": [] # 空订单列表
  },
  {
    "user_id": "U004",
    "user_name": "Diana",
    "contact": { "email": "diana@example.com" } # 缺少phone
  }
]

当我们用之前的json_normalize方法处理时：

data_irregular = [
  {
    "user_id": "U003",
    "user_name": "Charlie",
    "orders": []
  },
  {
    "user_id": "U004",
    "user_name": "Diana",
    "contact": { "email": "diana@example.com" }
  }
]

# 第一次拍平
orders_df_irregular = json_normalize(
    data_irregular,
    record_path='orders',
    meta=['user_id', 'user_name', ['contact', 'email'], ['contact', 'phone']],
    sep='_',
    errors='ignore' # 明确指定忽略错误
)

print(orders_df_irregular)

对于U003，因为orders列表为空，json_normalize不会生成任何行，这很合理。对于U004，contact_phone列会显示NaN，因为它在原始JSON中不存在。这种处理方式，让我觉得json_normalize在鲁棒性方面做得相当不错，能应对很多实际场景中的数据脏乱问题。当然，如果结构不规则到连record_path本身都可能不是列表，或者meta路径下的值类型不一致，那可能就需要一些预处理，比如用try-except块手动解析，或者在json_normalize之前用列表推导式清理数据。

json_normalize处理后的数据，如何结合Pandas进行高效分析和清洗？

json_normalize的输出是一个Pandas DataFrame，这意味着我们可以无缝地利用Pandas的强大功能进行后续的数据分析和清洗。这才是真正发挥数据价值的关键一步。

一旦你把复杂的JSON结构“拍平”了，接下来通常会做这些事情：

数据类型转换： json_normalize默认会尝试推断列的数据类型，但有时推断不准确，比如数字被当作字符串，日期被当作对象。这时候，可以使用df['column_name'].astype(int)、pd.to_datetime(df['date_column'])等方法进行显式转换。例如，商品价格和数量应该转换为数值类型，订单日期应该转换为日期时间类型，这对于后续的数值计算和时间序列分析至关重要。
```
# 假设items_df已经生成
items_df['price'] = pd.to_numeric(items_df['price'], errors='coerce') # errors='coerce' 将无法转换的值设为NaN
items_df['qty'] = pd.to_numeric(items_df['qty'], errors='coerce')
items_df['order_date'] = pd.to_datetime(items_df['order_date'])
```
列重命名与选择： json_normalize在处理嵌套键时，会默认用下划线连接，比如contact_email。如果你觉得这些列名不够直观，或者想简化，可以利用df.rename(columns={'old_name': 'new_name'})进行批量重命名。同时，如果拍平后出现了大量你不需要的中间列，可以使用df[['col1', 'col2', ...]]进行列选择，只保留你关心的核心数据。
```
# 假设我们想把contact_email改成更简洁的email
final_df_renamed = final_df.rename(columns={'contact_email': 'email'})
# 或者直接在选择列的时候就完成简化
# final_df = items_df[['user_id', 'order_id', 'order_date', 'item_id', 'name', 'price', 'qty', 'contact_email']]
# final_df = final_df.rename(columns={'contact_email': 'email'})
```
数据清洗与缺失值处理： 拍平后的DataFrame可能会有NaN值，这需要根据业务逻辑进行处理。你可以选择填充（df.fillna(value)）、删除（df.dropna()）或者进行更复杂的插值。
```
# 填充缺失的电话号码为'未知'
final_df['contact_phone'].fillna('未知', inplace=True)
```

数据聚合与透视： 这是数据分析的核心。一旦数据扁平化，你就可以轻松地进行分组聚合（df.groupby()），比如计算每个用户的总消费、每个商品的销售总量等。也可以使用pivot_table进行数据透视，从不同维度观察数据。

# 计算每个用户的总消费
user_total_spend = final_df.groupby('user_id')['price'].sum()
print("用户总消费：\n", user_total_spend)

# 计算每个商品的销售总量
item_sales_qty = final_df.groupby('item_id')['qty'].sum()
print("\n商品销售总量：\n", item_sales_qty)

# 查看每个订单的商品数量
order_item_counts = final_df.groupby('order_id')['item_id'].count()
print("\n订单商品数量：\n", order_item_counts)