基础概念:什么是JSON?为何网页常返回JSON?

JSON(JavaScript Object Notation)是一种轻量级数据交换格式,具有结构清晰、易于解析、跨平台兼容等优势,广泛应用于Web API接口响应中。相比XML,JSON更简洁、体积更小、解析更快,是现代前后端分离架构中的主流数据格式。

网页返回JSON而非HTML,主要出于以下考量:

因此,**python获取网页json**成为网络数据采集、自动化脚本开发、接口调试等场景的高频需求。

JSON基本结构示例

{
  "status": "success",
  "data": {
    "user": {
      "id": 1001,
      "name": "张三",
      "email": "zhangsan@example.com"
    },
    "orders": [
      {"order_id": "ORD20250401", "amount": 299.00},
      {"order_id": "ORD20250402", "amount": 159.50}
    ]
  },
  "timestamp": 1743513600
}

上述JSON中包含对象(键值对集合)、数组(有序列表)、字符串、数字等基本类型。在Python中,可通过内置的json模块完成解析。

主流方法详解:如何用Python获取网页JSON?

方法一:requests库(推荐首选)

requests是Python中最流行的HTTP客户端库,语法简洁、功能强大,支持会话保持、重试机制、代理设置等,是**python获取网页json**的首选方案。

核心步骤:

  1. 安装依赖:pip install requests
  2. 发送GET请求
  3. 调用.json()方法直接解析响应体

标准代码示例:

import requests
url = "https://api.example.com/data"
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}
try:
    response = requests.get(url, headers=headers, timeout=10)
    response.raise_for_status()  # 检查HTTP状态码
    data = response.json()       # 自动解析JSON
    print(data["status"])        # → success
except requests.exceptions.RequestException as e:
    print(f"请求失败:{e}")

特别提示:

  • 某些API需携带认证Token,可通过Authorization请求头传递。
  • 若响应为text/html但内容为JSON字符串,可手动json.loads(response.text)。
  • 避免直接对非JSON响应调用.json(),否则抛出JSONDecodeError。

方法二:urllib库(标准库方案)

无需安装第三方库,适用于轻量级或受限环境,但语法较冗长,需手动处理编码与异常。

import urllib.request
import json
url = "https://api.example.com/data"
req = urllib.request.Request(url, headers={
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
})
try:
    with urllib.request.urlopen(req, timeout=10) as resp:
        data = json.loads(resp.read().decode('utf-8'))
        print(data.get("data", {}).get("user", {}).get("name"))
except urllib.error.URLError as e:
    print(f"网络错误:{e.reason}")
except json.JSONDecodeError as e:
    print(f"JSON解析失败:{e.msg}")

适用场景:内网服务、无外网权限环境、教学演示等。

方法三:selenium模拟浏览器(应对JS渲染)

当网页通过JavaScript动态加载JSON(如滚动加载、AJAX延迟请求),requests直接请求静态URL将无法获取完整数据。此时需使用selenium驱动浏览器,捕获网络请求中的JSON响应。

完整流程:

  1. 启动浏览器(推荐无头模式)
  2. 监听Network.responseReceived事件
  3. 过滤含json的响应体
  4. 解析并提取数据
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import json
options = Options()
options.add_argument("--headless")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
driver = webdriver.Chrome(options=options)
# 启用网络监听
driver.execute_cdp_cmd("Network.enable", {})
driver.get("https://example.com/search?q=python")
# 等待动态加载
driver.implicitly_wait(5)
# 拦截响应
responses = driver.execute_cdp_cmd("Network.getAllRequestIds", {})
for req_id in responses.get("requestIds", []):
    try:
        resp_body = driver.execute_cdp_cmd(
            "Network.getResponseBody", {"requestId": req_id}
        )
        body = resp_body.get("body", "")
        if body:
            data = json.loads(body)
            if "results" in data:
                print("捕获到JSON数据:", data["results"])
    except:
        continue
driver.quit()

优势:可绕过部分反爬(如Cookie校验、Token动态生成);劣势:资源消耗大、速度慢,需配合ChromeDriver。

实战案例:三大典型场景深度解析

案例1:调用公开API获取实时数据

以OpenWeatherMap天气API为例,演示完整**python获取网页json**流程:

import requests
API_KEY = "your_api_key"
city = "Beijing"
url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric&lang=zh_cn"
response = requests.get(url)
data = response.json()
# 提取关键字段
weather = data["weather"][0]["description"]
temp = data["main"]["temp"]
humidity = data["main"]["humidity"]
print(f"📍 {city}天气:{weather}")
print(f"🌡️ 温度:{temp}℃ | 💧 湿度:{humidity}%")

输出示例:

📍 Beijing天气:多云
🌡️ 温度:12.5℃ | 💧 湿度:45%

此方案适用于天气、汇率、股票、新闻等公开API数据采集。

案例2:解析嵌套JSON结构(如电商订单)

真实API返回JSON常含多层嵌套,需灵活提取字段:

import requests
import json
response = requests.get("https://api.shop.com/orders?user_id=1001")
orders = response.json()
# 递归提取所有订单ID
def extract_order_ids(obj, path=""):
    if isinstance(obj, dict):
        for k, v in obj.items():
            if k == "order_id":
                print(f"订单路径:{path}.{k} → {v}")
            extract_order_ids(v, f"{path}.{k}")
    elif isinstance(obj, list):
        for i, item in enumerate(obj):
            extract_order_ids(item, f"{path}[{i}]")
extract_order_ids(orders)

输出示例:

订单路径:.data.orders[0].order_id → ORD20250401
订单路径:.data.orders[1].order_id → ORD20250402

配合jsonpath-ng库可更高效提取:

from jsonpath_ng import parse
jsonpath_expr = parse('$.data.orders[*].order_id')
order_ids = [match.value for match in jsonpath_expr.find(orders)]
print(order_ids)  # → ['ORD20250401', 'ORD20250402']

案例3:处理大文件JSON流式解析

当JSON响应体超大(如百万级日志数据),直接.json()易导致内存溢出。可使用ijson库实现流式解析:

import requests
import ijson
url = "https://data.gov.cn/api/large_dataset.json"
response = requests.get(url, stream=True)
# 流式读取每条记录
for obj in ijson.items(response.raw, 'data.items.item'):
    user_id = obj.get("user_id")
    action = obj.get("action")
    print(f"用户{user_id}执行了{action}")

核心优势:内存占用稳定,适合超大JSON处理。

常见问题与排错指南

问题1:JSONDecodeError: Expecting value

原因分析:

  • 响应体为空或非JSON格式(如返回HTML错误页)
  • 编码错误(如GB2312未解码)
  • 服务器返回压缩内容(如gzip),未自动解压

解决方案:

# 安全解析函数
import requests
import json
def safe_json(response):
    try:
        # 检查Content-Type
        if 'json' not in response.headers.get('Content-Type', ''):
            raise ValueError("响应非JSON格式")
        return response.json()
    except (json.JSONDecodeError, ValueError) as e:
        print(f"⚠️ 解析失败:{e}")
        print(f"实际内容前200字符:{response.text[:200]}")
        return None
resp = requests.get("https://api.example.com/data")
data = safe_json(resp)

问题2:中文乱码问题

根本原因:服务器返回的编码声明与实际编码不一致。

# 强制指定编码
response.encoding = 'utf-8'  # 或 'gbk'
data = json.loads(response.text)

或直接使用response.content(字节流)再解码:

data = json.loads(response.content.decode('utf-8', errors='ignore'))

问题3:403 Forbidden(反爬拦截)

常见触发条件:

  • 缺少User-Agent或为默认值
  • 请求头缺失Referer或Cookie
  • 请求频率过高触发限流

应对策略:

  1. 模拟真实浏览器请求头
  2. 添加随机User-Agent
  3. 使用代理IP轮换
  4. 控制请求间隔(如time.sleep(1))
import random
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
]
headers = {
    "User-Agent": random.choice(USER_AGENTS),
    "Referer": "https://www.example.com",
    "Cookie": "session_id=xxx"
}

性能优化:高效采集的关键技巧

技巧1:连接复用(Session优化)

频繁创建HTTP连接会消耗大量资源。使用requests.Session()可复用TCP连接,显著提升连续请求效率:

session = requests.Session()
session.headers.update({"User-Agent": "Mozilla/5.0..."})
# 连续请求复用连接
for page in range(1, 11):
    url = f"https://api.example.com/data?page={page}"
    response = session.get(url)
    data = response.json()
    process(data)

性能提升实测:在10次请求场景下,Session方案比普通请求快30%~50%。

技巧2:异步请求(asyncio + aiohttp)

面对大量独立请求(如采集1000个API),同步请求耗时极长。异步方案可并发执行:

import asyncio
import aiohttp
async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.json()
async def main():
    urls = [f"https://api.example.com/data?id={i}" for i in range(1, 1001)]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results
# 运行异步任务
data_list = asyncio.run(main())

优势:1000次请求耗时从分钟级降至秒级;注意:需处理并发上限(如asyncio.Semaphore(50)限制50并发)。

技巧3:结果缓存(避免重复请求)

对相同参数的请求缓存结果,减少服务器压力与网络开销:

import functools
import requests
@functools.lru_cache(maxsize=128)
def get_data(url):
    return requests.get(url).json()
# 首次请求耗时0.5s,后续请求毫秒级返回
data1 = get_data("https://api.example.com/data?id=1")

生产环境建议使用Redis缓存,支持分布式共享。

安全规范:避免数据泄露与攻击

风险1:硬编码API密钥

错误做法:

API_KEY = "sk_live_abc123..."  # ⚠️ 代码库中明文存储密钥

正确做法:

  1. 使用环境变量:os.environ["API_KEY"]
  2. 通过配置文件管理(如.env),并加入.gitignore
  3. 启用HTTPS防止中间人攻击
import os
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv("API_KEY")

风险2:JSON注入攻击

当JSON数据包含用户输入时,若未过滤特殊字符,可能导致JSON解析失败或XSS攻击:

import json
user_input = "测试\""
safe_json = json.dumps({"data": user_input}, ensure_ascii=False)
# 输出:{"data": "测试\\\""}  → 转义特殊字符

最佳实践:始终使用json.dumps()生成JSON,避免手动拼接字符串。

风险3:敏感信息泄露

调试时打印完整JSON可能暴露用户隐私或密钥:

# 错误:print(response.json())  # 泄露敏感字段
# 正确:仅打印必要字段
data = response.json()
print(f"状态:{data['status']} | 记录数:{len(data.get('data', []))}")

进阶技巧:处理复杂JSON场景

场景1:JSON数组分页处理

许多API采用数组分页返回,需循环获取下一页:

import requests
def fetch_all_pages(base_url):
    page = 1
    all_data = []
    while True:
        url = f"{base_url}?page={page}"
        resp = requests.get(url)
        data = resp.json()
        items = data.get("items", [])
        if not items:
            break
        all_data.extend(items)
        print(f"✅ 第{page}页已获取,共{len(items)}条")
        page += 1
    return all_data
results = fetch_all_pages("https://api.example.com/items")

场景2:处理JSON数组中的对象合并

当多个JSON片段需合并为单对象时,使用deep_merge函数:

def deep_merge(base, new):
    """递归合并字典,new优先级更高"""
    for key, value in new.items():
        if key in base and isinstance(base[key], dict) and isinstance(value, dict):
            deep_merge(base[key], value)
        else:
            base[key] = value
    return base
# 示例:合并两份用户配置
config1 = {"theme": "dark", "notifications": {"email": True}}
config2 = {"notifications": {"sms": False}, "language": "zh"}
merged = deep_merge(config1, config2)
# 结果:{"theme": "dark", "notifications": {"email": True, "sms": False}, "language": "zh"}

场景3:JSON Schema校验

确保响应结构符合预期,防止字段缺失导致后续错误:

from jsonschema import validate, ValidationError
schema = {
    "type": "object",
    "properties": {
        "status": {"type": "string", "enum": ["success", "error"]},
        "data": {
            "type": "object",
            "properties": {
                "user": {"type": "object", "required": ["id", "name"]}
            }
        }
    },
    "required": ["status", "data"]
}
data = response.json()
try:
    validate(instance=data, schema=schema)
    print("✅ 数据结构合法")
except ValidationError as e:
    print(f"❌ 校验失败:{e.message}")