罗罗编程学习记录
本页内容 展开查看

04.7.20.1 HTTP 客户端与序列化库

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.20 Python 常用第三方库

覆盖范围

  • requests:Session 会话复用、HTTPAdapter 连接池参数、默认无超时危害、stream=True 流式下载、SSL 校验与 urllib3.Retry 重试策略
  • httpx:同步/异步双 API、AsyncClient 与 Limits、HTTP/2、超时对象分级
  • aiohttp:ClientSession 连接复用、TCPConnector 并发上限与事件循环绑定
  • 序列化:orjson/ujson/msgspec 性能与兼容差异、pickle 反序列化安全边界
  • 编码、压缩、文件上传与大响应流式处理

04.7.20.1-001 requests 为什么默认不设置超时?

一句话结论

requests 2.32 系列在调用 requests.get/post/... 时不传 timeout 参数,底层 socket 就没有超时上限,连接或读取可以一直阻塞到对端断开或进程被外部杀掉。这是历史 API 设计遗留:库本身不替业务决定等待多久,因此把超时责任留给调用方。

概念解释

  • timeout 同时控制连接阶段与读取阶段,单位秒,可以传浮点数。
  • 超时不是“总耗时上限”,而是两次等待之间的间隔上限:连接一次握手等待、每次读数据等待。
  • 生产代码里“忘了传 timeout”是最常见的线上事故来源之一。

原理流程

  1. 调用方发起请求,未传 timeout。
  2. requests 把 None 透传给 urllib3 的连接与读取逻辑。
  3. 底层 socket 以阻塞模式等待,没有 SO_RCVTIMEO/SO_SNDTIMEO 超时。
  4. 对端不响应时,调用线程/协程一直挂起,直到 TCP 层超时或进程退出。

代码或图示

import requests

# 危险:对端挂起时线程永久阻塞
resp = requests.get("https://example.com/api")

# 安全:连接 3 秒、读取 10 秒
resp = requests.get("https://example.com/api", timeout=(3, 10))

常见误区

  • 以为“内网调用不会超时”:网络分区、下游 GC、连接挂死都可能让请求长期无响应。
  • 把 timeout 理解成整个请求的最大耗时:它只约束单次连接等待与单次读取等待,慢响应分多次返回时总耗时可以更长。
  • 全局默认超时需要自己封装客户端,requests 不会在 Session 上提供一个“默认 timeout”参数。

追问

  • 不传 timeout 会发生什么?答:socket 阻塞等待,直到对端断开、TCP 超时或进程被杀。
  • timeout 是总耗时吗?答:不是,它分 connect 与 read 两段,约束的是单次等待间隔。
  • 如何给所有请求统一加超时?答:封装一层请求方法,或在 HTTPAdapter/会话包装里强制注入默认值。

04.7.20.1-002 不设超时会造成什么连锁后果?

一句话结论

下游变慢时,阻塞的工作线程/协程无法释放,请求在入口处堆积,内存与文件描述符持续增长,最终拖垮整个服务;这是典型的“级联故障”起点,而不是单个慢请求问题。

概念解释

  • 同步服务(gunicorn + 线程/进程):每个阻塞请求占一个 worker 或线程,占满后新请求排队或拒绝。
  • 异步服务:如果用同步 requests 跑在事件循环里,阻塞会卡住整个 loop;即便用异步客户端,无超时的协程也会持续占用内存。
  • 故障扩散路径:下游慢 → 本服务线程堆积 → 入口队列满 → 健康检查失败 → 被摘除或重启。

原理流程

  1. 下游响应变慢,本服务调用线程挂起等待。
  2. 新请求不断进入,每个都新开线程等待,线程数与内存上涨。
  3. 连接池、文件描述符、内存达到上限,开始抛异常。
  4. 入口层超时或拒绝新请求,故障从一个下游扩散到本服务。

代码或图示

下游变慢 → 线程/协程堆积 → 内存与 fd 上涨 → 入口队列满 → 健康检查失败 → 服务被摘除

常见误区

  • 只加“请求入口超时”不够:出口调用不超时,入口线程照样被占住。
  • 以为重试能缓解:下游已经慢时重试只会放大流量,必须配合超时、限流与熔断。
  • 忽略文件描述符:每个挂起连接占用一个 fd,耗尽后新连接直接失败。

追问

  • 无超时最先耗尽什么资源?答:工作线程/协程,随后是内存、fd 与连接池。
  • 为什么重试会放大故障?答:同一慢下游被重复请求,流量成倍增加。
  • 同步库放进异步 loop 有什么额外风险?答:阻塞调用卡住事件循环,所有并发请求一起停顿。

一句话结论

requests.Session 在内部持有 urllib3 连接池,同一主机的多次请求复用 keep-alive 连接,并自动维护 Cookie Jar;跨请求的认证头、默认参数也挂在 Session 上,避免每次请求重复握手与重复携带凭证。

概念解释

  • 连接复用:TCP 三次握手与 TLS 握手只在首次发生,后续请求走已建立的 keep-alive 连接。
  • Cookie 持久化:Session.cookies 是 RequestsCookieJar,响应里的 Set-Cookie 自动写回,下次请求自动带上。
  • 进程内长期复用 Session 时,要注意线程安全与连接池大小。

原理流程

  1. 创建 Session(),初始化 Cookie Jar 与挂载的 HTTPAdapter。
  2. 首次请求经 adapter 从连接池取/建连接,完成握手。
  3. 响应 Cookie 写入 Jar,连接归还池中保持 keep-alive。
  4. 后续请求命中同一连接,复用 TCP/TLS 通道并自动携带 Cookie。

代码或图示

import requests

s = requests.Session()
s.headers.update({"User-Agent": "my-client/1.0"})

r1 = s.get("https://example.com/login")
r2 = s.get("https://example.com/profile")  # 复用连接与 Cookie

常见误区

  • 把 Session 当成“全局单例到处传”:长生命周期 Session 会持有连接与 Cookie,需评估隔离性。
  • 以为 Session 复用的是登录态:Cookie 由服务端下发,Session 只是携带,过期后需要重新登录。
  • 忘记关闭 Session:连接池中 keep-alive 连接需要在生命周期结束时释放,短脚本可 with requests.Session() as s:。

追问

  • Session 复用的底层是什么?答:urllib3 连接池里的 keep-alive 连接。
  • Cookie 存放在哪里?答:Session.cookies,一个 RequestsCookieJar。
  • 多个不同账号能用同一个 Session 吗?答:不建议,Cookie 与头会串,应按会话隔离。

04.7.20.1-004 HTTPAdapter 与连接池参数怎么调?

一句话结论

HTTPAdapter 通过 pool_connections(保持复用的连接数)、pool_maxsize(每主机最大连接数)、pool_block(池耗尽时是否阻塞等待)控制连接池行为;并发量上来后默认 pool_maxsize=10 容易成为瓶颈。

概念解释

  • pool_connections:池中保活的连接主机数,空闲连接保留多少条。
  • pool_maxsize:同一个主机最多建立多少条并发连接。
  • pool_block=False(默认):池满时直接新建连接;True:阻塞等待归还。
  • 适配器按 scheme 挂载:session.mount("https://", HTTPAdapter(...))。

原理流程

  1. 创建 HTTPAdapter 并配置池参数。
  2. 调用 session.mount 把适配器绑定到 http/https 前缀。
  3. 请求经过适配器,urllib3 按池参数取连接、复用或新建。
  4. 响应结束后连接归还池,按 keep-alive 策略保留或关闭。

代码或图示

import requests
from requests.adapters import HTTPAdapter

adapter = HTTPAdapter(pool_connections=20, pool_maxsize=50, pool_block=False)
s = requests.Session()
s.mount("https://", adapter)
s.mount("http://", adapter)

常见误区

  • 只调 pool_maxsize 不评估下游承载:连接开得过大反而压垮对端。
  • 混淆 pool_connections 与 pool_maxsize:前者是空闲保活数量,后者是并发上限。
  • 多线程共用 Session 时池参数要按总并发设计,而不是按单线程。

追问

  • 默认 pool_maxsize 是多少?答:10(待确认:验证点:查看 requests.adapters.HTTPAdapter 源码默认参数)。
  • pool_block=True 有什么代价?答:池满时调用方阻塞等待归还,可能把超时拖长。
  • 连接池大小与下游连接数什么关系?答:本服务池上限不能让下游总连接数超过其容量。

04.7.20.1-005 urllib3.Retry 策略由哪些参数组成?

一句话结论

urllib3.util.Retry 用 total/connect/read 限制重试次数,backoff_factor 控制退避间隔,status_forcelist 指定触发重试的状态码,allowed_methods 指定哪些方法可重试,backoff_max 限制退避上限。

概念解释

  • 退避公式:backoff_factor * (2 ** (retries - 1)),指数增长,再叠加可选抖动。
  • 默认 allowed_methods 不含 POST:POST 被视为非幂等,不自动重试(待确认:验证点:urllib3 版本中默认方法集合)。
  • status_forcelist 常见填 429、500、502、503、504;400/401/403/404 不应重试。

原理流程

  1. 配置 Retry 实例,写清次数、退避、状态码、方法白名单。
  2. 把 Retry 挂到 HTTPAdapter.max_retries。
  3. 一次请求失败后,urllib3 判断是否命中可重试条件。
  4. 命中则按退避间隔等待后重试,超出 total 或不可重试则抛出异常。

代码或图示

from urllib3.util.retry import Retry

retry = Retry(
    total=3,
    backoff_factor=0.5,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "HEAD", "OPTIONS"],
    backoff_max=30,
)

常见误区

  • 对所有方法开重试:POST/PATCH 可能造成重复下单、重复扣款。
  • 只看状态码不看异常:连接错误、读超时是否重试也要在策略里区分。
  • 退避没有上限:故障持续时重试间隔无限增长,应设 backoff_max。

追问

  • 退避间隔怎么算?答:backoff_factor * 2**(重试次数-1),指数增长。
  • 哪些状态码不该重试?答:400/401/403/404 这类确定性失败。
  • 为什么默认不重试 POST?答:POST 通常非幂等,重试可能产生重复副作用。

04.7.20.1-006 如何在 requests 中挂载重试?

一句话结论

requests 本身不直接暴露重试配置,需要构造 HTTPAdapter(max_retries=Retry(...)) 并 mount 到 Session;重试在 adapter 层完成,业务代码无需手写循环。

概念解释

  • 重试发生在 urllib3 连接层,覆盖连接失败与指定状态码。
  • 业务层还可以在上面再包一层重试(如 tenacity),两层职责不同:底层处理瞬时网络抖动,业务层处理需要判断响应体的场景。
  • 必须配合超时,否则重试间隔内每次等待都可能无限阻塞。

原理流程

  1. 构造 Retry 策略实例。
  2. 用它创建 HTTPAdapter,传入 max_retries。
  3. session.mount 挂载适配器到 http/https。
  4. 后续请求经 adapter 自动重试,业务代码只处理最终失败。

代码或图示

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

s = requests.Session()
retry = Retry(total=3, backoff_factor=0.5, status_forcelist=[502, 503, 504])
adapter = HTTPAdapter(max_retries=retry)
s.mount("https://", adapter)

resp = s.get("https://example.com", timeout=(3, 10))

常见误区

  • 直接在 requests.get 上传 max_retries:顶层 API 不接受该参数,必须走 Session + adapter。
  • 重试不区分异常类型:把参数错误也重试一遍,徒增延迟。
  • 忘记设超时:重试叠加无超时等待,故障时阻塞更久。

追问

  • 重试挂在哪一层?答:HTTPAdapter.max_retries,底层由 urllib3 执行。
  • 业务层重试和底层重试有什么区别?答:底层管网络抖动与状态码,业务层按响应体与业务错误码判断。
  • 重试为什么必须配超时?答:避免每次尝试都无限阻塞,放大故障。

