json高级处理详解 - Python JSON流式解析与性能优化指南

import json
from decimal import Decimal

# float精度问题
data = {"price": 0.1 + 0.2}
print(f"float结果: {data['price']}")  # 0.30000000000000004

# 使用Decimal保持精度
price = Decimal("0.1") + Decimal("0.2")
data_decimal = {"price": str(price)}
print(f"Decimal结果: {data_decimal['price']}")  # 0.3

# 序列化时使用parse_float
json_str = '{"amount": 19.99, "tax": 0.07}'
result_float = json.loads(json_str)
result_decimal = json.loads(json_str, parse_float=Decimal)

print(f"\nfloat: {result_float['amount'] + result_float['tax']}")
print(f"Decimal: {result_decimal['amount'] + result_decimal['tax']}")

float结果: 0.30000000000000004
Decimal结果: 0.3

float: 20.060000000000002
Decimal: 20.06

import json

def remove_circular_refs(obj, seen=None):
    """移除循环引用，替换为引用标记"""
    if seen is None:
        seen = set()

    obj_id = id(obj)

    if obj_id in seen:
        return "[循环引用]"

    if isinstance(obj, dict):
        seen.add(obj_id)
        return {k: remove_circular_refs(v, seen.copy()) for k, v in obj.items()}
    elif isinstance(obj, list):
        seen.add(obj_id)
        return [remove_circular_refs(item, seen.copy()) for item in obj]
    else:
        return obj

# 创建循环引用
node_a = {"name": "A"}
node_b = {"name": "B", "parent": node_a}
node_a["child"] = node_b  # 循环引用

# 直接序列化会报错
try:
    json.dumps(node_a)
except ValueError as e:
    print(f"循环引用错误: {e}")

# 使用处理函数
safe_data = remove_circular_refs(node_a)
result = json.dumps(safe_data, ensure_ascii=False, indent=2)
print(f"\n处理后的JSON:\n{result}")

循环引用错误: Circular reference detected

处理后的JSON:
{
  "name": "A",
  "child": {
    "name": "B",
    "parent": "[循环引用]"
  }
}

import json

class JSONValidator:
    """JSON数据验证工具"""

    @staticmethod
    def validate_type(data, schema):
        """根据schema验证数据类型"""
        errors = []

        for key, expected_type in schema.items():
            if key not in data:
                errors.append(f"缺少字段: {key}")
                continue

            actual_type = type(data[key]).__name__
            if actual_type != expected_type:
                errors.append(f"字段'{key}'类型错误: 期望{expected_type}, 实际{actual_type}")

        return errors

    @staticmethod
    def validate_required(data, required_keys):
        """验证必填字段"""
        missing = [k for k in required_keys if k not in data]
        return missing

    @staticmethod
    def validate_range(data, key, min_val=None, max_val=None):
        """验证数值范围"""
        if key not in data:
            return f"字段'{key}'不存在"

        value = data[key]
        if min_val is not None and value < min_val:
            return f"字段'{key}'值{value}小于最小值{min_val}"
        if max_val is not None and value > max_val:
            return f"字段'{key}'值{value}大于最大值{max_val}"
        return None

# 使用示例
user_data = {
    "name": "张三",
    "age": 25,
    "email": "zhangsan@example.com",
    "score": 85,
}

# 类型验证
schema = {"name": "str", "age": "int", "email": "str", "score": "int"}
type_errors = JSONValidator.validate_type(user_data, schema)
print("类型验证:", "通过" if not type_errors else type_errors)

# 必填验证
missing = JSONValidator.validate_required(user_data, ["name", "age", "phone"])
print("必填验证:", "通过" if not missing else f"缺少: {missing}")

# 范围验证
range_error = JSONValidator.validate_range(user_data, "score", 0, 100)
print("范围验证:", "通过" if not range_error else range_error)

类型验证: 通过
必填验证: 缺少: ['phone']
范围验证: 通过