Python Requests库：HTTP请求处理与REST API交互指南

1. Requests库：Python HTTP请求的瑞士军刀

在Python生态系统中，Requests库无疑是处理HTTP请求最受欢迎的第三方库。作为一个从业十年的Python开发者，我可以毫不夸张地说，Requests彻底改变了我们与Web服务交互的方式。相比Python内置的urllib库，Requests提供了更人性化的API设计，让发送HTTP请求变得像写普通Python代码一样自然。

这个库最初由Kenneth Reitz在2011年发布，如今已成为Python Package Index(PyPI)下载量最高的包之一。根据最新统计，Requests的周下载量超过5000万次，这充分说明了它在Python社区中的地位。无论是简单的GET请求获取网页内容，还是复杂的API交互处理JSON数据，Requests都能优雅地完成任务。

提示：如果你还在使用urllib或urllib2处理HTTP请求，现在是时候切换到Requests了。它不仅代码更简洁，错误处理也更完善，还能自动处理连接池和会话保持。

2. 核心功能解析

2.1 基本请求方法

Requests支持所有主要的HTTP方法，包括GET、POST、PUT、DELETE等。让我们看一个最基本的GET请求示例：

python复制import requests

response = requests.get('https://api.github.com/events')
print(response.status_code)  # 200
print(response.text)  # 返回的文本内容

POST请求同样简单，特别是当需要发送表单数据或JSON时：

python复制# 表单数据POST
response = requests.post('https://httpbin.org/post', data={'key': 'value'})

# JSON数据POST
response = requests.post('https://httpbin.org/post', json={'key': 'value'})

2.2 响应处理

Requests的响应对象提供了丰富的方法和属性来处理返回数据：

python复制response = requests.get('https://api.github.com/events')

# 获取响应状态码
print(response.status_code)

# 获取响应头
print(response.headers)

# 获取响应内容(自动解码)
print(response.text)

# 获取二进制响应内容
print(response.content)

# 获取JSON响应(自动解析)
print(response.json())

2.3 高级特性

Requests提供了许多高级功能，使得处理复杂场景变得简单：

• 会话对象：保持跨请求的持久性参数
• 超时设置：防止请求挂起
• SSL验证：确保安全连接
• 代理支持：通过代理服务器发送请求
• 文件上传：简单高效的文件传输
• 流式请求：处理大文件下载
• 身份验证：支持多种认证方式

3. 实战应用场景

3.1 Web爬虫开发

Requests是构建网络爬虫的基础工具。结合BeautifulSoup或lxml等解析库，可以轻松抓取和解析网页内容。以下是一个简单的天气数据爬取示例：

python复制import requests
from bs4 import BeautifulSoup

url = 'http://www.weather.com.cn/weather/101010100.shtml'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')
weather_data = soup.find('ul', class_='t clearfix').find_all('li')
for item in weather_data:
    date = item.find('h1').text
    weather = item.find('p', class_='wea').text
    print(f"{date}: {weather}")

3.2 REST API交互

现代Web应用大量使用RESTful API，Requests是与之交互的理想工具。以下是与GitHub API交互的示例：

python复制import requests
import json

# 获取用户仓库信息
response = requests.get(
    'https://api.github.com/users/octocat/repos',
    headers={'Accept': 'application/vnd.github.v3+json'}
)

repos = response.json()
for repo in repos:
    print(f"{repo['name']}: {repo['description']}")

3.3 文件下载与上传

Requests简化了文件传输操作。以下是文件下载和上传的示例：

python复制# 文件下载
url = 'https://example.com/largefile.zip'
response = requests.get(url, stream=True)
with open('largefile.zip', 'wb') as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

# 文件上传
files = {'file': open('report.xls', 'rb')}
response = requests.post('https://httpbin.org/post', files=files)

4. 性能优化与最佳实践

4.1 连接池与会话保持

使用Session对象可以重用底层TCP连接，显著提高性能：

python复制s = requests.Session()

# 所有请求将使用相同的连接
for i in range(10):
    s.get('https://httpbin.org/get')

4.2 超时设置