04.7.20.1-007 SSL 校验是怎么做的,何时关闭?

一句话结论

requests 默认校验服务端证书链与主机名:通过系统/ca 包信任链验证证书是否由可信 CA 签发、是否过期、域名是否匹配;verify=False 会跳过校验,仅用于本地调试,生产环境不应关闭。

概念解释

  • verify=True(默认):校验证书链、有效期、主机名;可传本地 CA 证书路径。
  • verify=False:跳过校验,同时 urllib3 会抛出 InsecureRequestWarning。
  • 主机名不匹配、证书过期、自签名证书都会触发 SSL 相关异常。

原理流程

  1. TLS 握手阶段服务端下发证书链。
  2. 客户端用信任根证书逐级验签,检查有效期与用途。
  3. 校验证书主题/SAN 与请求主机名是否一致。
  4. 任一环节失败抛出 SSLError;verify=False 则跳过上述检查。

代码或图示

import requests

# 使用自定义 CA 证书
r = requests.get("https://internal.example.com", verify="/etc/ssl/internal-ca.pem")

# 仅本地调试用,生产禁止
r = requests.get("https://example.com", verify=False)

常见误区

  • 生产环境图省事 verify=False:中间人可以替换证书窃听或篡改流量。
  • 自签名环境只关校验,不加内部 CA:正确做法是把内部根证书加入信任链。
  • 以为关了校验就没有警告:urllib3 会持续告警,需显式过滤而非依赖默认静默。

追问

  • verify 可以传什么值?答:True/False 或本地 CA 证书/证书包路径。
  • 跳过校验有什么风险?答:无法识别中间人,流量可被窃听篡改。
  • 内网自签名服务怎么安全接入?答:导入内部根 CA,保留 verify=True。

04.7.20.1-008 stream=True 解决什么问题,不关闭会泄漏什么?

一句话结论

stream=True 让响应体不在请求时一次性读入内存,而是按需迭代读取;适合下载大文件或转发流式响应。用完必须关闭连接(或用 with 上下文),否则连接无法归还连接池,造成连接与文件描述符泄漏。

概念解释

  • 默认 stream=False:响应体立即下载到内存,大文件直接撑爆内存。
  • stream=True:响应头先返回,body 保持连接打开,用 iter_content/iter_lines 逐块取。
  • 未关闭的响应会占用底层连接,池内可用连接逐步减少。

原理流程

  1. 请求带 stream=True,客户端只接收响应头。
  2. 调用方按块迭代 body,写入文件或转发。
  3. body 读完后连接自动可归还;中途放弃则需显式 response.close()。
  4. with requests.get(..., stream=True) as r: 在退出时保证关闭。

代码或图示

import requests

with requests.get("https://example.com/big.iso", stream=True, timeout=(3, 30)) as r:
    r.raise_for_status()
    with open("big.iso", "wb") as f:
        for chunk in r.iter_content(chunk_size=1024 * 1024):
            f.write(chunk)

常见误区

  • 流式下载还把整个响应 r.content 读出来:内存占用回到默认模式。
  • 异常分支忘记关闭:连接泄漏在长服务里累积,最终池耗尽。
  • iter_content 不设 chunk_size:块大小由底层决定,内存不可控。

追问

  • stream=True 什么时候返回 body?答:不自动下载,迭代时才从连接读取。
  • 不关闭响应泄漏什么?答:底层连接与文件描述符,连接池无法复用。
  • 如何保证异常时也关闭?答:用 with 包裹响应对象,退出时自动 close。

04.7.20.1-009 大响应下载怎么控制内存与断点续传?

一句话结论

大文件用 stream=True 加 iter_content 分块落盘,按块写入避免整文件进内存;需要断点续传时通过 Range 头带上已下载字节数,服务端支持则返回 206 Partial Content,追加写入本地文件。

概念解释

  • iter_content(chunk_size):按固定字节块迭代,二进制下载首选;iter_lines 面向文本行。
  • Range: bytes=start-:请求从指定偏移开始的剩余内容。
  • 服务端返回 Accept-Ranges: bytes 才支持续传;不支持则需从头重下。

原理流程

  1. 发起流式请求,先看响应头是否支持 Range。
  2. 读取本地已下载大小,构造 Range 头。
  3. 收到 206 后以追加模式写入;200 则重新整段下载。
  4. 循环分块写入直到结束,记录校验摘要用于完整性核对。

代码或图示

import os, requests

local = "big.iso"
pos = os.path.getsize(local) if os.path.exists(local) else 0
headers = {"Range": f"bytes={pos}-"}

with requests.get("https://example.com/big.iso", stream=True, headers=headers, timeout=(3, 30)) as r:
    mode = "ab" if r.status_code == 206 else "wb"
    with open(local, mode) as f:
        for chunk in r.iter_content(1024 * 1024):
            f.write(chunk)

常见误区

  • 服务端不支持 Range 仍追加写入:会把两段数据接错,必须按状态码决定模式。
  • 下载完不校验摘要:静默损坏无法发现。
  • 多线程分片下载不记录分片进度:中断后难以对齐续传位置。

追问

  • 怎么判断服务端支持续传?答:响应头 Accept-Ranges: bytes。
  • 206 与 200 在续传里分别怎么处理?答:206 追加,200 从头覆盖。
  • 分块下载用什么迭代器?答:二进制用 iter_content,文本按行用 iter_lines。

04.7.20.1-010 文件上传 multipart 怎么构造?

一句话结论

上传文件用 files= 参数传入文件对象或元组,requests 自动构造 multipart/form-data 编码并设置边界;同时提交表单字段用 data=,大文件同样可以流式传入避免整体读入内存。

概念解释

  • files={"field": open("a.pdf", "rb")}:字段名 + 文件对象,文件名与 Content-Type 由请求自动推断。
  • 元组形式 (filename, fileobj, content_type) 可以显式指定文件名与类型。
  • 二进制大对象也可用 data= 直接发送字节流,Content-Type 由调用方控制。

原理流程

  1. 打开待上传文件,以二进制句柄传入 files。
  2. requests 生成随机边界,按 multipart 规范拼装各部分。
  3. 表单字段写入对应 section,文件流逐块编码进请求体。
  4. 服务端按 boundary 拆分字段与文件。

代码或图示

import requests

with open("report.pdf", "rb") as f:
    r = requests.post(
        "https://example.com/upload",
        data={"category": "report"},
        files={"file": ("report.pdf", f, "application/pdf")},
        timeout=(3, 30),
    )

常见误区

  • 用文本模式 open(..., "r") 上传二进制:内容被编码破坏。
  • 文件句柄在请求结束后才关闭:应在 with 内完成请求。
  • 把整个文件读成字节串再传:大文件不必要地占用内存,流式句柄更优。

追问

  • multipart 边界由谁生成?答:requests 生成随机 boundary,写进 Content-Type。
  • 表单字段和文件分别用哪个参数?答:字段 data=,文件 files=。
  • 上传大文件为什么推荐传句柄?答:流式编码,避免整文件进内存。

04.7.20.1-011 压缩响应是自动解压的吗?

一句话结论

requests 会在请求头自动带上 Accept-Encoding: gzip, deflate,响应体如果是 gzip/deflate,访问 response.content/response.text 时由 urllib3 自动解压;br(Brotli)支持取决于是否安装 brotli 依赖,未安装时不应假设能自动解压。

概念解释

  • 压缩发生在传输层,目的是减小报文体积;解压对业务透明。
  • 自动解压只覆盖 urllib3 识别的编码,未知编码会保留原始字节。
  • 下载原始压缩包(如 .gz 文件本身)时不要依赖自动解压,应直接落盘字节。

原理流程

  1. 请求阶段客户端声明可接受的压缩编码。
  2. 服务端按 Content-Encoding 压缩 body 返回。
  3. urllib3 读取 body 后按编码解压,response.content 拿到解压后字节。
  4. 无法识别的编码保留压缩字节,由调用方处理。

代码或图示

import requests

r = requests.get("https://example.com/api", timeout=5)
print(r.headers.get("Content-Encoding"))
print(r.text)  # 已解压文本

常见误区

  • 以为所有压缩格式都开箱即用:br 需要额外安装 brotli 包,否则服务端可能不返回 br。
  • 把自动解压后的内容再压缩一次:重复压缩浪费 CPU。
  • 保存原始压缩文件时读了 r.content:已被解压,文件损坏。

追问

  • 自动解压由谁完成?答:urllib3 在读取响应体时按 Content-Encoding 解压。
  • br 支持缺什么?答:需要安装 brotli 相关依赖,否则不识别。
  • 想保存原始 gz 文件怎么办?答:直接写 r.content 原始字节,不要经过文本属性。

04.7.20.1-012 响应编码乱码怎么判断?

一句话结论

response.encoding 来自响应头 Content-Type 的 charset,缺失时 requests 会按 ISO-8859-1 猜测;中文接口若未声明编码,应先看 apparent_encoding(基于字节内容探测)再显式赋值,否则 response.text 出现乱码。

概念解释

  • response.encoding:用于解码 response.text,可手动覆盖。
  • response.apparent_encoding:chardet/charset-normalizer 探测结果,慢于头信息但更准。
  • response.content 始终是原始字节,不受编码影响。

原理流程

  1. 读取响应头,解析 charset 写入 response.encoding。
  2. 无 charset 时按默认推断,解码 text。
  3. 发现乱码后,用 apparent_encoding 探测并回写 response.encoding。
  4. 重新取 response.text 得到正确文本。

代码或图示

import requests

r = requests.get("https://example.com/legacy-page", timeout=5)
if r.encoding is None or r.encoding == "ISO-8859-1":
    r.encoding = r.apparent_encoding
print(r.text)

常见误区

  • 直接改 r.content.decode("utf-8") 而不确认真实编码:GBK 页面会二次乱码。
  • 忽略响应头声明:探测结果只用于兜底,头里明确 charset 时应优先采信。
  • 二进制接口也去猜编码:文件、图片应直接用 content 字节处理。

追问

  • text 与 content 区别?答:text 按 encoding 解码为字符串,content 是原始字节。
  • 探测编码用什么属性?答:apparent_encoding,底层字符集探测。
  • 头里没 charset 默认按什么?答:requests 历史默认 ISO-8859-1(待确认:验证点:当前版本对文本响应的默认推断规则)。

04.7.20.1-013 超时 connect/read 分级与异常类型怎么区分?

一句话结论

timeout=(connect, read) 分别约束 TCP/TLS 握手等待与每次读取等待;连接阶段失败抛 ConnectionError 子类,读取阶段超时抛 ReadTimeout,整体超时按阶段归类,调用方可以分别处理重试与告警。

概念解释

  • ConnectTimeout:连接阶段超时,属于 ConnectionError 与 TimeoutError 链路。
  • ReadTimeout:已建立连接后读取数据超时。
  • ConnectionError 覆盖 DNS 失败、拒绝连接、重置等连接层问题。

原理流程

  1. 传入二元组超时:第一个是 connect,第二个是 read。
  2. 握手阶段超过 connect 上限抛 ConnectTimeout。
  3. 连接建立后两次读取间隔超过 read 上限抛 ReadTimeout。
  4. 业务层按异常类型决定重试、降级还是直接失败。

代码或图示

import requests
from requests.exceptions import ConnectTimeout, ReadTimeout, ConnectionError

try:
    r = requests.get("https://example.com", timeout=(3, 10))
except ConnectTimeout:
    # 握手失败,可重试
    ...
except ReadTimeout:
    # 响应中途停滞,按业务决定是否重试
    ...
except ConnectionError:
    # DNS / 拒绝 / 重置
    ...

