加拿大机器人

六、深度对比：关键差异与技术细节

深入理解requests与httpx的技术差异，有助于在实际项目中做出更明智的选择。除了前文提到的异步支持外，两者在超时处理、代理配置、重定向机制等多个方面存在显著区别。

（一）超时处理策略

在超时设置上，两个库的默认行为截然不同，这直接影响了应用的稳定性。

requests的无限等待：requests库默认不设置超时时间，这意味着一个网络请求可能永远等待下去。虽然开发者可以手动设置timeout参数，但忘记设置的情况时有发生，可能导致整个应用因单个请求而阻塞。

import requests
# 默认无超时，可能永久阻塞
response = requests.get('https://example.com')

# 手动设置超时（连接和读取超时均为5秒）
response = requests.get('https://example.com', timeout=5)

# 分别设置连接超时和读取超时
response = requests.get('https://example.com', timeout=(3.05, 27))


httpx的默认超时：httpx默认设置了5秒的超时时间，这种“安全第一”的设计理念防止了因网络问题导致的无限等待。如果需要取消超时限制，必须显式设置timeout=None。

import httpx
# 默认5秒超时
response = httpx.get('https://example.com')

# 取消超时限制
response = httpx.get('https://example.com', timeout=None)

# 精细化超时配置
response = httpx.get('https://example.com', timeout=httpx.Timeout(10.0))


（二）代理配置方式

两个库在代理配置上采用了不同的语法结构，体现了各自的设计理念。

requests的简单代理：requests使用简单的字典结构配置代理，易于理解和使用。

import requests

proxies = {
   'http': 'http://10.10.1.10:3128',
   'https': 'http://10.10.1.10:1080',
}

response = requests.get('https://example.com', proxies=proxies)


httpx的灵活代理：httpx通过mounts参数提供更灵活的代理配置，支持更复杂的路由规则。

import httpx

# 基本代理配置
proxies = {
   'http://': 'http://10.10.1.10:3128',
   'https://': 'http://10.10.1.10:1080',
}

client = httpx.Client(proxies=proxies)

# 高级路由配置
from httpx import AsyncHTTPTransport

transports = {
   'all://': httpx.AsyncHTTPTransport(proxy='http://proxy.example.com'),
   'all://www.example.com': None,  # 排除特定域名
}

client = httpx.AsyncClient(transports=transports)


（三）重定向处理机制

重定向是HTTP请求中的常见场景，两个库的处理方式也有所不同。

requests的自动重定向：requests默认自动跟随重定向，最多允许30次重定向。

import requests

# 默认跟随重定向
response = requests.get('https://example.com/redirect')

# 禁用重定向
response = requests.get('https://example.com/redirect', allow_redirects=False)

# 获取重定向历史
print(response.history)  # 包含所有重定向响应


httpx的显式控制：httpx默认也跟随重定向，但提供了更细粒度的控制选项。

import httpx

# 默认跟随重定向
response = httpx.get('https://example.com/redirect')

# 禁用重定向
response = httpx.get('https://example.com/redirect', follow_redirects=False)

# 自定义最大重定向次数
client = httpx.Client(follow_redirects=True, max_redirects=10)


七、错误处理与异常机制

良好的错误处理机制是网络请求库成熟度的重要标志。requests和httpx都提供了完善的异常体系，但在细节上存在差异。

（一）requests的异常体系

requests定义了多个异常类，覆盖了常见的网络错误场景。

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError

try:
   response = requests.get('https://example.com', timeout=5)
   response.raise_for_status()  # 检查HTTP状态码
except Timeout:
   print("请求超时")
except ConnectionError:
   print("连接错误")
except RequestException as e:
   print(f"请求异常: {e}")
except Exception as e:
   print(f"其他异常: {e}")


（二）httpx的异常体系

httpx的异常体系更加现代化，与Python 3的异常链特性结合更紧密。

import httpx

try:
   response = httpx.get('https://example.com', timeout=5.0)
   response.raise_for_status()
