Python接口返回案例如何解析返回数据

wen python案例 2026-06-30 232

本文目录导读：

基础JSON解析
结构化数据解析案例
复杂嵌套JSON解析
错误处理和验证
分页数据处理
使用数据类解析

我来详细介绍Python中解析接口返回数据的常见方法和案例：

基础JSON解析

import requests
import json
# 发送请求
response = requests.get('https://api.example.com/users')
# 解析JSON数据
if response.status_code == 200:
    # 方法1：直接使用.json()
    data = response.json()
    # 方法2：使用json模块
    # data = json.loads(response.text)
    print(f"数据类型: {type(data)}")
    print(f"数据内容: {data}")

结构化数据解析案例

案例1：用户信息API

def parse_user_api():
    """解析用户信息API"""
    response = requests.get('https://api.example.com/user/123')
    if response.status_code == 200:
        user_data = response.json()
        # 安全地获取嵌套数据
        user_info = {
            'id': user_data.get('id'),
            'name': user_data.get('profile', {}).get('name', 'Unknown'),
            'email': user_data.get('contact', {}).get('email'),
            'age': user_data.get('age', 0),
            'address': user_data.get('address', {}).get('city', 'N/A')
        }
        return user_info
    return None
# 使用示例
user = parse_user_api()
if user:
    print(f"用户: {user['name']}, 邮箱: {user['email']}")

案例2：列表数据解析

def parse_users_list():
    """解析用户列表API"""
    response = requests.get('https://api.example.com/users')
    if response.status_code == 200:
        data = response.json()
        # 假设返回格式：{"users": [...], "total": 100}
        users = data.get('users', [])
        total = data.get('total', 0)
        # 解析每个用户
        parsed_users = []
        for user in users:
            parsed_user = {
                'id': user.get('id'),
                'name': user.get('name'),
                'status': user.get('status', 'active'),
                'created_at': user.get('created_at')
            }
            parsed_users.append(parsed_user)
        return {
            'total': total,
            'users': parsed_users,
            'count': len(parsed_users)
        }
    return None

复杂嵌套JSON解析

def parse_complex_api():
    """解析复杂嵌套JSON"""
    response = requests.get('https://api.example.com/orders')
    if response.status_code == 200:
        data = response.json()
        # 复杂嵌套结构
        try:
            orders = data['data']['orders']
            for order in orders:
                # 安全获取嵌套属性
                order_id = order.get('id')
                items = order.get('items', [])
                # 解析商品
                products = []
                for item in items:
                    product = {
                        'sku': item.get('product', {}).get('sku'),
                        'name': item.get('product', {}).get('name'),
                        'price': item.get('price', 0),
                        'quantity': item.get('quantity', 1)
                    }
                    products.append(product)
                # 解析收货地址
                shipping = order.get('shipping', {})
                address = {
                    'street': shipping.get('address', {}).get('street'),
                    'city': shipping.get('address', {}).get('city'),
                    'zip': shipping.get('address', {}).get('zipcode')
                }
                print(f"订单 {order_id}: {len(products)} 件商品")
        except KeyError as e:
            print(f"数据结构错误: {e}")
            return None
        return data
    return None

错误处理和验证

import requests
from typing import Optional, Dict, Any
class APIResponseParser:
    """API响应解析器"""
    def __init__(self, response: requests.Response):
        self.response = response
        self.raw_data = None
    def parse(self) -> Optional[Dict[str, Any]]:
        """解析响应数据"""
        try:
            # 检查状态码
            if self.response.status_code != 200:
                raise ValueError(f"API返回错误状态码: {self.response.status_code}")
            # 解析JSON
            self.raw_data = self.response.json()
            # 验证必要字段
            if not self._validate_data():
                raise ValueError("响应数据格式不正确")
            return self.raw_data
        except json.JSONDecodeError as e:
            print(f"JSON解析错误: {e}")
            return None
        except ValueError as e:
            print(f"数据验证错误: {e}")
            return None
        except Exception as e:
            print(f"未知错误: {e}")
            return None
    def _validate_data(self) -> bool:
        """验证数据结构"""
        if not self.raw_data:
            return False
        # 检查必要的顶级字段
        required_fields = ['status', 'data']
        for field in required_fields:
            if field not in self.raw_data:
                return False
        return True
    def extract_value(self, path: str, default=None):
        """通过点号路径提取值"""
        keys = path.split('.')
        value = self.raw_data
        try:
            for key in keys:
                value = value[key]
            return value
        except (KeyError, TypeError):
            return default
# 使用示例
response = requests.get('https://api.example.com/data')
parser = APIResponseParser(response)
parsed_data = parser.parse()
if parsed_data:
    # 提取嵌套值
    user_name = parser.extract_value('data.user.name', 'Unknown')
    print(f"用户名: {user_name}")

分页数据处理

def process_paginated_api():
    """处理分页API"""
    base_url = 'https://api.example.com/users'
    page = 1
    all_users = []
    while True:
        # 发送请求
        response = requests.get(f"{base_url}?page={page}")
        if response.status_code != 200:
            break
        data = response.json()
        # 解析当前页数据
        users = data.get('data', [])
        all_users.extend(users)
        # 检查是否有更多页
        pagination = data.get('pagination', {})
        total_pages = pagination.get('total_pages', 1)
        if page >= total_pages:
            break
        page += 1
    return all_users

使用数据类解析

from dataclasses import dataclass
from typing import List, Optional
import requests
@dataclass
class User:
    id: int
    name: str
    email: str
    age: Optional[int] = None
    @classmethod
    def from_dict(cls, data: dict):
        return cls(
            id=data.get('id'),
            name=data.get('name'),
            email=data.get('email'),
            age=data.get('age')
        )
def parse_with_dataclass():
    """使用数据类解析API响应"""
    response = requests.get('https://api.example.com/users')
    if response.status_code == 200:
        users_data = response.json().get('users', [])
        # 转换为User对象列表
        users = [User.from_dict(user) for user in users_data]
        for user in users:
            print(f"用户: {user.name}, 邮箱: {user.email}")
        return users
    return None

始终使用.get()方法：避免KeyError
进行错误处理：检查状态码和JSON解析
验证数据结构：确保关键字段存在
使用类型提示：提高代码可读性
提取为函数/类：复用解析逻辑

这些方法可以帮助你安全、高效地解析各种API接口返回的数据。

本文地址： https://www.bmjup.com/post/12516.html