常见误区

  • 只捕获 requests.Timeout:它同时是 ConnectTimeout 与 ReadTimeout 的父类,无法区分阶段。
  • 把读超时当成总耗时:长响应分块返回时,每次块间隔独立计时。
  • 不区分异常一律重试:连接拒绝可能是配置错误,重试无意义。

追问

  • 二元组超时两个值分别是什么?答:connect 与 read,单位秒。
  • ReadTimeout 什么时候触发?答:连接建立后两次读取之间超过 read 上限。
  • 为什么要分开捕获?答:区分握手失败与中途停滞,重试与告警策略不同。

04.7.20.1-014 重试为什么必须以幂等为前提?

一句话结论

重试意味着同一个请求可能被执行多次,只有接口具备幂等性(重复调用结果等价于一次)才安全;GET/HEAD/OPTIONS 通常只读可安全重试,POST/PATCH/DELETE 是否幂等要看业务语义,不能按方法名一概而论。

概念解释

  • 幂等:f(x) 调用一次与调用 N 次对系统的最终状态相同。
  • 非幂等副作用:重复创建订单、重复扣款、重复发消息。
  • 触发重试的场景:网络超时、连接重置、502/503,这些情况下服务端可能已经执行成功。

原理流程

  1. 一次请求发出后网络中断,客户端不知道服务端是否已处理。
  2. 若请求非幂等,重试会产生第二次副作用。
  3. 设计上通过业务幂等键(请求 ID、唯一单号)让服务端去重。
  4. 重试策略只对确认幂等的方法或带幂等键的写操作开启。

代码或图示

# 安全:只读,可重试
# 谨慎:写操作需带服务端可识别的幂等键
payload = {"order_id": "ORDER-20261119-001", "amount": 100}
r = requests.post("https://example.com/orders", json=payload, timeout=5)

常见误区

  • 认为 DELETE 一定幂等:按规范是,但业务实现可能重复删除关联数据。
  • 用客户端状态判断“没成功”:超时不代表服务端没执行。
  • 不做幂等键就对写接口重试:重复副作用只能靠事后对账修复。

追问

  • 什么是幂等?答:多次调用的最终状态与一次相同。
  • 写接口怎么做到可重试?答:服务端基于唯一幂等键去重,重复请求返回首次结果。
  • 网络超时后服务端一定没处理吗?答:不一定,请求可能已到达并执行。

04.7.20.1-015 连接池耗尽有什么表现,怎么调优?

一句话结论

池内连接被挂起请求占满后,新请求要么阻塞等待、要么新建连接导致 fd 上涨;表现为响应变慢、Connection pool is full 类告警、内存与连接数持续增长。调优方向是缩短超时、提高 pool_maxsize、修复泄漏的响应,并限制总并发。

概念解释

  • 池耗尽本质是“借出连接未归还”速度跟不上“新借连接”速度。
  • 常见原因:响应未关闭、请求无超时长期挂起、并发量超过池上限。
  • 调优必须结合下游承载,盲目加大池只会把压力转移到对端。

原理流程

  1. 请求占用连接后阻塞在慢响应上,连接迟迟不归还。
  2. 并发请求把池内连接全部占满。
  3. 按 pool_block 行为阻塞等待或新建连接。
  4. 定位慢请求与未关闭响应,调整超时、池大小与并发上限。

代码或图示

慢响应占住连接 → 池满 → 阻塞等待 / 新建连接 → fd 与内存上涨 → 拒绝服务

常见误区

  • 一出问题就调大 pool_maxsize:根因若是超时缺失,加大池只会延后爆发。
  • 忽略响应关闭路径:异常分支泄漏连接,池使用率长期居高不下。
  • 多进程部署时按单机配置池:总连接数 = 进程数 × 池大小,要核对下游上限。

追问

  • 池耗尽最先看什么?答:响应是否关闭、超时是否配置、并发是否超上限。
  • 多进程下总连接数怎么算?答:进程数 × 每进程池大小,需 ≤ 下游连接容量。
  • pool_block=True 耗尽时会怎样?答:调用方阻塞等待连接归还,延迟上升。

04.7.20.1-016 Session 能否多线程共享?

一句话结论

Session 内部连接池基于 urllib3,在多线程场景下通常可以共享使用,连接池本身做了并发控制;但 Session 上可变状态(自定义头、Cookie、挂载的适配器)在并发修改时需要自己加锁,且按账号/租户隔离的会话不应共用一个实例。

概念解释

  • 只读地复用连接池与默认配置:多线程共用是常见做法。
  • 并发写 session.headers/session.cookies:没有原子保护,可能出现竞态。
  • 长服务里 Session 生命周期应覆盖整个应用,而不是每请求新建(浪费握手)也不是跨业务混用。

原理流程

  1. 工作线程从同一 Session 取连接,连接池分配/归还连接。
  2. 默认头与 Cookie 作为请求基准被读取。
  3. 若某线程修改共享可变状态,其他线程可能读到中间态。
  4. 多账号场景按会话创建独立 Session,隔离凭证与连接。

代码或图示

import threading, requests

session = requests.Session()

def worker():
    r = session.get("https://example.com", timeout=5)
    return r.status_code

threads = [threading.Thread(target=worker) for _ in range(10)]

常见误区

  • 把每请求新建 Session 当成安全做法:重复握手,吞吐明显下降。
  • 不同认证用户共用 Session:Cookie 与头串号。
  • 在请求回调里改写全局 Session 头:并发下影响其他线程。

追问

  • 共享 Session 主要复用什么?答:连接池、默认头与 Cookie Jar。
  • 什么状态要避免并发改?答:headers、cookies、挂载的适配器。
  • 多租户怎么隔离?答:按租户/账号创建独立 Session,凭证不混用。

04.7.20.1-017 requests 的底层调用链是什么?

一句话结论

调用 Session.request 构造 PreparedRequest,经 HTTPAdapter.send 交给 urllib3 的 HTTPConnectionPool 取连接、发送请求并返回 Response;requests 负责 API 与 cookie/认证,urllib3 负责连接管理与协议细节,底层再到 http.client 与 socket。

概念解释

  • PreparedRequest:把方法、URL、头、body 预处理成可发送形态。
  • HTTPAdapter:requests 与 urllib3 之间的适配层,可挂载重试与池参数。
  • urllib3 连接池管理 keep-alive 连接,http.client 处理报文,socket 负责字节收发。

原理流程

  1. Session.request 合并默认头与参数,构造 PreparedRequest。
  2. 请求经挂载的 HTTPAdapter.send 发出。
  3. adapter 从 urllib3 连接池取/建连接,发送报文。
  4. 响应流回,包装成 requests.Response 返回给调用方。

代码或图示

Session.request → PreparedRequest → HTTPAdapter.send
  → urllib3 ConnectionPool → http.client → socket
  → Response

常见误区

  • 以为 requests 直接操作 socket:中间隔了 adapter、urllib3、http.client 多层。
  • 自定义行为只改 Session:拦截协议层要通过自定义 HTTPAdapter。
  • 排查连接问题时不看 urllib3 日志:连接池与重试信息在底层更完整。

追问

  • PreparedRequest 做什么?答:预处理方法、URL、头与 body 为可发送请求。
  • 适配器在链路哪一层?答:requests 与 urllib3 之间,承载池与重试配置。
  • 谁管理 keep-alive 连接?答:urllib3 连接池。

04.7.20.1-018 证书校验失败有哪些异常?

一句话结论

证书链不受信、证书过期、主机名不匹配分别抛出 SSLError 的不同子类或包装异常;DNS 失败、连接拒绝属于 ConnectionError,不要和证书问题混为一类处理。

概念解释

  • 证书链错误:缺少可信根或中间证书,验签失败。
  • 过期/未生效:证书时间不在有效期内。
  • 主机名不匹配:证书 SAN/主题与请求域名不一致。

原理流程

  1. TLS 握手下发证书链。
  2. 信任链验签失败抛出证书错误。
  3. 有效期检查失败抛出过期类错误。
  4. 主机名校验失败抛出匹配错误,统一可被 requests.exceptions.SSLError 捕获。

代码或图示

import requests
from requests.exceptions import SSLError

try:
    requests.get("https://expired.example.com", timeout=5)
except SSLError as e:
    # 含证书链、过期、主机名不匹配等 SSL 层问题
    print(e)

常见误区

  • 遇到 SSL 错误直接 verify=False:绕过校验而不修信任链,生产留隐患。
  • 把证书错误当网络错误重试:重试无法修复配置问题。
  • 中间证书未部署:客户端报链不受信,问题在服务端证书配置。

追问

  • 主机名不匹配属于哪类错误?答:SSL 校验错误,SSLError 链路。
  • 信任链不受信怎么修?答:补全中间证书或配置客户端信任根。
  • 关校验能解决过期证书吗?答:只是跳过检查,风险仍在。

04.7.20.1-019 代理如何配置,环境变量如何介入?

一句话结论

requests 按 proxies= 参数配置代理,未显式配置时会读取 HTTP_PROXY/HTTPS_PROXY 等环境变量;代理凭证可以写在 URL 里,NO_PROXY 控制绕过列表,容器与开发机的代理差异容易导致连不通。

概念解释

  • proxies={"http": "http://127.0.0.1:8080", "https": "..."} 按 scheme 分流。
  • 环境变量默认被信任,CI/容器里预置的代理可能影响本地请求。
  • 代理鉴权:http://user:pass@host:port 形式传入。

原理流程

  1. 检查请求是否在 NO_PROXY 绕过列表。
  2. 取显式 proxies 配置,没有则读环境变量。
  3. 按 scheme 选择代理地址,建立到代理的隧道连接。
  4. HTTPS 通过 CONNECT 隧道转发原始 TLS 流量。

代码或图示

import requests

proxies = {"https": "http://proxy.example.com:8080"}
r = requests.get("https://example.com", proxies=proxies, timeout=5)

# 环境变量示例(不入代码仓库)
# HTTPS_PROXY=http://proxy.example.com:8080
# NO_PROXY=localhost,internal.example.com

常见误区

  • 容器里不通也不查代理:环境变量代理把流量发到不可达地址。
  • 代理凭证硬编码进代码:应走环境变量或密钥管理。
  • 以为 HTTPS 代理能看到明文内容:CONNECT 隧道内仍是端到端 TLS。

追问

  • 代理配置优先级?答:显式 proxies= 高于环境变量。
  • NO_PROXY 作用?答:匹配到的主机绕过代理直连。
  • HTTPS 代理怎么转发?答:CONNECT 建立隧道,内部 TLS 不变。

04.7.20.1-020 请求钩子 hooks 与 prepare_request 有什么用?

一句话结论

hooks={"response": fn} 在响应返回后插入统一处理(日志、错误断言、指标),Request.prepare/Session.prepare_request 则把请求预处理成 PreparedRequest,便于复用同一套拼装逻辑做重试、转发或自定义发送。

概念解释

  • response 钩子接收响应对象,可读取头/体并补充标记。
  • 钩子适合放横切关注点:记录耗时、按状态码抛异常、采集指标。
  • PreparedRequest 可在多适配器、多会话之间复用拼装结果。

原理流程

  1. 请求构造完成后注册 response 钩子。
  2. 响应返回后依次调用钩子函数。
  3. 钩子可改写响应或附加属性,再返回给业务代码。
  4. 需要重发时基于 PreparedRequest 复用已预处理报文。

代码或图示

import requests

def log_hook(resp, *args, **kwargs):
    print(resp.request.url, resp.status_code, resp.elapsed)

s = requests.Session()
s.hooks["response"].append(log_hook)
r = s.get("https://example.com", timeout=5)

常见误区

  • 在钩子里做重业务或阻塞操作:拖慢所有请求链路。
  • 钩子吞掉异常:响应错误被静默,上层感知不到失败。
  • 把业务判断写进钩子:横切逻辑与业务耦合,难以测试。