except httpx.TimeoutException:
   print("请求超时")
except httpx.ConnectError:
   print("连接错误")
except httpx.HTTPStatusError as e:
   print(f"HTTP错误: {e.response.status_code}")
except httpx.RequestError as e:
   print(f"请求错误: {e}")


八、流式传输与文件上传

对于大文件上传或下载场景，流式传输能力尤为重要。两个库都支持流式操作，但API设计有所不同。

（一）requests的流式传输

requests使用stream参数控制是否使用流式传输。

import requests

# 流式下载大文件
with requests.get('https://example.com/large-file', stream=True) as r:
   with open('large-file.bin', 'wb') as f:
       for chunk in r.iter_content(chunk_size=8192):
           f.write(chunk)

# 流式上传文件
with open('large-file.bin', 'rb') as f:
   response = requests.post('https://example.com/upload', data=f)


（二）httpx的流式传输

httpx提供了更现代的流式API，支持同步和异步两种模式。

import httpx

# 同步流式下载
with httpx.stream('GET', 'https://example.com/large-file') as response:
   with open('large-file.bin', 'wb') as f:
       for chunk in response.iter_bytes():
           f.write(chunk)

# 异步流式上传
async def upload_large_file():
   async with httpx.AsyncClient() as client:
       async def file_generator():
           with open('large-file.bin', 'rb') as f:
               while chunk := f.read(8192):
                   yield chunk
       
       response = await client.post('https://example.com/upload', content=file_generator())


九、性能优化与最佳实践

在实际生产环境中，正确的配置和使用方式能显著提升网络请求的性能和稳定性。

（一）连接池管理

合理的连接池配置可以大幅减少TCP连接建立的开销。

requests的连接池：requests通过Session对象管理连接池。

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

session = requests.Session()

# 配置重试策略
retry_strategy = Retry(
   total=3,
   backoff_factor=1,
   status_forcelist=[429, 500, 502, 503, 504],
)

adapter = HTTPAdapter(max_retries=retry_strategy, pool_connections=100, pool_maxsize=100)
session.mount('http://', adapter)
session.mount('https://', adapter)

# 复用session发送请求
for _ in range(100):
   response = session.get('https://api.example.com/data')


httpx的连接池：httpx的Client对象提供了更精细的连接池控制。

import httpx

# 创建客户端实例，复用连接
client = httpx.Client(
   limits=httpx.Limits(
       max_connections=100,      # 最大连接数
       max_keepalive_connections=20,  # 最大保持活动连接数
       keepalive_expiry=30.0,    # 连接保持时间（秒）
   ),
   timeout=httpx.Timeout(10.0),  # 全局超时
)

# 批量请求
responses = []
for url in urls:
   response = client.get(url)
   responses.append(response)

# 使用完毕后关闭客户端
client.close()


（二）异步并发控制

httpx的异步特性使其在高并发场景下表现出色，但需要合理控制并发度。

import httpx
import asyncio
from asyncio import Semaphore

async def fetch_with_semaphore(client, url, semaphore):
   async with semaphore:
       try:
           response = await client.get(url, timeout=10.0)
           return response.json()
       except Exception as e:
           print(f"请求失败 {url}: {e}")
           return None

async def main():
   # 限制最大并发数为50
   semaphore = Semaphore(50)
   
   async with httpx.AsyncClient(
       limits=httpx.Limits(max_connections=100),
       timeout=httpx.Timeout(10.0)
   ) as client:
       tasks = [
           fetch_with_semaphore(client, url, semaphore)
           for url in urls
       ]
       
       results = await asyncio.gather(*tasks, return_exceptions=True)
       return results

# 运行异步任务
results = asyncio.run(main())


（三）内存优化策略

对于需要处理大量数据或长时间运行的应用，内存管理尤为重要。

import httpx
import gc

