Python 数据处理进阶：告别多层 for 循环，用 JSONPath 精准提取嵌套 JSON 数据

76次阅读

共计 5902 个字符，预计需要花费 15 分钟才能阅读完成。

上周帮同事调试一个聚合型接口，返回的 JSON 数据结构极其复杂，嵌套了好几层，甚至还带有一些不确定字段。我发现不少同事在处理这类数据时，仍然习惯用 for 循环一层层地剥洋葱，代码冗长、可读性差，稍不留神就会因为某个键不存在而报错。其实，面对这种场景，Python 社区有一个“效率神器”——jsonpath 库，它能让你以声明式的方式，像写 SQL 一样轻松查询和提取数据，省一半时间不说，代码还优雅得多。今天，咱们就一起来深入实践一下，告别那些繁琐的 for 循环。

为什么我们需要 `jsonpath`？从痛点说起

在日常开发中，我们经常会遇到 JSON 数据，无论是调用 RESTful API、处理前端传来的数据，还是解析配置文件。对于简单的、扁平化的 JSON 结构，比如：

data = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}
print(data["name"]) # 轻松获取

这当然不成问题。但当 JSON 结构变得复杂，出现多层嵌套、列表包含字典等情况时，传统的数据访问方式就会变得异常痛苦。

考虑这样一个模拟的电商数据：

import json

complex_data = {
    "store": {
        "book": [
            {
                "category": "reference",
                "author": "Nigel Rees",
                "title": "Sayings of the Century",
                "price": 8.95
            },
            {
                "category": "fiction",
                "author": "Evelyn Waugh",
                "title": "Sword of Honour",
                "price": 12.99,
                "isbn": "0-553-21315-X"
            },
            {
                "category": "fiction",
                "author": "Herman Melville",
                "title": "Moby Dick",
                "isbn": "0-553-21315-X",
                "price": 8.99
            },
            {
                "category": "non-fiction",
                "author": "J. R. R. Tolkien",
                "title": "The Lord of the Rings",
                "price": 22.99
            }
        ],
        "bicycle": {
            "color": "red",
            "price": 19.95
        }
    },
    "expensive": 10,
    "customers": [
        {
            "id": "cust-001",
            "name": "Alice",
            "orders": [{"order_id": "ord-001", "amount": 100},
                {"order_id": "ord-002", "amount": 150}
            ]
        },
        {
            "id": "cust-002",
            "name": "Bob",
            "orders": [{"order_id": "ord-003", "amount": 50}
            ]
        }
    ]
}

现在，假如你想提取所有书的作者，或者找出所有价格低于 10 的书名，甚至想获取所有顾客的订单总金额。如果用 for 循环，代码可能是这样的：

all_authors = []
for book in complex_data.get("store", {}).get("book", []):
    if "author" in book:
        all_authors.append(book["author"])
print(f"所有作者 (for 循环): {all_authors}")

# 更复杂的，比如获取所有顾客的订单总金额
customer_order_amounts = {}
for customer in complex_data.get("customers", []):
    customer_id = customer.get("id")
    total_amount = 0
    if customer_id:
        for order in customer.get("orders", []):
            total_amount += order.get("amount", 0)
        customer_order_amounts[customer_id] = total_amount
print(f"顾客订单总金额 (for 循环): {customer_order_amounts}")

这段代码，虽然能完成任务，但嵌套了好几层 get() 和 for 循环，写起来费劲，维护起来也容易让人头大。更要命的是，一旦数据结构发生微小变化，比如某个层级名称变了，或者某个字段不确定存在，你可能就需要修改大量的 if 判断和循环逻辑。这效率实在不高，我刚入行时就吃过这种亏，一个需求改动能调半天。

`jsonpath` 入门：三步实操精准提取数据

jsonpath 库提供了一种声明式的查询语言，可以让你用简洁的表达式定位到 JSON 树中的任何位置。它语法类似于 XPath（XML Path Language），非常强大。

首先，你需要安装 jsonpath 库。

pip install jsonpath