追问

  • hooks 支持哪些事件?答:常用 response 钩子(待确认:验证点:当前版本支持的钩子事件类型)。
  • PreparedRequest 什么时候复用?答:需要在不同发送路径重发同一请求时。
  • 钩子适合放什么?答:日志、指标、统一错误断言等横切逻辑。

04.7.20.1-021 会话级默认头、Cookie 与认证怎么设置?

一句话结论

Session.headers.update 设默认请求头,Session.cookies 直接写入 Cookie,认证可用 Session.auth 或各请求的 auth= 参数;会话级配置对后续所有请求生效,代码比每次重复传头更一致,也避免漏带凭证。

概念解释

  • 默认头与单次请求头合并,单次参数可覆盖会话默认值。
  • 认证三种方式:auth= 基本认证元组、会话级 auth、手动在头里放 Bearer token。
  • 凭证不写进代码仓库,应从环境变量或密钥管理读取。

原理流程

  1. 创建 Session,更新默认头与 Cookie。
  2. 设置会话级认证回调或元组。
  3. 后续请求自动合并默认头、Cookie 与认证信息。
  4. 单次请求需要覆盖时,在该调用上传同名参数。

代码或图示

import requests

s = requests.Session()
s.headers.update({"X-Client": "order-service/1.0"})
s.cookies.set("sid", "token-value")
s.auth = ("user", "password")

r = s.get("https://example.com/me", timeout=5)

常见误区

  • 把长期 token 存进全局 Session 后不刷新:过期后请求持续 401。
  • 会话头与单次头同名时不清楚谁覆盖谁:单次请求参数优先。
  • 硬编码账号密码进源码:违反凭证管理边界,应走配置注入。

追问

  • 单次请求头能覆盖会话默认头吗?答:能,单次参数优先级更高。
  • auth 支持哪些形式?答:基本认证元组、可调用认证对象,或手动写 Authorization 头。
  • 凭证应该放在哪里?答:环境变量/密钥管理,不进仓库与代码。

04.7.20.1-022 自定义 HTTPAdapter 能拦截什么?

一句话结论

继承 HTTPAdapter 可以重写 send/init_poolmanager 等方法,在请求发出前后插入日志、指标、重试装饰、连接池定制或协议替换;它是 requests 扩展传输层的标准落点,业务横切逻辑不应该散落在各个调用处。

概念解释

  • adapter 绑定到 scheme(http/https),同一前缀下所有请求经过它。
  • 可观测性:在 send 前后记录耗时、状态码、异常类型。
  • 连接管理:重写池管理器参数,按目标主机差异化配置。

原理流程

  1. 子类继承 HTTPAdapter,重写需要介入的方法。
  2. 在重写方法里调用 super().send(...) 保留默认行为。
  3. 挂载到 Session 的对应 scheme。
  4. 横切逻辑在适配器层统一生效,业务代码只关心业务。

代码或图示

import time, requests
from requests.adapters import HTTPAdapter

class TimingAdapter(HTTPAdapter):
    def send(self, request, **kwargs):
        start = time.perf_counter()
        resp = super().send(request, **kwargs)
        print(request.url, resp.status_code, time.perf_counter() - start)
        return resp

s = requests.Session()
s.mount("https://", TimingAdapter())

常见误区

  • 重写 send 不调用父类:连接池与重试行为丢失。
  • 在适配器里做业务校验:传输层不应理解业务语义。
  • 同一 Session 挂载多个同 scheme 适配器:后挂载覆盖先挂载。

追问

  • adapter 挂载按什么匹配?答:按 URL scheme,http/https 分别挂载。
  • 重写 send 为什么要调 super?答:保留连接池、重试与默认发送逻辑。
  • 统一耗时日志放哪层合适?答:传输适配器或上层客户端封装。

04.7.20.1-023 大请求体流式上传怎么控制内存?

一句话结论

上传大文件时把打开的文件句柄交给 files/data,requests/urllib3 按流编码发送;不要先 read() 成字节串再传,避免整文件驻留内存。请求体很大时还要关注服务端接收限制与发送超时。

概念解释

  • 流式句柄:边读边编码边发送,内存占用与块大小相关。
  • 预读成 bytes:整文件进入进程内存,大文件直接 OOM。
  • 发送超时要比下载场景留足余量,慢速上传容易触发 write 阶段等待。

原理流程

  1. 以二进制模式打开文件,保留句柄。
  2. 请求构造时传入句柄作为文件字段。
  3. 传输层按块读取、编码、发送。
  4. 发送完成后关闭句柄,异常路径用 with 保证释放。

代码或图示

import requests

with open("archive.tar.gz", "rb") as f:
    r = requests.post(
        "https://example.com/upload",
        files={"archive": f},
        timeout=(3, 120),
    )

常见误区

  • data=open(...).read():文件内容一次性进内存。
  • 上传超时沿用下载的 read 超时:慢上传在写阶段卡住。
  • 不校验服务端大小限制:传到一半被断开,前功尽弃。

追问

  • 流式上传为什么省内存?答:按块读取发送,不整文件驻留。
  • 发送阶段超时叫什么?答:连接/写阶段等待,需在超时参数里覆盖。
  • 大文件上传更稳的方案?答:分片上传、断点续传,由服务端配合。

04.7.20.1-024 请求与响应 body 的内存边界怎么估算?

一句话结论

同步下载默认把整个响应体读进内存,内存占用 ≈ 响应体大小;流式处理后内存 ≈ 块大小 × 缓冲区。服务端接口应限制可下载体积,客户端也要按“最大响应大小”设计接收与超时策略。

概念解释

  • response.content:完整 body 的字节串,大响应直接放大堆内存。
  • 流式迭代:iter_content 块大小可控,配合落盘避免堆积。
  • 并发场景下内存 = 单连接 body 占用 × 并发数,相乘后才是峰值。

原理流程

  1. 判断响应是否可能很大(文件下载、分页报表、日志导出)。
  2. 大 body 强制 stream=True,按块写入目标。
  3. 按并发数估算峰值内存,设上限保护进程。
  4. 服务端对响应体积做分页或压缩,避免无界返回。

代码或图示

内存峰值 ≈ 单请求 body 大小 × 并发连接数
流式后 ≈ 块大小 × 并发连接数

常见误区

  • 只看单次响应大小,不乘并发数:批量拉取时内存翻倍上涨。
  • 接口不做大小限制:恶意大响应可以打垮客户端进程。
  • 解压后体积膨胀:压缩包很小但解压后巨大,需按解压后估算。

追问

  • 默认下载 body 放哪?答:response.content,整段进入内存。
  • 流式后内存由什么决定?答:块大小与并发连接数。
  • 服务端怎么防大响应?答:分页、大小上限、压缩与流式导出。

04.7.20.1-025 httpx 同步与异步 API 如何划分?

一句话结论

httpx 提供 Client(同步)与 AsyncClient(异步)两套对等 API:方法名与参数基本一致,同步用 with Client() as c:,异步用 async with AsyncClient() as c: 并 await 请求方法;同一代码路径不要混用同步客户端与事件循环。

概念解释

  • 双 API 设计:业务可以从同步逐步迁移到异步,接口形态一致。
  • 异步客户端方法是协程,必须 await;同步客户端方法阻塞执行。
  • 底层传输层不同:同步走线程/阻塞 IO,异步走事件循环与非阻塞 IO。

原理流程

  1. 按运行环境选择 Client 或 AsyncClient。
  2. 客户端在上下文管理器中创建,复用连接池。
  3. 调用对应请求方法,异步版本加 await。
  4. 退出上下文时关闭连接池,释放底层资源。

代码或图示

import httpx

# 同步
with httpx.Client(timeout=5) as client:
    r = client.get("https://example.com")

# 异步
import asyncio

async def main():
    async with httpx.AsyncClient(timeout=5) as client:
        r = await client.get("https://example.com")

asyncio.run(main())

常见误区

  • 在 async 函数里用同步 Client:阻塞事件循环,并发能力丧失。
  • 忘记 await 异步请求方法:拿到协程对象而非响应。
  • 每次请求新建客户端:丢失连接复用,握手开销翻倍。

追问

  • 两套客户端 API 差异大吗?答:方法名与参数基本对等,异步需 await。
  • 异步客户端为什么必须上下文管理?答:退出时关闭连接池与传输层。
  • 同步客户端能跑在 async loop 里吗?答:会阻塞 loop,应换 AsyncClient。

04.7.20.1-026 AsyncClient 生命周期与连接复用怎么管理?

一句话结论

AsyncClient 应在应用生命周期内创建一次并复用,用 async with 或在启动/关闭钩子中 aclose();内部连接池随客户端存活,反复创建会反复握手,客户端未关闭则连接与事件循环资源泄漏。

概念解释

  • 长生命周期客户端:池内 keep-alive 连接被多次请求复用。
  • 与事件循环绑定:异步客户端的连接属于创建它的 loop,不能跨 loop 传递。
  • Web 框架中通常在 lifespan 启动时创建,关闭时 aclose()。

原理流程

  1. 应用启动阶段创建 AsyncClient,配置超时与连接池。
  2. 各请求复用同一客户端,走池内连接。
  3. 事件循环停止前调用 aclose() 关闭连接池。
  4. 上下文管理器退出时自动执行关闭。

代码或图示

import httpx, asyncio

async def main():
    async with httpx.AsyncClient() as client:
        r1 = await client.get("https://example.com/a")
        r2 = await client.get("https://example.com/b")

常见误区

  • 请求函数内每次 AsyncClient():连接不复用,且产生未关闭警告。
  • 客户端实例跨事件循环复用:底层连接归属旧 loop,行为未定义。
  • 进程退出不显式关闭:可能看到未关闭连接的资源警告。

追问

  • 客户端什么时候创建一次?答:应用启动后、请求处理前,全局或按模块复用。
  • AsyncClient 能跨 loop 用吗?答:不能,连接绑定创建时的事件循环。
  • 如何显式关闭?答:await client.aclose(),或用 async with。

04.7.20.1-027 Limits 连接池参数有哪些?

一句话结论

httpx.Limits(max_connections=100, max_keepalive_connections=20, keepalive_expiry=5) 分别限制总并发连接数、空闲保活连接数与保活时长;参数语义与 urllib3 池对应,异步场景下池大小直接决定并发上限。

概念解释

  • max_connections:同一客户端允许的最大并发连接。
  • max_keepalive_connections:空闲后保留的 keep-alive 连接上限,应 ≤ 总上限。
  • keepalive_expiry:空闲连接保留秒数,超时关闭避免半开连接。

原理流程

  1. 创建客户端时传入 limits=Limits(...)。
  2. 新请求按池参数取/建连接,并发不超过 max_connections。
  3. 空闲连接按 keepalive_expiry 超时回收。
  4. 池满时新请求等待连接归还,受超时对象的 pool 超时约束。

代码或图示

import httpx

limits = httpx.Limits(max_connections=50, max_keepalive_connections=10, keepalive_expiry=10)
client = httpx.Client(limits=limits, timeout=5)

常见误区

  • max_keepalive_connections 大于 max_connections:配置矛盾,保活数被总上限约束。
  • 池大小不评估下游容量:并发连接压垮对端。
  • 忽略 pool 超时:池满时等待连接也可能无限阻塞。

追问

  • max_connections 控制什么?答:客户端最大并发连接数。
  • keepalive_expiry 作用?答:空闲连接保留时长,超时关闭。
  • 池满等待受哪个超时约束?答:超时对象的 pool 字段。

04.7.20.1-028 HTTP/2 如何启用,依赖什么?

一句话结论

httpx 默认走 HTTP/1.1,启用 HTTP/2 需要创建客户端时传 http2=True,并额外安装 h2 依赖;服务端必须也支持 HTTP/2,协商失败会回退,客户端代码不需要为协议版本改业务调用。

