处理非标准多对象JSON响应：Python解析策略与实践

本教程旨在解决api响应中包含多个json对象但缺乏标准数组封装和逗号分隔的非规范情况。我们将深入探讨一种基于行内容特征识别json对象边界的python解析策略，通过示例代码演示如何将这些独立且无分隔符的json字符串准确地分割并解析为独立的python字典列表，确保数据能够被正确处理和利用。

在与各种API交互时，我们通常期望接收到符合RFC 8259标准的JSON响应。然而，在某些特殊场景下，API可能返回一种非标准的JSON结构，其中包含多个独立的JSON对象，但这些对象既没有被包裹在一个外层数组 [] 中，也没有通过逗号 , 进行分隔。它们可能只是简单地一个接一个地拼接在一起，如下所示：

{
  "key1": "value1",
  "key2": "value2"
}
{
  "key3": "value3",
  "key4": "value4"
}

直接使用 json.loads() 解析此类字符串会导致 json.JSONDecodeError，因为整个字符串不构成一个有效的JSON文档（既不是单个对象也不是单个数组）。本教程将介绍一种在Python中有效解析此类非标准响应的策略。

理解非标准JSON结构

上述非标准结构的核心挑战在于缺乏明确的分隔符。每个JSON对象都以 { 开始，以 } 结束。当一个JSON对象结束后，下一个JSON对象可能紧随其后开始。这种模式提供了一个关键线索：一个对象的结束符 } 后面紧跟着下一个对象的开始符 {，通常在不同的行上。我们可以利用这一特征来识别对象之间的边界。

核心解析策略

我们的策略是逐行读取原始响应数据，并寻找表示一个JSON对象结束和另一个JSON对象开始的特定行模式。具体来说，当遇到一行内容仅为 } 且紧接着下一行内容仅为 { 时，这便是一个对象边界的信号。通过这种方式，我们可以将原始的非标准字符串分割成多个独立的、有效的JSON字符串片段，然后对每个片段单独进行解析。

Pippit AI

CapCut推出的AI创意内容生成工具

133

查看详情

立即学习“Python免费学习笔记（深入）”；

Python实现示例

以下Python代码演示了如何应用上述策略来解析此类非标准的多对象JSON响应。

import json

# 示例非标准JSON响应数据
non_standard_json_data = '''
{
"self": "https://example1.com",
"key": "keyOne",
"name": "nameOne",
"emailAddress": "mailOne",
"avatarUrls": {
  "48x48": "https://test.com/secure/useravatar?avatarId=1",
  "24x24": "https://test.com/secure/useravatar?size=small&avatarId=1",
  "16x16": "https://test.com/secure/useravatar?size=xsmall&avatarId=1",
  "32x32": "https://test.com/secure/useravatar?size=medium&avatarId=1"
},
"displayName": "displayNameOne",
"active": true,
"timeZone": "Europe",
"locale": "en_UK"
}
{
"self": "https://example2.com",
"key": "keyTwo",
"name": "nameTwo",
"emailAddress": "mailTwo",
"avatarUrls": {
  "48x48": "https://test.com/secure/useravatar?avatarId=2",
  "24x24": "https://test.com/secure/useravatar?size=small&avatarId=2",
  "16x16": "https://test.com/secure/useravatar?size=xsmall&avatarId=2",
  "32x32": "https://test.com/secure/useravatar?size=medium&avatarId=2"
},
"displayName": "displayNameTwo",
"active": false,
"timeZone": "Europe",
"locale": "en_US"
}
'''

def parse_non_standard_multi_json(raw_data: str) -> list[dict]:
    """
    解析包含多个非标准连接JSON对象的字符串。

    Args:
        raw_data: 包含多个JSON对象的原始字符串。

    Returns:
        一个包含所有解析出的JSON字典的列表。
    """
    parsed_objects = []

    # 将原始数据按行分割，并移除每行首尾的空白字符
    lines = [line.strip() for line in raw_data.splitlines()]

    # 过滤掉空行，确保只处理有效内容行
    lines = [line for line in lines if line]

    current_object_start_index = 0

    for i, line in enumerate(lines):
        # 寻找对象边界：当前行是'{'且前一行是'}'
        if i > 0 and line == "{" and lines[i-1] == "}":
            # 提取前一个完整的JSON对象的所有行
            json_segment_lines = lines[current_object_start_index:i]
            # 将这些行拼接成一个完整的JSON字符串
            json_string = "".join(json_segment_lines)
            try:
                # 解析并添加到结果列表
                parsed_objects.append(json.loads(json_string))
            except json.JSONDecodeError as e:
                print(f"解析JSON片段失败: {e}\n片段内容: {json_string}")
                # 根据实际需求处理错误，例如跳过或记录

            # 更新下一个对象的起始索引
            current_object_start_index = i

    # 处理最后一个JSON对象
    if current_object_start_index < len(lines):
        json_segment_lines = lines[current_object_start_index:]
        json_string = "".join(json_segment_lines)
        try:
            parsed_objects.append(json.loads(json_string))
        except json.JSONDecodeError as e:
            print(f"解析最后一个JSON片段失败: {e}\n片段内容: {json_string}")

    return parsed_objects

# 调用解析函数
result_list = parse_non_standard_multi_json(non_standard_json_data)

# 打印解析结果以验证
print(f"成功解析 {len(result_list)} 个JSON对象:")
for idx, obj in enumerate(result_list):
    print(f"\n--- 对象 {idx + 1} ---")
    print(json.dumps(obj, indent=2, ensure_ascii=False))

代码详解

1. 导入 json 模块: Python内置的 json 库用于JSON数据的序列化和反序列化。
2. non_standard_json_data: 这是一个多行字符串，模拟了我们遇到的非标准JSON响应数据。
3. parse_non_standard_multi_json(raw_data) 函数:
   • parsed_objects = []: 初始化一个空列表，用于存储所有成功解析的JSON字典。
   • lines = [line.strip() for line in raw_data.splitlines()]: 将原始字符串按行分割，并使用 strip() 方法移除每行开头和结尾的空白字符（包括换行符、空格等）。这一步非常关键，因为它确保了 "{" 和 "}" 这样的字符串能够被准确匹配。
   • lines = [line for line in lines if line]: 过滤掉所有空行，避免它们干扰判断逻辑。
   • current_object_start_index = 0: 记录当前正在构建的JSON对象在 lines 列表中的起始行索引。
   • 循环遍历行:
     • for i, line in enumerate(lines): 迭代处理每一行及其索引。
     • if i > 0 and line == "{" and lines[i-1] == "}": 这是核心的边界检测逻辑。它检查：
       • i > 0: 确保不是第一行，因为需要比较前一行。
       • line == "{": 当前行是否为 {。
       • lines[i-1] == "}": 前一行是否为 }。
       • 如果这三个条件都满足，说明我们找到了一个JSON对象的结束和下一个JSON对象的开始，即一个对象边界。
     • 提取和解析片段: 当检测到边界时，从 current_object_start_index 到当前行 i 之间的所有行被认为是前一个完整的JSON对象。
       • json_segment_lines = lines[current_object_start_index:i]: 截取这些行。
       • json_string = "".join(json_segment_lines): 将这些行重新拼接成一个完整的JSON字符串。
       • json.loads(json_string): 使用 json.loads() 解析这个片段，并将其添加到 parsed_objects 列表中。
       • current_object_start_index = i: 更新 current_object_start_index 为当前行 i，为下一个JSON对象的解析做准备。
     • 错误处理: try-except json.JSONDecodeError 块用于捕获在解析单个JSON片段时可能发生的错误，提高了程序的健壮性。
   • 处理最后一个JSON对象: 循环结束后，current_object_start_index 到 lines 列表末尾的所有行构成了最后一个JSON对象。需要单独处理它，以确保所有对象都被解析。

注意事项与最佳实践

1. 数据格式的严格性: 此方法高度依赖于原始数据中 } 和 { 必须单独成行且紧密相连的模式。如果JSON对象内部的字符串值或键包含了 } 或 {，或者格式有其他变体（例如，} 和 { 不在独立行，或者中间有其他非空字符），此方法可能需要调整甚至失效。因此，在实际应用前，务必仔细检查非标准JSON响应的实际格式。
2. 空白字符处理: line.strip() 和过滤空行是至关重要的。如果原始数据中 } 或 { 前后存在不必要的空白字符，或者它们与JSON内容混杂在同一行，解析逻辑将受到影响。
3. 错误处理: 在生产环境中，应加强 json.JSONDecodeError 的处理。例如，可以记录错误片段、跳过损坏的对象，或者抛出自定义异常，以便上层应用能够感知并处理数据不完整的情况。
4. 性能考量: 对于非常大的响应数据，逐行处理并多次拼接字符串可能会有一定的性能开销。如果性能成为瓶颈，可以考虑使用正则表达式进行更高效的分割，但正则表达式的编写会更加复杂，且需要确保其鲁棒性。
5. API规范化: 最根本的解决方案是与API提供方沟通，请求他们返回符合标准的JSON格式（例如，将所有对象封装在一个JSON数组中）。这不仅简化了客户端解析逻辑，也提高了数据的互操作性和可靠性。

总结

尽管API返回非标准JSON格式是一种不理想的情况，但通过本教程介绍的基于行内容特征识别边界的策略，我们能够有效地在Python中解析此类数据。该方法的核心在于将原始数据分割成多个独立的、可解析的JSON字符串片段，然后逐一处理。理解这种策略及其潜在的局限性，将有助于开发者在面对各种复杂数据格式时，构建更健壮和灵活的数据处理方案。

以上就是处理非标准多对象JSON响应：Python解析策略与实践的详细内容，更多请关注php中文网其它相关文章！