安装完成后，在 Python 脚本中导入它：

import jsonpath

小提醒： Python 生态中有一个叫 jsonpath-rw 的库，功能也很强大，但语法略有不同。咱们今天主要聚焦在 jsonpath 这个库，它的表达式语法与前端常用的 jsonpath 概念更接近，相对更直观。

jsonpath 的强大之处在于它的路径表达式。理解这些表达式是掌握 jsonpath 的关键。以下是一些最常用的符号：

$：表示 JSON 数据的根对象。
.：用于访问对象的子成员。例如 $.store.book。
[]：用于访问数组元素（通过索引）或对象成员（通过键名，即使键名包含特殊字符也能用）。例如 $.store.book[0]，$.store['bicycle']。
*：通配符，表示所有元素或所有成员。例如 $.store.book[*].author 会返回所有书的作者。
..：递归下降，查找所有符合条件的子节点，无论它们在哪个层级。例如 $..author 会查找所有 author 字段。
?()：条件表达式，用于过滤数组中的元素。例如 $.store.book[?(@.price < 10)]。@ 代表当前元素。
[:n] / [m:n] / [m:]：数组切片，类似于 Python 列表切片。例如 $.store.book[:2] 返回前两本书。

掌握了这些，你就能像指挥家一样，让 jsonpath 精准地为你“挑选”出数据。

jsonpath 库的核心函数是 jsonpath.jsonpath(data, expression)，它接受 JSON 数据和 jsonpath 表达式作为参数，返回一个包含所有匹配结果的列表（如果没有匹配到，则返回 False 或空列表）。

咱们用前面定义的 complex_data 数据，来实操几个常见场景：

实操 1: 提取所有书的作者

这是一个非常常见的需求，需要遍历列表中的字典，并取出特定字段。

# 提取所有书的作者
authors = jsonpath.jsonpath(complex_data, '$.store.book[*].author')
print(f"所有书的作者: {authors}")
# 第一次处理这种数据时，我就是用 for 循环一层层 dict.get()，结果遇到不存在的 key 就报错，# 后面才学到 jsonpath 的 [*] 通配符，不仅代码更简洁，而且即便某些书没有 author 字段也不会直接报错，而是简单地不返回。# 这样处理接口数据时，容错性也大大提升了。