概念解释

  • HTTP/2:单连接多路复用、头部压缩,适合高并发多请求场景。
  • 依赖:h2 包提供 HTTP/2 协议实现,未安装时 http2=True 会报错或不可用(待确认:验证点:未装 h2 时的具体行为是抛错还是静默回退)。
  • 浏览器/网关链路是否 h2 取决于整条链路,客户端启用只保证到下一跳。

原理流程

  1. 安装 h2,客户端配置 http2=True。
  2. TLS 握手时 ALPN 协商协议版本。
  3. 服务端支持则升级到 HTTP/2,多路复用同一连接。
  4. 不支持则按协商结果回退到 HTTP/1.1。

代码或图示

# 安装依赖:pip install h2
import httpx

client = httpx.Client(http2=True, timeout=5)
r = client.get("https://example.com")
print(r.http_version)  # 协商结果,如 HTTP/2

常见误区

  • 只开 http2=True 不装 h2:协议实现缺失,无法建立 h2 连接。
  • 以为开了 h2 所有请求都 h2:仍需服务端与中间链路支持。
  • 用 h2 长连接承载大文件:h2 单流被慢响应阻塞,多路复用收益受限。

追问

  • h2 依赖哪个包?答:h2,需单独安装。
  • 怎么看实际协商版本?答:响应对象的 http_version 属性。
  • 服务端不支持会怎样?答:ALPN 协商后回退到 HTTP/1.1。

04.7.20.1-029 httpx 超时对象如何分级?

一句话结论

httpx.Timeout(connect=..., read=..., write=..., pool=...) 分别控制连接建立、读取、写入与等待池内连接的超时;传单个数值 timeout=5 是四项统一取值,默认客户端超时为 5 秒(待确认:验证点:当前版本默认超时数值)。

概念解释

  • connect:建连握手等待。
  • read/write:已建连后读写等待。
  • pool:从连接池等待可用连接的时间,池拥塞时生效。

原理流程

  1. 构造 Timeout 对象或直接传数值。
  2. 各阶段等待超过对应字段即抛 httpx.ConnectTimeout/ReadTimeout/WriteTimeout/PoolTimeout。
  3. 业务按异常类型区分建连失败、读写停滞与池拥塞。
  4. 超时对象可在客户端默认值与单次请求参数上覆盖。

代码或图示

import httpx

timeout = httpx.Timeout(connect=3, read=10, write=10, pool=5)
client = httpx.Client(timeout=timeout)

# 单次覆盖
r = client.get("https://example.com", timeout=httpx.Timeout(connect=2, read=8))

常见误区

  • 只设 read 不设 pool:池满等待仍可能拖长。
  • 用总耗时理解分段超时:各阶段独立计时,不是请求上限。
  • 异步下省略超时:协程挂起同样堆积,只是表现为任务队列变长。

追问

  • pool 超时什么时候触发?答:池满,等待连接归还超过 pool 上限。
  • 单个 timeout 值代表什么?答:四项统一取值。
  • 超时异常分哪几类?答:Connect/Read/Write/Pool 四种超时。

04.7.20.1-030 httpx 与 requests 的 API 有哪些差异?

一句话结论

两者请求方法、response.json()、头/Cookie 访问大体一致;差异集中在:httpx 原生异步、超时对象分级、HTTP/2 支持、response.url 是 URL 对象,以及部分行为(如默认环境变量信任、重定向处理细节)需要对照文档,迁移时不要假设 100% 等价。

概念解释

  • 共性:get/post/put/delete、headers、cookies、status_code、text/content。
  • 差异:httpx 客户端需显式创建并关闭;超时用 Timeout 对象;URL 不可变对象。
  • 测试替换:httpx 提供 MockTransport,便于不打真实网络。

原理流程

  1. 迁移时先核对同步客户端调用方式与返回类型。
  2. 异步路径改用 AsyncClient 并补 await。
  3. 检查超时、代理、证书等参数写法差异。
  4. 用传输层 mock 做回归测试,确认响应解析一致。

代码或图示

import httpx

with httpx.Client() as c:
    r = c.get("https://example.com")
    r.json()
    str(r.url)

常见误区

  • 认为 requests 代码可以无改动跑在 httpx:个别参数与默认行为不同。
  • 直接复用 requests 的 Session 概念:httpx 客户端模型更接近 Client 实例。
  • 忽略版本差异:httpx 0.27+ 的参数与行为以当前文档为准。

追问

  • 两者最核心的能力差异?答:httpx 原生异步、HTTP/2、分级超时对象。
  • httpx 怎么做网络隔离测试?答:注入 MockTransport 或自定义 transport。
  • 迁移时先核对什么?答:超时、代理、证书、URL 类型等参数与默认行为。

04.7.20.1-031 httpx 流式响应怎么读?

一句话结论

httpx 用 client.stream("GET", url) 进入流式上下文,响应体通过 response.iter_bytes()/iter_text()/iter_lines() 分块读取;与 requests 一样,流式响应必须在上下文内处理完,避免 body 未读完导致连接无法复用。

概念解释

  • stream() 上下文管理器:退出时保证响应与连接被正确释放。
  • 迭代器按块产出,内存占用与块大小相关。
  • 需要先取响应头(状态码、Content-Length)再决定是否下载。

原理流程

  1. 进入 async with client.stream(...) 或同步 with client.stream(...)。
  2. 检查状态码与响应头。
  3. 调用 iter_bytes 分块写入文件或转发。
  4. 退出上下文时关闭 body,连接归还池中。

代码或图示

import httpx

with httpx.Client() as client:
    with client.stream("GET", "https://example.com/big.iso") as r:
        r.raise_for_status()
        with open("big.iso", "wb") as f:
            for chunk in r.iter_bytes(1024 * 1024):
                f.write(chunk)

常见误区

  • 流式上下文里提前 return:body 未读完,连接不能复用。
  • 用 r.text 读大响应:整段进内存,流式失去意义。
  • 异步版本忘记 async with/async for:协程未正确挂起。

追问

  • 流式迭代器有哪几种?答:iter_bytes、iter_text、iter_lines。
  • body 不读完会怎样?答:连接无法归还复用,可能泄漏。
  • 怎么先看头再决定下载?答:stream 上下文里先读 status 与 headers。

04.7.20.1-032 mounts、代理与 verify 怎么配置?

一句话结论

httpx 用 mounts={前缀: 客户端/传输} 按 URL 前缀分流连接池与配置,proxy= 配置代理,verify= 控制证书校验(True/False/CA 路径);不同目标环境(内网、外网、mock)可以挂不同传输,而不改动业务调用。

概念解释

  • mounts:为特定前缀单独设置连接池、超时或传输,例如内网走直连、外网走代理。
  • proxy:支持 HTTP 代理与环境变量代理,语义与 requests 对应。
  • verify:证书校验开关或自定义 CA 路径,生产不应关闭。

原理流程

  1. 构造客户端时传入 mounts/proxy/verify。
  2. 请求 URL 按前缀匹配对应 mount 配置。
  3. TLS 阶段按 verify 配置校验证书链。
  4. 不匹配前缀的请求走默认客户端配置。

代码或图示

import httpx

client = httpx.Client(
    verify="/etc/ssl/internal-ca.pem",
    proxy="http://proxy.example.com:8080",
    mounts={
        "https://internal.example.com": httpx.Client(verify=True),
    },
    timeout=5,
)

常见误区

  • 混用 proxy 与 mounts 不清楚优先级:前缀 mount 覆盖默认代理设置。
  • 生产 verify=False:中间人风险同 requests 场景。
  • 给内网地址也走外网代理:增加一跳延迟与失败点。

追问

  • mounts 解决什么问题?答:按前缀差异化连接池、代理与传输配置。
  • verify 可传什么?答:布尔值或本地 CA 证书路径。
  • 代理支持环境变量吗?答:支持,显式参数优先(待确认:验证点:当前版本环境变量信任规则)。

04.7.20.1-033 httpx 传输层怎么做测试替换?

一句话结论

httpx 把网络发送抽象为 transport,测试时注入 MockTransport 或自定义 transport 返回固定响应,业务代码不打真实网络;这比 monkeypatch 请求方法更稳定,也能覆盖超时、错误响应等分支。

概念解释

  • MockTransport(handler=...):handler 接收请求实例,返回 httpx.Response。
  • 自定义 transport:实现 handle_request/handle_async_request 协议。
  • 客户端通过 transport= 参数接收替换对象,生产环境默认走网络传输。

原理流程

  1. 测试里构造 handler,按 URL 返回预设状态码与 body。
  2. 创建客户端时传入 transport=MockTransport(handler)。
  3. 业务调用客户端方法,响应来自 mock 而非网络。
  4. 断言请求方法、URL、头与发出的 body。

代码或图示

import httpx

def handler(request: httpx.Request) -> httpx.Response:
    return httpx.Response(200, json={"ok": True})

client = httpx.Client(transport=httpx.MockTransport(handler))
r = client.get("https://example.com/api")

常见误区

  • 在测试里 patch 全局 requests.get:漏改路径仍会打网络。
  • mock 只返回成功分支:超时、5xx、连接错误分支没覆盖。
  • 断言只看响应不看请求:发出的参数错误无法发现。

追问

  • MockTransport 怎么构造响应?答:handler 返回 httpx.Response 实例。
  • 自定义 transport 要实现什么?答:同步/异步请求处理方法(待确认:验证点:当前版本 transport 协议方法名)。
  • 测试能模拟超时吗?答:handler 抛对应超时异常或返回延迟响应。

04.7.20.1-034 aiohttp ClientSession 的连接复用模型是什么?

一句话结论

aiohttp.ClientSession 是异步 HTTP 客户端的主入口,内部通过 TCPConnector 维护连接池,同主机 keep-alive 连接在多次请求间复用;Session 应在应用生命周期内创建一次,并发请求由事件循环调度,连接由 connector 分配与回收。

概念解释

  • Session 持有 connector、cookie jar、默认头与中间件钩子。
  • 连接复用:与 urllib3 池模型类似,但跑在异步非阻塞 IO 上。
  • Session 不是线程/协程局部对象,而是与事件循环绑定的长生命周期对象。

原理流程

  1. 应用启动时创建 ClientSession(connector=...)。
  2. 并发请求经 Session 提交,connector 从池中取/建连接。
  3. 响应返回后连接归还池,保持 keep-alive。
  4. 关闭应用时 await session.close() 释放连接。

代码或图示

import aiohttp, asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get("https://example.com/a") as r1:
            await r1.text()
        async with session.get("https://example.com/b") as r2:
            await r2.text()

asyncio.run(main())

常见误区

  • 每请求新建 Session:连接不复用,且容易出现 loop 绑定问题。
  • 响应不用 async with 或不释放:连接占用不归还。
  • 在多线程里共享同一 Session:aiohttp 会话设计为单事件循环使用。

追问

  • 连接池由谁管理?答:传入 Session 的 TCPConnector。
  • Session 什么时候关闭?答:应用退出前 await close(),或用 async with。
  • 一个 Session 能跨事件循环吗?答:不能,绑定创建时的 loop。

04.7.20.1-035 TCPConnector 的并发上限参数有哪些?

一句话结论

TCPConnector(limit=100, limit_per_host=0, ttl_dns_cache=...) 控制总并发连接数、单主机连接上限与 DNS 缓存时长;limit_per_host=0 表示不按主机限制,只受总 limit 约束,异步并发峰值由这两个参数兜底。

概念解释

  • limit:整个 connector 同时打开的最大连接数。
  • limit_per_host:单个目标主机的最大连接数,防止下游被单一调用方打满。
  • DNS 缓存:减少重复 DNS 查询,ttl 内复用解析结果。

原理流程

  1. 创建 connector 时设定总与单主机上限。
  2. 新请求取连接时先检查是否触达上限。
  3. 触达则等待连接归还,或受客户端超时约束。
  4. DNS 结果按 ttl 缓存,过期重新解析。