# 使用上下文管理器确保资源释放
async def process_large_dataset(urls):
   results = []
   
   async with httpx.AsyncClient() as client:
       for url in urls:
           # 使用流式响应避免一次性加载大文件到内存
           async with client.stream('GET', url) as response:
               if response.status_code == 200:
                   # 逐块处理数据
                   async for chunk in response.aiter_bytes():
                       processed_chunk = process_chunk(chunk)
                       results.append(processed_chunk)
                   
                   # 定期清理内存
                   if len(results) % 1000 == 0:
                       gc.collect()
   
   return results


十、迁移指南与兼容性处理

从requests迁移到httpx通常很平滑，但仍需注意一些细节差异。

（一）API兼容性检查

大部分requests代码可以直接替换为httpx，但某些API需要调整。

# requests代码
import requests

response = requests.get(
   url='https://api.example.com/data',
   params={'page': 1, 'limit': 20},
   headers={'Authorization': 'Bearer token'},
   cookies={'session': 'abc123'},
   verify=False  # 禁用SSL验证
)

# 对应的httpx代码
import httpx

response = httpx.get(
   url='https://api.example.com/data',
   params={'page': 1, 'limit': 20},
   headers={'Authorization': 'Bearer token'},
   cookies={'session': 'abc123'},
   verify=False  # 注意：httpx中verify接受布尔值或SSLContext
)


（二）常见迁移问题处理

1. 响应对象属性差异

# requests
response = requests.get('https://example.com')
content = response.content
text = response.text
json_data = response.json()

# httpx - 大部分相同，但json()是异步方法
response = httpx.get('https://example.com')
content = response.content
text = response.text
json_data = response.json()  # 同步版本
# 异步版本: json_data = await response.aread().json()


2. 文件上传差异

# requests
files = {'file': open('data.txt', 'rb')}
response = requests.post('https://example.com/upload', files=files)

# httpx - 需要显式关闭文件或使用上下文管理器
with open('data.txt', 'rb') as f:
   files = {'file': f}
   response = httpx.post('https://example.com/upload', files=files)


3. 流式响应处理

# requests
response = requests.get('https://example.com/large', stream=True)
for chunk in response.iter_content(chunk_size=8192):
   process(chunk)

# httpx
response = httpx.get('https://example.com/large', stream=True)
for chunk in response.iter_bytes():
   process(chunk)


（三）渐进式迁移策略

对于大型项目，可以采用渐进式迁移策略：

1. 并行运行：在测试环境中同时运行requests和httpx版本，对比结果

2. 模块化替换：按模块逐步替换，而不是一次性全部迁移

3. 监控对比：在生产环境中监控两个版本的性能指标

4. 回滚准备：准备完善的回滚方案，确保迁移失败时可以快速恢复

十一、总结与展望

requests库作为Python网络请求的经典之作，以其简洁的API和稳定的表现赢得了广大开发者的青睐。然而，在现代应用开发中，随着异步编程的普及和高并发需求的增长，httpx凭借其原生异步支持、HTTP/2协议支持以及更优的性能表现，正逐渐成为新的选择标准。

从技术演进的角度看，httpx代表了Python网络请求库的发展方向：更高效的异步处理、更现代的协议支持、更完善的类型提示。虽然requests在简单场景下依然可靠，但对于需要处理高并发、大数据量或需要与异步框架集成的项目，httpx无疑是更好的选择。

在实际项目中，建议根据具体需求选择合适的库：

• 对于简单的脚本或小型应用，requests依然是最佳选择

• 对于需要高并发处理的Web应用、爬虫或API客户端，httpx的异步特性将带来显著性能提升

• 对于需要HTTP/2支持的应用，httpx是唯一选择

• 对于现有项目迁移，可以采取渐进式策略，逐步替换关键模块

随着Python异步生态的不断完善，httpx的生态也在快速发展。未来，我们可以期待更多基于httpx的工具和框架出现，进一步推动Python网络编程的发展。无论选择哪个库，理解其底层原理和最佳实践，都是写出高质量网络请求代码的关键。