输出： 所有书的作者: ['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'J. R. R. Tolkien']

实操 2: 查找所有价格低于 10 的书

需要对列表中的元素进行条件过滤。

# 查找所有价格低于 10 的书
cheap_books = jsonpath.jsonpath(complex_data, '$.store.book[?(@.price < 10)]')
print(f"价格低于 10 的书: {json.dumps(cheap_books, indent=2, ensure_ascii=False)}")
# 我刚接触这种条件过滤语法时，总是忘记在外层加上中括号 `[]`，调试了半天才发现是语法错误，# 以为 @.price < 10 就可以直接过滤了。大家在用 `?()` 表达式时，一定要注意它的位置，它通常是作用在数组元素上的过滤器。

输出：

 价格低于 10 的书: [
  {
    "category": "reference",
    "author": "Nigel Rees",
    "title": "Sayings of the Century",
    "price": 8.95
  },
  {
    "category": "fiction",
    "author": "Herman Melville",
    "title": "Moby Dick",
    "isbn": "0-553-21315-X",
    "price": 8.99
  }
]

实操 3: 递归查找所有 price 字段的值

不管 price 字段藏得多深，都能一次性找出来。

# 递归查找所有 price 字段
all_prices = jsonpath.jsonpath(complex_data, '$..price')
print(f"所有 price 字段的值: {all_prices}")
# 之前在处理一些日志分析数据时，不同类型的事件数据结构差异很大，但我们只想统计所有事件中的某个共同字段（比如 event_id 或者 timestamp）。# 如果用 for 循环，你就得判断各种类型、各种嵌套，而 $.. 就能轻松搞定，特别适合这种结构不统一但需要全局查找的场景。

输出： 所有 price 字段的值: [8.95, 12.99, 8.99, 22.99, 19.95]

实操 4: 获取第一个顾客的所有订单号

涉及数组索引和多层嵌套。

# 获取第一个顾客的所有订单号
first_customer_orders_ids = jsonpath.jsonpath(complex_data, '$.customers[0].orders[*].order_id')
print(f"第一个顾客的所有订单号: {first_customer_orders_ids}")
# 别问我怎么知道的，刚开始学的时候，我常常把 `[]` 当成只用于数字索引，# 结果对于字典的键名也想当然用 `.`，但有时候键名可能包含特殊字符或者动态获取，# 此时 `['key']` 这种形式就更安全。虽然 `jsonpath` 库的 `.` 通常也支持，但了解 `[]` 的这种用法能让你在面对更复杂的键名时游刃有余。

输出： 第一个顾客的所有订单号: ['ord-001', 'ord-002']

实操 5: 获取所有顾客的订单总金额 (稍微复杂点的条件)

虽然 jsonpath 本身不能直接进行数学运算，但它能帮你精确地提取出所需数据，再结合 Python 自身的逻辑进行处理。

# 获取所有顾客的订单总金额（jsonpath 提取数据，Python 计算）customers_data = jsonpath.jsonpath(complex_data, '$.customers[*]') # 提取所有顾客数据
customer_order_amounts = {}
if customers_data: # 检查 jsonpath 是否返回了有效结果
    for customer in customers_data:
        customer_id = customer.get("id")
        orders = customer.get("orders", [])
        total_amount = sum(order.get("amount", 0) for order in orders)
        customer_order_amounts[customer_id] = total_amount
print(f"所有顾客的订单总金额: {customer_order_amounts}")

输出： 所有顾客的订单总金额: {'cust-001': 250, 'cust-002': 50}

虽然 jsonpath 功能强大，但在实际使用中，有几个常见的“坑”新手容易踩，甚至一些有经验的开发者也可能忽略：

混淆 . 和 [] 的用法：
- jsonpath 中的 . 通常用于访问对象的键，如 $.key。
- [] 可以用于数组索引（[0]）或访问对象键（['key']）。当键名包含特殊字符（如空格、短横线）或动态获取时，使用 ['key'] 是更安全的做法。
- 我刚开始学习时，总觉得 . 更简洁，但遇到像 $.'my-key' 这种键名就傻眼了，结果发现要用 ['my-key']。所以，了解 [] 的强大通用性很有必要。
忘记处理查询结果为空的情况：
- jsonpath.jsonpath() 在没有找到匹配项时，通常返回 False 或一个空列表 []，而不是抛出 KeyError 或 IndexError。这使得它比直接 dict['key'] 更健壮。
- 但这意味着你需要在代码中显式检查返回结果是否为空。我平时用的习惯是，拿到 jsonpath 的结果后，都会加一个 if result: 的判断，确保后续操作有数据可处理，这能有效避免 NoneType 报错。
```
# 示例：查找不存在的字段
non_existent_field = jsonpath.jsonpath(complex_data, '$.non_existent_path')
if non_existent_field:
    print(f"找到了：{non_existent_field}")
else:
    print("指定路径的数据不存在或为空。")
```
表达式过于复杂，可读性下降：
- jsonpath 表达式可以写得很长很复杂，虽然功能强大，但有时会牺牲可读性。
- 我试过 3 种方法：
  - 纯 for 循环：代码量大，维护性差。
  - 纯 jsonpath 复杂表达式：简洁但可能难以理解。
  - jsonpath 提取主要数据 + Python 逻辑处理细节：这是一种平衡之道，用 jsonpath 快速定位并提取出大的数据块，然后用 Python 擅长的循环、条件判断进行精细化处理。
- 对于需要频繁、精细化操作且数据量不大的情况，jsonpath 结合 Python 逻辑能兼顾效率与可读性。对于超大规模且只需要少量特定字段的数据，jq 等外部工具可能更高效，大家可根据实际场景选择。