代码或图示

import aiohttp

connector = aiohttp.TCPConnector(limit=50, limit_per_host=10, ttl_dns_cache=300)
session = aiohttp.ClientSession(connector=connector)

常见误区

  • 只设总 limit 不设 per_host:某一下游占用全部连接,其他请求排队。
  • 并发量超过 limit 不做排队控制:协程大量等待,内存与延迟上涨。
  • 连接器随 Session 反复新建:池状态全部丢失。

追问

  • limit 与 limit_per_host 区别?答:总连接上限 vs 单主机上限。
  • limit_per_host=0 是什么含义?答:不按主机限制。
  • DNS 缓存由哪个参数控制?答:ttl_dns_cache,单位秒。

04.7.20.1-036 ClientSession 与事件循环绑定有什么坑?

一句话结论

ClientSession 在创建时绑定当前运行的事件循环,连接、cookie 与内部状态都归该 loop;把 Session 拿到另一个 loop 或在线程间复用,会出现“Session is bound to a different event loop”类错误或未定义行为。

概念解释

  • 异步对象(连接、信号量、队列)内部使用 loop 原语,跨 loop 无法安全共享。
  • 测试里反复 asyncio.run 会创建新 loop,复用旧 Session 必报错。
  • 正确做法:一个应用进程内一个 loop,Session 随 loop 创建与关闭。

原理流程

  1. Session 创建时记录当前 loop 引用。
  2. 后续协程在同一 loop 上调度,复用连接与状态。
  3. 切换 loop 后内部原语归属不匹配,抛出绑定错误。
  4. 需要隔离时按 loop 创建独立 Session,结束后关闭。

代码或图示

import aiohttp, asyncio

async def make_session():
    return aiohttp.ClientSession()

async def main():
    session = await make_session()
    await session.get("https://example.com")
    await session.close()

asyncio.run(main())

常见误区

  • 模块级全局 Session 在导入时创建:没有运行中的 loop,绑定时机错误。
  • 在线程池任务里复用主 loop 的 Session:跨线程调度冲突。
  • 关闭后复用 Session:内部连接已释放,行为异常。

追问

  • 跨 loop 复用会报什么?答:事件循环绑定不一致类错误(待确认:验证点:当前版本异常类名与提示文本)。
  • 模块级 Session 为什么危险?答:导入时没有 loop,创建时机错误。
  • 多隔离场景怎么做?答:每个 loop 独立 Session,用完关闭。

04.7.20.1-037 aiohttp 超时与流式读取怎么配置?

一句话结论

aiohttp 用 ClientTimeout(total=..., connect=..., sock_read=..., sock_connect=...) 分级控制超时;响应体通过 resp.text()/resp.read()/resp.content.iter_chunked() 读取,大文件用分块迭代避免整段进内存。

概念解释

  • total:整体最长耗时;connect/sock_connect:建连;sock_read:两次读取间隔。
  • resp.content 是流式读取对象,iter_chunked 按块产出字节。
  • 响应未释放时连接不归还,异常路径要确保关闭。

原理流程

  1. 创建 Session 时传入 timeout=ClientTimeout(...),或单次请求覆盖。
  2. 请求建立后按各阶段超时等待。
  3. 大 body 用 iter_chunked 分块落盘。
  4. 响应上下文退出后连接归还 connector 池。

代码或图示

import aiohttp, asyncio

timeout = aiohttp.ClientTimeout(total=30, connect=5, sock_read=10)

async def download(session, url):
    async with session.get(url, timeout=timeout) as resp:
        with open("big.iso", "wb") as f:
            async for chunk in resp.content.iter_chunked(1024 * 1024):
                f.write(chunk)

常见误区

  • 只设 total 不设读超时:慢速连接可以拖到整体超时才退出。
  • resp.read() 读大文件:整段 body 进内存。
  • 超时配置只在 Session 设,单次慢请求无法收紧覆盖。

追问

  • ClientTimeout 分哪些字段?答:total、connect/sock_connect、sock_read(待确认:验证点:字段命名与默认值)。
  • 分块迭代用什么方法?答:resp.content.iter_chunked(块大小)。
  • 响应不关闭有什么后果?答:连接不归还,池逐步耗尽。

04.7.20.1-038 aiohttp 与 httpx 异步客户端怎么选?

一句话结论

两者都是成熟异步 HTTP 客户端:httpx API 与 requests 对齐、同步/异步双栈、内置 HTTP/2 与 mock 传输,适合新服务与测试友好场景;aiohttp 生态更早、连接器配置细、常与 aiohttp 服务端配套,适合已有该栈的项目。选型看团队熟悉度、协议需求与测试方式,不要为单一功能换栈。

概念解释

  • httpx:双 API、分级超时、MockTransport、HTTP/2,异步体验统一。
  • aiohttp:客户端与服务端同生态,connector 粒度细,社区案例多。
  • 两者都需要长生命周期 Session/Client 与显式超时。

原理流程

  1. 列出需求:同步兼容、HTTP/2、代理、流式、测试 mock、服务端配套。
  2. 对照两库能力与团队既有经验。
  3. 小范围验证连接复用、超时与错误分支行为。
  4. 统一封装一层客户端,底层可替换。

代码或图示

需求:异步调用 + 测试隔离 → httpx
需求:与 aiohttp 服务端同栈、细粒度连接器 → aiohttp

常见误区

  • 按“谁性能高”选客户端:差距通常小于下游网络与业务处理,基准测试要按自己场景做。
  • 混用两库的 Session 概念:生命周期与关闭方式不同。
  • 封装层直接暴露底层类型:后续替换成本高,应抽象出方法接口。

追问

  • httpx 相对 aiohttp 的优势?答:双 API、HTTP/2、内置 mock 传输。
  • aiohttp 适合什么存量场景?答:已有 aiohttp 服务端、连接器调优经验的项目。
  • 选型前必须验证什么?答:连接复用、超时行为、错误分支与自己场景的吞吐。

04.7.20.1-039 标准 json 与 orjson/ujson/msgspec 性能与兼容差异是什么?

一句话结论

标准库 json 兼容性最好、零依赖;orjson/ujson 用 C/Rust 实现提速序列化与反序列化;msgspec 偏向 schema 化二进制编码(msgpack 风格)。性能排序在不同负载下会变,选型先看类型兼容、输出格式与依赖约束,而不是只看 benchmarks。

概念解释

  • 标准 json:纯 Python 实现,支持类型最全,无额外依赖。
  • orjson:Rust 实现,返回 bytes,速度快,但部分 Python 类型需显式处理。
  • ujson:C 实现,轻量快,类型保真度与边界行为弱于标准库。
  • msgspec:用 Struct 定义 schema,编码为紧凑二进制,解码直接成对象。

原理流程

  1. 按接口对外格式选:对外 JSON 用 json/orjson/ujson;内部高性能通信可用 msgspec。
  2. 压测序列化/反序列化耗时与内存占用。
  3. 核对边界类型:日期、Decimal、字节、自定义类、NaN。
  4. 保留标准库作为兜底实现,方便回退。

代码或图示

import json, orjson, msgspec

data = {"name": "Ann", "tags": ["backend", "python"]}

json.dumps(data)                 # str
orjson.dumps(data)              # bytes
msgspec.encode(data)            # 二进制

常见误区

  • 只看序列化速度:反序列化、内存占用与类型校验同样要测。
  • 把 ujson 当标准 json 等价替换:边界类型可能丢精度或抛错。
  • 内部通信选 JSON 而忽略二进制 schema 方案:高频大消息有优化空间。

追问

  • orjson 输出类型是什么?答:bytes,使用前按需 decode。
  • msgspec 编码格式?答:基于 msgpack 风格的二进制,配合 Struct schema。
  • 什么时候保留标准 json?答:类型兼容要求高、依赖受限或作为兜底。

04.7.20.1-040 orjson 有哪些输出与类型限制?

一句话结论

orjson 默认输出 UTF-8 字节串,速度快且不转义非 ASCII;它对可序列化类型有严格要求:日期/时间、UUID、字节等有专门支持,但自定义类、部分嵌套类型需要实现 default 回调,遇到不支持类型会抛 TypeError,而不是静默降级。

概念解释

  • 输出 bytes:与标准库返回 str 不同,HTTP 响应可直接写入字节。
  • 原生支持:datetime/date/time、UUID、bytes/bytearray、numpy 标量(待确认:验证点:当前版本支持的 numpy 类型范围)。
  • default= 回调处理自定义对象,类似标准库的 default。

原理流程

  1. 传入 dict/list 等原生结构或已标注类型对象。
  2. orjson 按类型规则编码,不支持类型交给 default。
  3. 输出字节串,需要文本时 .decode("utf-8")。
  4. 反序列化 orjson.loads 接受 bytes/str/bytearray。

代码或图示

import orjson
from datetime import datetime

payload = {"ts": datetime(2026, 11, 19), "tags": ["a", "b"]}
raw = orjson.dumps(payload)  # bytes
obj = orjson.loads(raw)

常见误区

  • 拿 orjson 结果当 str 直接拼接:类型是 bytes,混用会报错。
  • 自定义 dataclass 直接序列化:需配 default 或转 dict。
  • 假设与标准库输出逐字节一致:空白、转义、类型表示可能不同。

追问

  • orjson 为什么返回 bytes?答:避免二次编码,便于直接写响应体。
  • 不支持类型怎么处理?答:传 default 回调转换为原生类型。
  • 反序列化接受什么输入?答:bytes、str、bytearray 等。

04.7.20.1-041 ujson 有哪些兼容性坑?

一句话结论

ujson 以 C 实现换取速度,但在数值精度、嵌套深度、类型转换上与标准库 json 不完全等价:超大整数、浮点表示、特殊类型可能被截断或转成其他形式,替换前必须用边界用例比对,不能只跑 happy path。

概念解释

  • 数值保真:大整数、极小/极大浮点的字符串表示可能与标准库不同。
  • 类型宽松:某些非原生类型可能被强制转换,而标准库抛 TypeError。
  • 嵌套深度与长度限制:极端结构下行为与标准库有差异(待确认:验证点:当前版本的深度/长度限制阈值)。

原理流程

  1. 用标准库与 ujson 分别序列化同一组边界数据。
  2. 比对输出文本、反序列化结果与类型。
  3. 记录不一致的类型与数值范围。
  4. 对外接口保持标准库行为,内部热点路径再评估 ujson。

代码或图示

import json, ujson

data = {"big": 10**40, "flag": None, "ratio": 0.1}
json.dumps(data)
ujson.dumps(data)  # 边界数值表示需逐项核对

常见误区

  • 全局替换 json = ujson:测试只覆盖普通字符串数字,边界问题上线后暴露。
  • 依赖 ujson 抛出的异常类型做分支:异常类型与标准库不一致。
  • 把 ujson 输出发给严格 JSON 解析器:非标准表示可能被对端拒绝。

追问

  • ujson 主要风险在哪?答:数值与类型保真度弱于标准库。
  • 替换前要做什么?答:边界用例双实现比对输出与反序列化结果。
  • 什么场景不建议用 ujson?答:对外契约严格、数值精度敏感的接口。

04.7.20.1-042 msgspec 的 schema 化编码模型是什么?

一句话结论

msgspec 用 Python 类(Struct)声明字段与类型,encode/decode 在 schema 约束下完成二进制编码与对象还原;相比动态 dict 序列化,它在解码时即做类型检查,编码紧凑、速度快,适合内部高频 RPC 与消息队列载荷。

概念解释

  • Struct:字段带类型注解,可设默认值、可选字段。
  • 编码格式:msgpack 风格二进制,不是可读 JSON。
  • 性能来源:C 扩展 + 静态 schema,减少运行时类型探测。