总是设置合理的超时值，避免程序挂起：

python复制# 连接超时3秒，读取超时7秒
try:
    response = requests.get('https://example.com', timeout=(3, 7))
except requests.exceptions.Timeout:
    print("请求超时")

4.3 重试机制

对于不稳定的网络连接，实现自动重试：

python复制from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

session = requests.Session()
retries = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[502, 503, 504]
)
session.mount('http://', HTTPAdapter(max_retries=retries))
session.mount('https://', HTTPAdapter(max_retries=retries))

response = session.get('https://example.com')

5. 常见问题与解决方案

5.1 429 Too Many Requests

当遇到429状态码时，表示请求过于频繁。解决方案：

python复制import time
from requests.exceptions import HTTPError

try:
    response = requests.get('https://api.example.com/endpoint')
    response.raise_for_status()
except HTTPError as e:
    if e.response.status_code == 429:
        retry_after = int(e.response.headers.get('Retry-After', 5))
        print(f"请求过于频繁，将在{retry_after}秒后重试")
        time.sleep(retry_after)
        # 重试逻辑

5.2 502 Bad Gateway

502错误通常表示服务器端问题。处理方式：

python复制import time

max_retries = 3
retry_delay = 2

for i in range(max_retries):
    try:
        response = requests.get('https://example.com/api')
        if response.status_code == 502:
            raise Exception("Bad Gateway")
        break
    except Exception as e:
        if i == max_retries - 1:
            raise
        time.sleep(retry_delay * (i + 1))

5.3 SSL证书验证问题

处理SSL证书验证错误：

python复制# 不推荐在生产环境中使用
response = requests.get('https://example.com', verify=False)

# 更好的做法是指定CA证书包路径
response = requests.get('https://example.com', verify='/path/to/certfile')

6. 高级技巧与经验分享

6.1 请求钩子

Requests支持钩子函数，可以在请求过程中插入自定义逻辑：

python复制def print_url(r, *args, **kwargs):
    print(r.url)

requests.get('https://httpbin.org', hooks={'response': [print_url]})

6.2 流式处理大响应

对于大文件或流式响应，可以使用iter_content方法：

python复制response = requests.get('https://example.com/large_file', stream=True)
with open('large_file', 'wb') as f:
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:  # 过滤keep-alive新块
            f.write(chunk)

6.3 自定义身份验证

实现自定义认证方式：

python复制from requests.auth import AuthBase

class TokenAuth(AuthBase):
    def __init__(self, token):
        self.token = token
    
    def __call__(self, r):
        r.headers['Authorization'] = f'Token {self.token}'
        return r

requests.get('https://example.com', auth=TokenAuth('my_token'))

6.4 性能监控

使用事件钩子监控请求性能：

python复制import time

def timing_hook(response, *args, **kwargs):
    response.elapsed_total = time.time() - kwargs['start_time']
    return response

start_time = time.time()
response = requests.get(
    'https://httpbin.org/delay/2',
    hooks={'response': [timing_hook]},
    start_time=start_time
)
print(f"请求耗时: {response.elapsed_total:.2f}秒")

7. 与其他库的集成

7.1 结合Pandas处理数据

Requests获取的数据可以方便地转换为Pandas DataFrame：

python复制import pandas as pd
import requests

response = requests.get('https://api.example.com/data.json')
data = response.json()
df = pd.DataFrame(data['results'])
print(df.head())

7.2 异步请求

虽然Requests本身是同步的，但可以与asyncio和aiohttp配合使用：

python复制import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'http://python.org')
        print(html[:100])

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

7.3 结合缓存

使用requests-cache实现自动缓存：

python复制import requests_cache

requests_cache.install_cache('demo_cache')

# 第一次请求会真正发送
response = requests.get('https://httpbin.org/get')
print(response.from_cache)  # False

# 相同请求会从缓存读取
response = requests.get('https://httpbin.org/get')
print(response.from_cache)  # True

8. 安全注意事项

8.1 敏感信息处理

避免在代码中硬编码敏感信息：