原理流程

  1. 定义继承 msgspec.Struct 的消息结构。
  2. msgspec.encode(msg) 生成二进制,msgspec.decode(raw, Msg) 还原对象。
  3. 字段类型不符在解码阶段报错。
  4. 跨语言需配合对应 schema 或生成代码,不能只靠 Python 类。

代码或图示

import msgspec

class Order(msgspec.Struct):
    order_id: str
    amount: int
    tags: list[str] = []

raw = msgspec.encode(Order("O-1", 100))
order = msgspec.decode(raw, Order)

常见误区

  • 把 msgspec 当 JSON 替代品对外暴露:二进制格式对浏览器/外部调用方不友好。
  • 字段演进不做兼容:新增必填字段会让旧消息解码失败。
  • 忽略跨语言 schema:其他语言消费消息需要对应定义。

追问

  • msgspec 解码时做什么?答:按 Struct 类型检查字段并还原对象。
  • 编码是文本还是二进制?答:msgpack 风格二进制。
  • 字段变更怎么保证兼容?答:新字段给默认值,避免破坏旧消息。

04.7.20.1-043 pickle 反序列化的安全边界在哪里?

一句话结论

pickle 只能反序列化完全可信的数据:解析过程会执行数据中携带的构造指令(__reduce__),不可信输入可触发任意代码执行。跨服务、跨语言、来自用户/消息队列/缓存的外部数据,禁止用 pickle,应改用 JSON、msgpack、protobuf 等数据格式。

概念解释

  • pickle 是 Python 对象序列化协议,不是纯数据格式;载荷里可以包含可执行逻辑。
  • 历史漏洞多通过构造恶意 pickle 触发 __reduce__ 调用危险函数。
  • 即使加签名也不能把 pickle 变成安全格式:签名只防篡改,不防恶意构造。

原理流程

  1. 不可信字节流进入 pickle.loads。
  2. 解析器按协议重建对象,执行 __reduce__ 指定的调用。
  3. 恶意载荷借此执行系统命令或加载危险类。
  4. 安全边界:数据源必须是自己写入、未被篡改的内部存储。

代码或图示

import pickle

# 禁止:加载来自网络、用户、消息队列、第三方缓存的数据
# obj = pickle.loads(untrusted_bytes)

# 可信内部缓存场景也应评估替代方案

常见误区

  • 给 pickle 加密/签名就对外使用:加密不改变可执行指令本质。
  • 用 pickle 存跨语言消息:其他语言无法解析 Python 对象协议。
  • 认为“数据不大就安全”:载荷大小与可执行风险无关。

追问

  • pickle 为什么危险?答:反序列化会执行载荷中的构造指令,可任意代码执行。
  • 哪些数据不能 pickle 加载?答:网络、用户、MQ、第三方缓存等不可信来源。
  • 替代格式有哪些?答:JSON、msgpack、protobuf、msgspec 等纯数据格式。

04.7.20.1-044 pickle 协议版本与跨语言限制是什么?

一句话结论

pickle 协议版本由 protocol= 指定,高版本支持更多内建类型与更紧凑编码,但新旧 Python 版本之间要注意兼容;pickle 绑定 Python 对象模型,其他语言无法直接读取,也不适合作为长期存储格式,类结构变更后旧字节可能无法还原。

概念解释

  • 协议版本:低版本兼容性好,高版本编码效率与类型支持更强(待确认:验证点:当前 Python 版本默认协议号)。
  • 类引用:pickle 记录模块与类名,类被移动/删除后旧数据加载失败。
  • 长期存储:结构演进、依赖变更都会破坏可还原能力。

原理流程

  1. 序列化时按协议号写入对象状态与类引用。
  2. 反序列化时按引用找到类,重建实例。
  3. 类路径变更或协议不匹配时抛出异常。
  4. 跨语言/长期持久化场景改用版本化数据格式。

代码或图示

import pickle

raw = pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
# 加载方 Python 版本与类结构必须匹配

常见误区

  • 把 pickle 文件当长期归档:类改名/重构后无法读取。
  • 不同 Python 大版本混用高协议:旧版本可能不识别。
  • 在缓存里存 pickle 对象:缓存被污染后同样触发反序列化风险。

追问

  • pickle 能被其他语言解析吗?答:不能直接解析 Python 对象协议。
  • 类改名后旧 pickle 怎样?答:按引用找不到类,加载失败。
  • 高协议版本一定更好吗?答:编码更紧凑,但要兼顾加载方版本兼容。

04.7.20.1-045 ensure_ascii 与中文编码怎么处理?

一句话结论

标准库 json.dumps(..., ensure_ascii=False) 直接输出 UTF-8 中文,默认 ensure_ascii=True 会把非 ASCII 转成 \uXXXX 转义;对外接口用 UTF-8 编码时通常关闭转义以减小体积,日志/调试保留转义也可,关键是编码在生成与消费两端一致。

概念解释

  • ensure_ascii=True:输出纯 ASCII,非 ASCII 转义,兼容性最广但体积大。
  • ensure_ascii=False:保留 UTF-8 字符,体积小,需要下游按 UTF-8 解码。
  • 序列化结果是 str,写入响应/文件时再指定编码。

原理流程

  1. 确定下游编码约定(一般 UTF-8)。
  2. 选择 ensure_ascii 取值,生成 JSON 字符串。
  3. 写入时按 UTF-8 编码为字节,响应头声明 charset=utf-8。
  4. 读取端按同一编码解码再 json.loads。

代码或图示

import json

payload = {"city": "楚雄", "tag": "后端"}
text = json.dumps(payload, ensure_ascii=False)
raw = text.encode("utf-8")

常见误区

  • 序列化用 UTF-8 转义、读取端按 GBK 解码:中文乱码。
  • 把 bytes 直接传给 json.loads:标准库可接受 bytes,但要确认编码。
  • 接口响应头不声明 charset:客户端按默认编码解析出乱码。

追问

  • ensure_ascii=False 省什么?答:减少 \uXXXX 转义体积,保留原字符。
  • 两端编码不一致会怎样?答:中文乱码或解析失败。
  • orjson 默认怎么处理非 ASCII?答:直接输出 UTF-8 字节,不做 ASCII 转义。

04.7.20.1-046 序列化后如何搭配压缩?

一句话结论

文本 JSON 体积大、冗余高,可在序列化后用 gzip/deflate/zstd 压缩传输或落盘;压缩是 CPU 换体积,要在“报文大小、压缩耗时、解压耗时”之间权衡,大消息与高频消息才值得压,小请求压缩收益有限反而增加延迟。

概念解释

  • 压缩层级:级别越高压缩率越好,CPU 耗时越大。
  • 流式压缩:大对象可以边序列化边压缩,避免整段进内存。
  • 传输层压缩(HTTP Content-Encoding)与应用层压缩是两层,不要重复压。

原理流程

  1. 评估消息大小与频率,判断压缩收益。
  2. 序列化得到文本/二进制载荷。
  3. 选择压缩算法与级别,压缩后落盘或发送。
  4. 消费端先解压再反序列化,错误处理区分解压失败与格式错误。

代码或图示

import gzip, json, zstandard as zstd

payload = {"items": list(range(1000))}
raw = json.dumps(payload).encode("utf-8")
compressed = gzip.compress(raw, compresslevel=6)
restored = json.loads(gzip.decompress(compressed))

常见误区

  • 已经在 HTTP 层开 gzip,应用层再压一次:双重压缩浪费 CPU。
  • 小消息强行压缩:压缩头开销抵消收益,延迟上升。
  • 不记录压缩格式:解压端无法选择正确算法。

追问

  • 压缩主要代价是什么?答:CPU 时间,压缩/解压都耗计算。
  • 大对象怎么避免内存峰值?答:边序列化边流式压缩写入。
  • 哪些算法常见?答:gzip、deflate、zstd(待确认:验证点:项目环境可用的算法与依赖)。

04.7.20.1-047 NaN/Infinity 在标准 JSON 里是什么边界?

一句话结论

标准 JSON 规范只允许有限数值,NaN、Infinity、-Infinity 不是合法 JSON 标记;Python 标准库 json 出于兼容会输出这些裸标记,但严格解析器(其他语言、浏览器 JSON.parse)会拒绝,对外接口必须在序列化前把它们转换为 null 或有限值。

概念解释

  • 标准库行为:json.dumps(float("nan")) 输出 NaN,属于 Python 扩展写法。
  • 严格解析:JSON.parse、多数语言 JSON 库遇到裸 NaN 报错。
  • 来源:除法零、缺失计算、浮点溢出、未初始化数值。

原理流程

  1. 序列化前扫描数值字段,识别非有限浮点。
  2. 按业务约定转为 null、0 或显式错误标记。
  3. 输出严格合法 JSON,下游可无歧义解析。
  4. 日志记录非法数值来源,避免掩盖计算问题。

代码或图示

import math, json

def clean(v):
    if isinstance(v, float) and not math.isfinite(v):
        return None
    return v

payload = {"ratio": clean(float("inf"))}
json.dumps(payload, ensure_ascii=False)

常见误区

  • 认为 Python 能 round-trip 就代表 JSON 合法:外部严格解析器不接受。
  • 把 NaN 当 0 静默处理:掩盖了上游计算错误。
  • 接口文档不说明缺失值表示:调用方无法区分 null 与 0。

追问

  • NaN 是合法 JSON 吗?答:不是,标准 JSON 只允许有限数值。
  • 标准库为什么能输出 NaN?答:历史兼容的 Python 扩展写法。
  • 对外接口怎么处理?答:序列化前转 null 或有限值,并记录来源。

04.7.20.1-048 日期时间与 Decimal 怎么序列化?

一句话结论

JSON 没有日期与高精度十进制原生类型,惯例用 ISO 8601 字符串表示时间,Decimal 转字符串或浮点需按精度约定;时间统一存 UTC,展示层再转本地时区,避免序列化端携带歧义时区。

概念解释

  • 时间:datetime.isoformat() 生成 ISO 8601,带时区偏移;naive 时间要先补时区。
  • Decimal:转 str 保留精度,转 float 会引入二进制浮点误差。
  • 下游解析端按格式还原,类型约定写进接口文档。

原理流程

  1. 时间对象转 UTC 并生成 ISO 字符串。
  2. Decimal 按约定序列化为字符串(高精度金额)或数值。
  3. 反序列化时按字段类型还原为 datetime/Decimal。
  4. 跨时区展示在应用层完成,不把本地时间塞进载荷。

代码或图示

from datetime import datetime, timezone
from decimal import Decimal
import json

now = datetime.now(timezone.utc)
amount = Decimal("19.99")

payload = {"ts": now.isoformat(), "amount": str(amount)}
json.dumps(payload, ensure_ascii=False)

常见误区

  • 时间序列化为时间戳又混用字符串:同一字段两种格式,解析端出错。
  • Decimal 转 float 存金额:分位精度丢失。
  • 序列化本地 naive 时间:跨时区接收方无法判断原始时刻。

追问

  • 时间推荐什么格式?答:UTC 的 ISO 8601 字符串。
  • Decimal 为什么用字符串?答:避免 float 二进制误差,保留十进制精度。
  • 时区转换在哪层做?答:展示层,载荷统一 UTC。

04.7.20.1-049 大体积 JSON 怎么流式解析?

一句话结论

整段 json.loads 会把完整对象与字节流同时留在内存,大文件/大响应需要流式解析:按读取位置逐个产出事件或记录(如 JSON 数组逐条对象),解析一条处理一条,内存与文件大小解耦。标准库本身不提供完整流式 API,需借助事件式解析库或分块预处理。

概念解释

  • 整段解析:内存 ≈ 文件大小 × 2(字节 + 对象)。
  • 事件流解析:回调在遇到键、值、数组元素时触发,上层只保留当前记录。
  • 适用场景:日志导出、批量导入、大报表解析。

原理流程

  1. 打开文件/响应流,按块读取。
  2. 流式解析器维护状态机,产出 token 或完整记录。
  3. 上层逐条处理(落库、转换、转发),不保留全量对象。
  4. 处理完一条即释放引用,控制内存峰值。

代码或图示

# 事件式流式解析思路(具体库按环境选型)
# 逐条取出数组中的对象,处理后释放
# with open("big.json", "rb") as f:
#     for record in iter_records(f):
#         process(record)

常见误区

  • 大文件先 read() 再 loads:字节串与对象双重占用内存。
  • 流式解析器状态处理不当:跨块的字符串被截断。
  • 一次性把解析结果收进 list:流式只省了解析中间态,结果堆积仍 OOM。

追问

  • 标准库支持流式解析吗?答:没有完整事件式 API,需选第三方解析库(待确认:验证点:当前环境可用的流式 JSON 库)。
  • 流式后内存由什么决定?答:单条记录大小与并发处理量。
  • 什么数据适合流式?答:大数组日志、批量导入、分页导出。

04.7.20.1-050 字节字段在 JSON 中如何表示?

一句话结论

JSON 没有二进制类型,字节字段通常用 Base64 编码成字符串传输;编码后体积膨胀约三分之一,且两端要约定编码方式。大二进制数据(图片、文件)不应塞进 JSON 载荷,应走对象存储或分片上传,JSON 里只放引用地址。

概念解释

  • Base64:把字节映射为可打印 ASCII,是 JSON 内嵌二进制的通用约定。
  • 体积膨胀:每 3 字节编码为 4 字符,约 +33%。
  • 替代方案:二进制协议(msgpack/protobuf)原生支持 bytes,避免 Base64。

原理流程

  1. 判断字段是否必须内嵌二进制;能给 URL 就给 URL。
  2. 必须内嵌时对字节做 Base64 编码为字符串。
  3. 序列化进 JSON,消费端先 Base64 解码再用字节。
  4. 接口文档标注编码方式与字节长度。

代码或图示

import base64, json

raw = b"\x89PNG\r\n"
payload = {"image_b64": base64.b64encode(raw).decode("ascii")}
text = json.dumps(payload)

decoded = base64.b64decode(json.loads(text)["image_b64"])

常见误区

  • 直接把 bytes 丢给标准 json:抛 TypeError。
  • 大文件 Base64 内嵌:报文膨胀且解析内存高。
  • 两端编码不一致(Base64 变体/URL-safe):解码失败或损坏。

追问

  • JSON 能直接放二进制吗?答:不能,需 Base64 等文本编码。
  • Base64 膨胀多少?答:约三分之一(3 字节变 4 字符)。
  • 大二进制推荐怎么传?答:对象存储/分片上传,JSON 放引用地址。

04.7.20.1-051 如何定位序列化在服务端的 CPU 占比?

一句话结论

先用采样剖析(cProfile/line_profiler 或线上持续剖析)区分时间花在网络等待、业务计算还是 JSON 编解码;序列化热点通常表现为 json.dumps/loads、orjson 编码函数占 CPU 比例高,再结合报文大小与 QPS 估算每秒序列化字节量,决定是否换更快的库或减小载荷。

概念解释

  • 剖析要区分 CPU 时间与 wall time:网络等待不计入 CPU 热点。
  • 大报文 + 高 QPS 是序列化成本放大器:单条耗时 × 并发量。
  • 优化顺序:先减字段/减体积,再换编码库,最后才考虑二进制协议。

原理流程

  1. 在压测或线上采样剖析,按函数聚合 CPU 占比。
  2. 确认编解码函数是否进入热点前列。
  3. 统计平均报文大小、QPS,估算序列化吞吐。
  4. 对比候选库在同等数据上的耗时与内存,小范围灰度验证。

代码或图示

import cProfile, pstats

profiler = cProfile.Profile()
profiler.enable()
# 执行业务请求
profiler.disable()
pstats.Stats(profiler).sort_stats("cumulative").print_stats(20)

常见误区

  • 用单次本地调用判断库快慢:未考虑并发、内存分配与 GC 压力。
  • 只优化序列化不看载荷:冗余字段去掉后编码自然变快。
  • 剖析结果把 IO 等待误判为 CPU 热点:先分离等待与计算。

追问

  • 序列化热点怎么识别?答:编解码函数在 CPU 剖析中占比靠前。
  • 优化顺序是什么?答:减字段减体积 → 换编码库 → 评估二进制协议。
  • 为什么要统计报文大小?答:单条耗时乘大小与 QPS 才是真实成本。

04.7.20.1-052 JSON 缺少 schema 会带来什么问题?

一句话结论

动态 JSON 没有字段类型与必填约束,字段缺失、类型错、命名漂移只能在运行时暴露;接口契约靠文档口头约定,前后端/多语言协作成本高。关键链路应引入 schema 校验(Pydantic/marshmallow)或契约定义,在入口处拒绝不合规数据。

概念解释

  • 无 schema:解析出 dict,取值靠键名约定,错键不报错。
  • 运行时才发现:下游取 data["amount"] 遇到缺失或字符串,异常沿调用链扩散。
  • 契约漂移:字段改名/改类型,调用方与提供方不同步。

原理流程

  1. 入口接收原始 JSON,先按 schema 校验类型与必填。
  2. 校验失败返回明确错误,不进入业务逻辑。
  3. 校验通过后得到类型安全的对象,业务直接使用。
  4. 契约变更通过 schema/接口文档同步给调用方。

代码或图示

# 无 schema:错键、缺字段都要到使用时才爆
data = response.json()
amount = data["amount"]

# 有 schema:入口即校验(示例为思路,具体库见 04.7.20.3)

常见误区

  • 信任内部服务返回:内部接口同样会变更,缺字段会打垮调用方。
  • 在每个取值点重复判空:应在入口统一校验,而不是散落防御。
  • schema 只用于请求不用于响应:下游消费响应同样需要类型保障。

追问

  • 无 schema 最大风险是什么?答:错误延迟到运行时业务路径才暴露。
  • 校验放在哪一层?答:接口入口,解析后、业务处理前。
  • 契约漂移怎么治理?答:schema/接口文档 + 版本化变更通知。

04.7.20.1-053 序列化版本兼容怎么做?

一句话结论

跨版本消息要做到“新增字段可选、删除字段容忍、类型不随意改”:消费端忽略未知字段,生产端不给必填字段强约束;格式本身版本化(schema 版本号、协议字段编号),破坏性变更走新接口或新版本,而不是原地改老契约。

概念解释

  • 向前兼容:新生产端发旧消费端,旧端忽略未知字段。
  • 向后兼容:旧生产端发新消费端,新端对缺失字段给默认值。
  • 破坏性变更:改字段类型、改语义、删除必填字段,需要版本隔离。

原理流程

  1. 定义 schema 时区分必填与可选,新字段一律可选。
  2. 消费端解析时容忍未知字段与缺失可选字段。
  3. 字段语义/类型变更先评估兼容,必要时开新版本。
  4. 消息或接口携带版本标识,便于灰度与回滚。

代码或图示

兼容:新增可选字段、字段改名并存过渡期
破坏:改类型、改语义、删除必填字段 → 新版本/新接口

常见误区

  • 直接在老字段上改类型:旧消费端解析失败。
  • 消费端严格拒绝未知字段:生产端加字段就把旧端打挂。
  • 消息不记版本:出问题无法定位是哪一版契约。

追问

  • 什么是向前/向后兼容?答:新端旧端互发消息都能解析。
  • 新增字段要注意什么?答:设为可选,旧端可忽略。
  • 破坏性变更怎么处理?答:版本隔离,不走原地修改。

04.7.20.1-054 客户端封装应统一哪些横切能力?

一句话结论

内部封装一层 HTTP 客户端,统一超时、连接池、重试与幂等判断、请求/响应日志与指标、错误归一化、认证头注入与代理配置;业务代码只传 URL、参数与业务预期,避免每个调用处重复造轮子并漏配超时。

概念解释

  • 横切能力:与具体业务无关、所有下游调用都需要的策略。
  • 封装边界:底层客户端可替换(requests/httpx/aiohttp),上层方法接口稳定。
  • 可观测性:统一记录耗时、状态码、异常类型、下游标识,便于排障。

原理流程

  1. 初始化长生命周期客户端,配置默认超时与池参数。
  2. 封装 get/post 等方法,注入认证与默认头。
  3. 统一执行重试策略(仅限幂等方法)与异常转换。
  4. 输出结构化日志与指标,业务层处理归一化后的错误类型。

代码或图示

import httpx

class DownstreamClient:
    def __init__(self):
        self._client = httpx.Client(timeout=httpx.Timeout(connect=3, read=10))

    def get(self, url, **kwargs):
        resp = self._client.get(url, **kwargs)
        resp.raise_for_status()
        return resp.json()

常见误区

  • 封装层把底层类型直接暴露:后续换库影响所有调用方。
  • 每个方法各自配超时/重试:策略不一致,漏配一处就出事故。
  • 日志打印完整请求体/凭证:敏感信息泄漏,需脱敏。

追问

  • 封装层必须统一什么?答:超时、连接池、重试、日志指标、认证与错误归一化。
  • 为什么底层要可替换?答:业务接口稳定,库选型可后续调整。
  • 日志要注意什么?答:脱敏凭证与敏感字段,不打印完整载荷。

04.7.20.1-055 HTTP 客户端选型怎么总结?

一句话结论

存量同步栈、简单脚本用 requests;需要异步、HTTP/2、测试 mock 或同步异步统一 API 用 httpx;已有 aiohttp 服务端生态或细粒度连接器调优用 aiohttp。三者共性要求一致:长生命周期复用连接、显式分级超时、按幂等性决定重试、流式处理大响应、生产关闭证书校验。

概念解释

  • requests:生态最广、资料最多,同步场景默认选择。
  • httpx:双 API、异步原生、传输层可替换,新服务优先评估。
  • aiohttp:异步客户端+服务端一体,连接器配置细。
  • 选型不改变工程底线:超时、池、重试、流式、安全校验缺一不可。

原理流程

  1. 按运行模型(同步/异步)与既有栈缩小范围。
  2. 核对协议需求(HTTP/2)、测试方式、代理与证书配置。
  3. 小压测验证连接复用与错误分支行为。
  4. 通过封装层隔离底层,保留后续替换空间。

代码或图示

同步脚本/存量服务 → requests
异步服务、双栈统一、可测试传输 → httpx
aiohttp 同生态、细粒度连接器 → aiohttp

常见误区

  • 追新盲目换库:团队不熟悉、踩坑成本高于收益。
  • 选型后忽略工程配置:换了库仍不设超时,事故照旧。
  • 把客户端库当服务治理:重试/熔断/限流还需要框架或中间件配合。

追问

  • requests 适合什么场景?答:同步脚本、存量服务、生态依赖广的项目。
  • httpx 的核心优势?答:异步原生、双 API、HTTP/2、可替换传输。
  • 无论选哪个都必须做什么?答:复用连接、分级超时、幂等重试、流式与证书校验。

本节高频题

  • requests 默认无超时的危害(001、002)
  • Session 连接复用与 Cookie(003)
  • HTTPAdapter 连接池参数(004)
  • urllib3.Retry 策略与挂载重试(005、006)
  • SSL 校验与异常(007、018)
  • stream=True 与流式下载(008、009、023)
  • 重试的幂等前提(014)
  • 连接池耗尽与调优(015)
  • httpx 同步/异步与生命周期(025、026)
  • Limits 与分级超时(027、029)
  • HTTP/2 启用条件(028)
  • aiohttp 会话与连接器(034、035、036)
  • 序列化库性能与兼容取舍(039、040、041)
  • pickle 安全边界(043、044)
  • NaN/Decimal/时间序列化边界(047、048)
  • 客户端统一封装(054)