python复制# 不推荐
requests.get('https://api.example.com', auth=('username', 'password'))

# 推荐使用环境变量
import os
from requests.auth import HTTPBasicAuth

username = os.getenv('API_USER')
password = os.getenv('API_PASS')
requests.get('https://api.example.com', auth=HTTPBasicAuth(username, password))

8.2 输入验证

总是验证用户提供的URL：

python复制from urllib.parse import urlparse

def safe_request(url):
    parsed = urlparse(url)
    if not parsed.scheme in ('http', 'https'):
        raise ValueError("仅支持HTTP/HTTPS协议")
    if not parsed.netloc:
        raise ValueError("无效的域名")
    return requests.get(url)

safe_request('https://example.com')

8.3 速率限制

实现客户端速率限制，避免被封禁：

python复制import time

class RateLimitedSession(requests.Session):
    def __init__(self, rate_limit=1):
        super().__init__()
        self.rate_limit = rate_limit
        self.last_request = 0
    
    def send(self, *args, **kwargs):
        elapsed = time.time() - self.last_request
        if elapsed < self.rate_limit:
            time.sleep(self.rate_limit - elapsed)
        self.last_request = time.time()
        return super().send(*args, **kwargs)

session = RateLimitedSession(rate_limit=0.5)  # 每秒最多2个请求
for i in range(5):
    session.get('https://httpbin.org/get')

9. 调试与问题排查

9.1 请求日志记录

启用详细日志记录帮助调试：

python复制import logging
import http.client

http.client.HTTPConnection.debuglevel = 1
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True

requests.get('https://httpbin.org/get')

9.2 使用Fiddler/Charles调试

配置代理查看请求详情：

python复制proxies = {
    'http': 'http://127.0.0.1:8888',
    'https': 'http://127.0.0.1:8888'
}

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

9.3 异常处理

全面的异常处理策略：

python复制from requests.exceptions import RequestException

try:
    response = requests.get('https://example.com', timeout=5)
    response.raise_for_status()
except RequestException as e:
    if isinstance(e, requests.exceptions.Timeout):
        print("请求超时")
    elif isinstance(e, requests.exceptions.HTTPError):
        print(f"HTTP错误: {e.response.status_code}")
    elif isinstance(e, requests.exceptions.ConnectionError):
        print("连接错误")
    else:
        print(f"请求错误: {str(e)}")

10. 测试与Mock

10.1 使用responses库测试

模拟HTTP响应进行测试：

python复制import responses
import requests

@responses.activate
def test_my_api():
    responses.add(
        responses.GET,
        'https://api.example.com/data',
        json={'key': 'value'},
        status=200
    )
    
    response = requests.get('https://api.example.com/data')
    assert response.status_code == 200
    assert response.json() == {'key': 'value'}

test_my_api()

10.2 请求/响应录制

使用vcrpy录制和回放请求：

python复制import vcr
import requests

with vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml'):
    response = requests.get('https://httpbin.org/get')
    print(response.status_code)

10.3 性能测试

使用locust进行负载测试：

python复制from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
    wait_time = between(1, 2.5)
    
    @task
    def get_index(self):
        self.client.get("/")
    
    @task(3)
    def get_item(self):
        self.client.get("/item?id=1")

11. 替代方案与比较

11.1 Requests vs urllib3

虽然Requests基于urllib3，但提供了更高级的API：

11.2 Requests vs aiohttp

同步与异步的选择：

11.3 Requests vs httpx

新一代HTTP客户端的比较：

12. 未来发展与建议

Requests库虽然成熟稳定，但在现代Python生态中面临一些挑战。随着Python异步编程的普及和HTTP/2的广泛应用，开发者可能需要考虑更现代的替代方案如httpx。然而，对于大多数同步用例和传统项目，Requests仍然是可靠的选择。

我个人在实际项目中的经验是：对于简单的脚本和一次性任务，Requests是最快捷的解决方案；对于需要高性能或现代HTTP特性的项目，可以考虑结合使用Requests和其他更先进的库。无论选择哪种工具，理解HTTP协议本身才是最重要的基础。