HTTP协议网络编程实例教程常见连接超时POST请求参数传递错误解决方案
嘿，朋友！今天咱们来聊聊HTTP网络编程中那些让人头疼的问题——连接超时和POST参数传递错误。别担心，这些坑我踩过无数次了，现在整理出来让你少摔几跤。
一、连接超时的那些事儿
连接超时简直是网络编程中最常见的”老朋友”了。你可能遇到过这种情况：代码跑着跑着就卡住了，然后程序直接崩掉或者挂起，一脸懵。
1.1 什么是连接超时？
简单来说，连接超时就是客户端尝试与服务器建立TCP连接时，在规定时间没能成功建立连接。想象一下，你给朋友打电话，一直”嘟——嘟——”响个不停，对方就是不接，几秒后你挂断了——这就是超时。
1.2 为什么会超时？
让我给你列举几个常见原因：
网络不通畅：服务器太远了，或者中间网络有问题，数据包在路上丢了。 服务器太忙：服务器处理不过来，连接队列满了，新连接进不来。 防火墙拦路：服务器那边的防火墙不让你连，或者你本地的防火墙把你拦截了。 超时时间设置太短：你给自己设了个3秒的超时，但网络状况差，3秒根本不够。 DNS解析慢：域名解析半天解析不出来，浪费时间。
1.3 用Python来解决连接超时问题
我直接上代码，让你看看怎么处理。
import requests
from requests.exceptions import ConnectTimeout, HTTPError, RequestException
def http_get_with_timeout(url, timeout=10):
"""
发送GET请求，带超时处理
:param url: 目标URL
:param timeout: 超时时间（秒）
:return: 响应内容或错误信息
"""
try:
# 发送请求，设置超时时间
response = requests.get(url, timeout=timeout)
# 检查HTTP状态码，非200就抛异常
response.raise_for_status()
return {
'status': 'success',
'data': response.json() if 'application/json' in response.headers.get('Content-Type', '') else response.text,
'headers': dict(response.headers)
}
except ConnectTimeout:
# 专门捕获连接超时异常
return {
'status': 'error',
'error': f'连接超时：请求 {url} 在 {timeout} 秒内未能建立连接'
}
except HTTPError as e:
# HTTP错误（比如404、500等）
return {
'status': 'error',
'error': f'HTTP错误：{e.response.status_code} - {e.response.reason}'
}
except RequestException as e:
# 其他请求异常
return {
'status': 'error',
'error': f'请求异常：{str(e)}'
}
# 使用示例
if __name__ == '__main__':
url = 'https://api.github.com/users/octocat/repos'
result = http_get_with_timeout(url, timeout=5)
if result['status'] == 'success':
print('请求成功！')
print(f'获取到 {len(result["data"])} 个仓库')
else:
print(f'请求失败：{result["error"]}')
1.4 优化超时设置的最佳实践
别光设置一个timeout就完事了，下面这些细节很重要：
分阶段设置超时：
import requests
# 更精细的超时控制：连接超时和读取超时分开设置
# timeout=(连接超时, 读取超时)
response = requests.get(url, timeout=(3, 10))
# 3秒内建立连接，10秒内读取数据
使用会话对象复用连接：
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retry():
"""
创建带重试机制的会话对象
"""
session = requests.Session()
# 配置重试策略
retry = Retry(
total=3, # 最多重试3次
backoff_factor=0.3, # 重试间隔：0.3s, 0.6s, 1.2s
status_forcelist=[500, 502, 503, 504] # 这些状态码才重试
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('http://', adapter)
session.mount('https://', adapter)
return session
# 使用
session = create_session_with_retry()
response = session.get(url, timeout=(3, 10))
设置socket级别的超时：
import socket
import http.client
# 设置全局socket超时
socket.setdefaulttimeout(10)
# 或者使用http.client手动设置
conn = http.client.HTTPConnection('api.github.com', timeout=10)
conn.request('GET', '/users/octocat/repos')
response = conn.getresponse()
二、POST请求参数传递错误
POST请求参数传错了，简直是网络编程中的”经典翻车现场”。数据没传过去，或者传过去服务器不认识，或者传了错误类型的数据… 让人抓狂。
2.1 POST请求参数传递的常见错误
让我一个个给你数：
错误1：Content-Type头没设置对
import requests
url = 'https://httpbin.org/post'
# 错误示范：没设置Content-Type，或者设置错了
data = {'name': '张三', 'age': 25}
# 错误方式1：直接传data，但没有设置正确的Content-Type
# requests会自动设置Content-Type为application/x-www-form-urlencoded
response1 = requests.post(url, data=data)
print(response1.json()['headers']['Content-Type'])
# 输出: application/x-www-form-urlencoded
# 错误方式2：手贱设置了Content-Type为json，但传的是data
response2 = requests.post(
url,
data=data,
headers={'Content-Type': 'application/json'} # 这会导致服务器解析错误！
)
错误2：JSON数据没有序列化
import json
import requests
url = 'https://httpbin.org/post'
data = {'name': '张三', 'age': 25}
# 错误示范：直接传字典，但告诉服务器是JSON
response = requests.post(url, data=data, headers={'Content-Type': 'application/json'})
# 服务器收到的原始数据是：name=%E5%BC%A0%E4%B8%89&age=25
# 这不是有效的JSON！服务器当然解析不了。
# 正确做法：使用json参数，或者手动序列化
response = requests.post(url, json=data)
# 或者
response = requests.post(url, data=json.dumps(data), headers={'Content-Type': 'application/json'})
错误3：参数编码问题
import requests
url = 'https://httpbin.org/post'
# 中文参数处理
data = {
'name': '张三',
'city': '北京',
'message': '你好，世界！'
}
# 错误示范：直接传，在某些情况下编码会出问题
# 正确做法：使用json参数，requests会自动处理编码
response = requests.post(url, json=data)
# 或者使用data参数，确保编码正确
response = requests.post(url, data=data)
# requests默认使用utf-8编码，一般没问题
2.2 POST请求的多种参数传递方式
让我给你完整演示POST请求的各种参数传递方式：
import requests
import json
from urllib.parse import urlencode
url = 'https://httpbin.org/post'
# ========== 方式1：使用data参数传递表单数据 ==========
# 适用于：Content-Type: application/x-www-form-urlencoded
form_data = {
'username': 'testuser',
'password': '123456',
'remember': 'true'
}
response1 = requests.post(url, data=form_data)
print("方式1 - 表单数据:")
print(f"Content-Type: {response1.json()['headers']['Content-Type']}")
print(f"Form数据: {response1.json()['form']}")
print()
# ========== 方式2：使用json参数传递JSON数据 ==========
# 适用于：Content-Type: application/json
json_data = {
'username': 'testuser',
'password': '123456',
'remember': True, # 布尔值，会自动序列化
'profile': {
'name': '测试用户',
'age': 25,
'hobbies': ['编程', '读书', '跑步']
}
}
response2 = requests.post(url, json=json_data)
print("方式2 - JSON数据:")
print(f"Content-Type: {response2.json()['headers']['Content-Type']}")
print(f"JSON数据: {json.dumps(response2.json()['json'], indent=2, ensure_ascii=False)}")
print()
# ========== 方式3：手动序列化JSON并设置headers ==========
# 适用于：需要完全控制请求时的情况
json_str = json.dumps(json_data, ensure_ascii=False)
headers = {
'Content-Type': 'application/json; charset=utf-8',
'Authorization': 'Bearer your_token_here',
'Custom-Header': 'CustomValue'
}
response3 = requests.post(url, data=json_str, headers=headers)
print("方式3 - 手动序列化:")
print(f"Content-Type: {response3.json()['headers']['Content-Type']}")
print(f"Authorization: {response3.json()['headers']['Authorization']}")
print(f"自定义Header: {response3.json()['headers']['Custom-Header']}")
print()
# ========== 方式4：上传文件 ==========
# 适用于：multipart/form-data
file_data = {
'file': open('test.txt', 'rb'),
'description': '测试文件'
}
response4 = requests.post(url, files=file_data)
print("方式4 - 文件上传:")
print(f"Content-Type: {response4.json()['headers']['Content-Type']}")
print(f"Files: {list(response4.json()['files'].keys())}")
file_data['file'].close()
print()
# ========== 方式5：传递原始数据（如XML、纯文本等） ==========
xml_data = '''<?xml version="1.0" encoding="UTF-8"?>
<user>
<name>张三</name>
<age>25</age>
</user>'''
headers_xml = {
'Content-Type': 'application/xml; charset=utf-8'
}
response5 = requests.post(url, data=xml_data, headers=headers_xml)
print("方式5 - XML数据:")
print(f"Content-Type: {response5.json()['headers']['Content-Type']}")
print(f"Data: {response5.json()['data']}")
2.3 处理复杂的POST请求场景
在实际开发中，你可能会遇到更复杂的情况，让我给你几个实战示例：
import requests
import json
import time
from requests.auth import HTTPBasicAuth
class APIClient:
"""
一个处理POST请求的客户端类
封装了常见的错误处理和参数传递逻辑
"""
def __init__(self, base_url, timeout=10, retry_count=3):
self.base_url = base_url.rstrip('/')
self.timeout = timeout
self.retry_count = retry_count
self.session = requests.Session()
self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})
def post_json(self, endpoint, data, headers=None):
"""
发送JSON格式的POST请求
"""
url = f"{self.base_url}/{endpoint.lstrip('/')}"
# 合并自定义headers
request_headers = self.session.headers.copy()
if headers:
request_headers.update(headers)
for attempt in range(self.retry_count):
try:
response = self.session.post(
url,
json=data, # 自动序列化为JSON并设置正确的Content-Type
headers=request_headers,
timeout=self.timeout
)
# 检查状态码
response.raise_for_status()
return {
'success': True,
'status_code': response.status_code,
'data': response.json()
}
except requests.exceptions.Timeout:
if attempt < self.retry_count - 1:
print(f"请求超时，正在重试 ({attempt + 1}/{self.retry_count})...")
time.sleep(0.5 * (attempt + 1)) # 指数退避
continue
else:
return {
'success': False,
'error': f'请求超时：{url}'
}
except requests.exceptions.HTTPError as e:
error_detail = {
'success': False,
'error': f'HTTP错误：{e}',
'status_code': e.response.status_code,
'response': e.response.text
}
# 4xx错误不重试
if 400 <= e.response.status_code < 500:
return error_detail
# 5xx错误可以重试
if attempt < self.retry_count - 1:
print(f"服务器错误 ({e.response.status_code})，正在重试...")
time.sleep(0.5 * (attempt + 1))
continue
else:
return error_detail
except requests.exceptions.ConnectionError as e:
if attempt < self.retry_count - 1:
print(f"连接错误，正在重试 ({attempt + 1}/{self.retry_count})...")
time.sleep(0.5 * (attempt + 1))
continue
else:
return {
'success': False,
'error': f'连接错误：{str(e)}'
}
return {
'success': False,
'error': '未知错误'
}
def post_form(self, endpoint, data, headers=None):
"""
发送表单格式的POST请求
"""
url = f"{self.base_url}/{endpoint.lstrip('/')}"
request_headers = self.session.headers.copy()
if headers:
request_headers.update(headers)
try:
response = self.session.post(
url,
data=data, # 自动序列化为表单数据
headers=request_headers,
timeout=self.timeout
)
response.raise_for_status()
return {
'success': True,
'status_code': response.status_code,
'data': response.json() if response.headers.get('Content-Type', '').startswith('application/json') else response.text
}
except Exception as e:
return {
'success': False,
'error': str(e)
}
def post_with_auth(self, endpoint, data, username, password):
"""
发送带基本认证的POST请求
"""
url = f"{self.base_url}/{endpoint.lstrip('/')}"
try:
response = self.session.post(
url,
json=data,
auth=HTTPBasicAuth(username, password),
timeout=self.timeout
)
response.raise_for_status()
return {
'success': True,
'status_code': response.status_code,
'data': response.json()
}
except requests.exceptions.HTTPError as e:
if e.response.status_code == 401:
return {
'success': False,
'error': '认证失败：用户名或密码错误'
}
else:
return {
'success': False,
'error': f'HTTP错误：{e}'
}
except Exception as e:
return {
'success': False,
'error': str(e)
}
# ========== 使用示例 ==========
if __name__ == '__main__':
# 创建API客户端
client = APIClient(
base_url='https://httpbin.org',
timeout=10,
retry_count=3
)
# 示例1：发送JSON数据
print("=== 示例1：发送JSON数据 ===")
result = client.post_json('/post', {
'name': '张三',
'age': 25,
'email': 'zhangsan@example.com',
'tags': ['python', '编程', '网络']
})
if result['success']:
print("请求成功！")
print(f"返回数据: {json.dumps(result['data'], indent=2, ensure_ascii=False)}")
else:
print(f"请求失败: {result['error']}")
print()
# 示例2：发送表单数据
print("=== 示例2：发送表单数据 ===")
result = client.post_form('/post', {
'username': 'testuser',
'password': 'testpass',
'remember': 'true'
})
if result['success']:
print("请求成功！")
print(f"返回数据: {json.dumps(result['data'], indent=2, ensure_ascii=False)}")
else:
print(f"请求失败: {result['error']}")
print()
# 示例3：带认证的请求
print("=== 示例3：带认证的请求 ===")
result = client.post_with_auth(
'/basic-auth/testuser/testpass',
{'action': 'test'},
username='testuser',
password='testpass'
)
if result['success']:
print("请求成功！")
print(f"返回数据: {json.dumps(result['data'], indent=2, ensure_ascii=False)}")
else:
print(f"请求失败: {result['error']}")
2.4 POST请求参数传递的”坑”与”雷”
让我给你总结一下最容易踩的雷区：
| 错误类型 | 错误表现 | 正确做法 |
|---|---|---|
| Content-Type不匹配 | 服务器返回400 Bad Request | 确保Content-Type与实际数据格式一致 |
| JSON未序列化 | 服务器收到的是”{‘name’: ‘张三’}“字符串 | 使用json参数或json.dumps() |
| 中文编码问题 | 出现乱码或Unicode转义 | 使用json参数，或确保charset=utf-8 |
| 重复发送请求 | 重复扣款、重复下单 | 使用幂等性设计，添加唯一请求ID |
| 请求体过大 | 413 Payload Too Large | 检查服务器限制，压缩数据或分页提交 |
| 缺少必要参数 | 400或500错误 | 在发送前校验所有必要参数 |
| 参数类型错误 | 服务器解析失败 | 确保参数类型与API文档一致 |
2.5 参数校验的最佳实践
在发送POST请求前，做好参数校验能避免很多麻烦：
import re
from typing import Dict, Any, Optional
def validate_post_data(data: Dict[str, Any], rules: Dict[str, Dict]) -> Dict[str, str]:
"""
校验POST请求参数
:param data: 请求数据
:param rules: 校验规则
:return: 错误信息字典，如果没有错误返回空字典
"""
errors = {}
for field, rule in rules.items():
value = data.get(field)
# 必填校验
if rule.get('required') and not value:
errors[field] = f"{field}是必填项"
continue
# 类型校验
if value and rule.get('type'):
expected_type = rule['type']
if expected_type == 'string':
if not isinstance(value, str):
errors[field] = f"{field}必须是字符串类型"
elif expected_type == 'integer':
if not isinstance(value, int):
errors[field] = f"{field}必须是整数类型"
elif expected_type == 'number':
if not isinstance(value, (int, float)):
errors[field] = f"{field}必须是数字类型"
elif expected_type == 'boolean':
if not isinstance(value, bool):
errors[field] = f"{field}必须是布尔类型"
elif expected_type == 'array':
if not isinstance(value, list):
errors[field] = f"{field}必须是数组类型"
elif expected_type == 'object':
if not isinstance(value, dict):
errors[field] = f"{field}必须是对象类型"
# 长度校验
if value and rule.get('min_length'):
if len(str(value)) < rule['min_length']:
errors[field] = f"{field}长度不能少于{rule['min_length']}个字符"
if value and rule.get('max_length'):
if len(str(value)) > rule['max_length']:
errors[field] = f"{field}长度不能超过{rule['max_length']}个字符"
# 正则校验
if value and rule.get('pattern'):
if not re.match(rule['pattern'], str(value)):
errors[field] = rule.get('pattern_message', f"{field}格式不正确")
# 枚举校验
if value and rule.get('enum'):
if value not in rule['enum']:
errors[field] = f"{field}必须是以下值之一: {rule['enum']}"
return errors
# 使用示例
if __name__ == '__main__':
# 定义校验规则
rules = {
'username': {
'required': True,
'type': 'string',
'min_length': 3,
'max_length': 20,
'pattern': r'^[a-zA-Z0-9_]+$',
'pattern_message': '用户名只能包含字母、数字和下划线'
},
'email': {
'required': True,
'type': 'string',
'pattern': r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$',
'pattern_message': '邮箱格式不正确'
},
'age': {
'required': True,
'type': 'integer',
'min_length': 1,
'max_length': 3
},
'gender': {
'required': True,
'type': 'string',
'enum': ['male', 'female', 'other']
},
'tags': {
'required': False,
'type': 'array'
}
}
# 测试数据
test_data = {
'username': 'test_user',
'email': 'test@example.com',
'age': 25,
'gender': 'male',
'tags': ['python', '编程']
}
# 校验
errors = validate_post_data(test_data, rules)
if errors:
print("校验失败：")
for field, error in errors.items():
print(f" {field}: {error}")
else:
print("校验通过！")
三、综合实战：构建健壮的HTTP客户端
光知道问题不够，咱们得学会怎么写出健壮的代码。下面这个例子综合了前面讲的所有内容：
import requests
import json
import time
import logging
from typing import Dict, Any, Optional, Union
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import ssl
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
class RobustHTTPClient:
"""
健壮的HTTP客户端
集成了超时处理、重试机制、参数校验等功能
"""
def __init__(
self,
base_url: str,
timeout: Union[int, float, tuple] = (5, 10),
retry_count: int = 3,
user_agent: str = 'RobustHTTPClient/1.0'
):
"""
初始化客户端
:param base_url: 基础URL
:param timeout: 超时时间，可以是int或(tuple, tuple)
:param retry_count: 重试次数
:param user_agent: 用户代理
"""
self.base_url = base_url.rstrip('/')
self.timeout = timeout
self.retry_count = retry_count
self.session = requests.Session()
# 设置默认headers
self.session.headers.update({
'User-Agent': user_agent,
'Accept': 'application/json'
})
# 配置重试策略
retry = Retry(
total=retry_count,
backoff_factor=0.5,
status_forcelist=[500, 502, 503, 504],
allowed_methods=['GET', 'POST', 'PUT', 'DELETE']
)
adapter = HTTPAdapter(max_retries=retry)
self.session.mount('http://', adapter)
self.session.mount('https://', adapter)
# 禁用SSL证书验证（仅用于测试环境）
# 生产环境请删除下面这行
requests.packages.urllib3.disable_warnings()
def request(
self,
method: str,
endpoint: str,
data: Optional[Dict[str, Any]] = None,
params: Optional[Dict[str, Any]] = None,
headers: Optional[Dict[str, str]] = None,
json_data: Optional[Dict[str, Any]] = None,
files: Optional[Dict[str, Any]] = None,
auth: Optional[Any] = None
) -> Dict[str, Any]:
"""
发送HTTP请求
:param method: HTTP方法
:param endpoint: 端点
:param data: 表单数据
:param params: URL参数
:param headers: 自定义headers
:param json_data: JSON数据
:param files: 文件数据
:param auth: 认证信息
:return: 响应结果
"""
url = f"{self.base_url}/{endpoint.lstrip('/')}"
# 合并headers
request_headers = self.session.headers.copy()
if headers:
request_headers.update(headers)
# 记录请求信息
logger.info(f"发送 {method} 请求: {url}")
logger.info(f"请求参数: {data or json_data or params}")
try:
# 发送请求
response = self.session.request(
method=method,
url=url,
data=data,
params=params,
headers=request_headers,
json=json_data,
files=files,
auth=auth,
timeout=self.timeout
)
# 记录响应信息
logger.info(f"响应状态码: {response.status_code}")
# 解析响应
result = {
'success': True,
'status_code': response.status_code,
'headers': dict(response.headers),
'url': response.url
}
# 尝试解析JSON
content_type = response.headers.get('Content-Type', '')
if 'application/json' in content_type:
try:
result['data'] = response.json()
except json.JSONDecodeError:
result['data'] = None
result['raw_data'] = response.text
else:
result['data'] = None
result['raw_data'] = response.text
return result
except requests.exceptions.Timeout:
logger.error(f"请求超时: {url}")
return {
'success': False,
'error': f'请求超时: {url}',
'status_code': None
}
except requests.exceptions.ConnectionError as e:
logger.error(f"连接错误: {str(e)}")
return {
'success': False,
'error': f'连接错误: {str(e)}',
'status_code': None
}
except requests.exceptions.HTTPError as e:
logger.error(f"HTTP错误: {e}")
return {
'success': False,
'error': str(e),
'status_code': e.response.status_code if e.response else None,
'response_data': e.response.text if e.response else None
}
except Exception as e:
logger.error(f"未知错误: {str(e)}")
return {
'success': False,
'error': f'未知错误: {str(e)}',
'status_code': None
}
def get(self, endpoint: str, **kwargs) -> Dict[str, Any]:
"""发送GET请求"""
return self.request('GET', endpoint, **kwargs)
def post(self, endpoint: str, **kwargs) -> Dict[str, Any]:
"""发送POST请求"""
return self.request('POST', endpoint, **kwargs)
def put(self, endpoint: str, **kwargs) -> Dict[str, Any]:
"""发送PUT请求"""
return self.request('PUT', endpoint, **kwargs)
def delete(self, endpoint: str, **kwargs) -> Dict[str, Any]:
"""发送DELETE请求"""
return self.request('DELETE', endpoint, **kwargs)
# ========== 使用示例 ==========
if __name__ == '__main__':
# 创建客户端
client = RobustHTTPClient(
base_url='https://httpbin.org',
timeout=(5, 10),
retry_count=3
)
# 示例1：GET请求
print("=" * 50)
print("示例1：GET请求")
print("=" * 50)
result = client.get('/get', params={'name': '张三', 'age': 25})
print(json.dumps(result, indent=2, ensure_ascii=False))
print()
# 示例2：POST JSON请求
print("=" * 50)
print("示例2：POST JSON请求")
print("=" * 50)
result = client.post('/post', json_data={
'username': 'testuser',
'password': 'testpass',
'email': 'test@example.com'
})
print(json.dumps(result, indent=2, ensure_ascii=False))
print()
# 示例3：POST表单请求
print("=" * 50)
print("示例3：POST表单请求")
print("=" * 50)
result = client.post('/post', data={
'username': 'testuser',
'password': 'testpass'
})
print(json.dumps(result, indent=2, ensure_ascii=False))
print()
# 示例4：带自定义Headers的请求
print("=" * 50)
print("示例4：带自定义Headers的请求")
print("=" * 50)
result = client.post('/post', json_data={'test': 'data'}, headers={
'X-Custom-Header': 'CustomValue',
'Authorization': 'Bearer test_token'
})
print(json.dumps(result, indent=2, ensure_ascii=False))
print()
# 示例5：模拟超时请求
print("=" * 50)
print("示例5：超时请求处理")
print("=" * 50)
client_short_timeout = RobustHTTPClient(
base_url='https://httpbin.org',
timeout=(0.001, 0.001) # 超短超时，模拟超时
)
result = client_short_timeout.get('/delay/10')
print(json.dumps(result, indent=2, ensure_ascii=False))
四、调试技巧与常见问题排查
代码写好了，但运行起来就是有问题？别急，让我教你几招调试技巧。
4.1 开启详细日志
import logging
import http.client as http_client
# 开启requests库的详细日志
logging.basicConfig(level=logging.DEBUG)
http_client.HTTPConnection.debuglevel = 1
4.2 使用Wireshark抓包分析
Wireshark是网络调试的神器，可以帮你看到每一个数据包的细节。对于排查连接超时、参数传递错误等问题非常有用。
4.3 常见错误码及解决方案
| 错误码 | 含义 | 常见原因 | 解决方案 |
|---|---|---|---|
| 400 | 请求错误 | 参数格式错误、缺少必要参数 | 检查请求参数，对照API文档 |
| 401 | 未授权 | Token过期、认证失败 | 检查认证信息，重新获取Token |
| 403 | 禁止访问 | 权限不足 | 检查用户权限 |
| 404 | 找不到资源 | URL错误、资源不存在 | 检查URL是否正确 |
| 405 | 方法不允许 | 使用了错误的HTTP方法 | 检查HTTP方法是否正确 |
| 413 | 请求体过大 | 数据量超过限制 | 压缩数据或分页提交 |
| 429 | 请求过于频繁 | 触发限流 | 降低请求频率，使用缓存 |
| 500 | 服务器内部错误 | 服务器代码错误 | 联系服务器管理员 |
| 502 | bad gateway | 网关错误 | 检查代理服务 |
| 503 | 服务不可用 | 服务器过载 | 稍后重试 |
| 504 | 网关超时 | 服务器响应超时 | 增加超时时间或联系管理员 |
4.4 使用curl命令测试
在写代码之前，先用curl命令测试一下接口，确认接口本身没问题，再写代码。
# 测试GET请求
curl -X GET "https://api.example.com/users" -H "Accept: application/json"
# 测试POST JSON请求
curl -X POST "https://api.example.com/users" \
-H "Content-Type: application/json" \
-d '{"name": "张三", "age": 25}'
# 测试POST表单请求
curl -X POST "https://api.example.com/users" \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "name=张三&age=25"
# 查看详细请求和响应信息
curl -v -X POST "https://api.example.com/users" \
-H "Content-Type: application/json" \
-d '{"name": "张三"}'
五、性能优化建议
最后，让我分享几个优化建议，让你的HTTP请求更快更稳。
5.1 连接池复用
import requests
from requests.adapters import HTTPAdapter
# 创建会话并启用连接池
session = requests.Session()
adapter = HTTPAdapter(pool_connections=100, pool_maxsize=100)
session.mount('http://', adapter)
session.mount('https://', adapter)
# 复用连接，减少握手开销
for i in range(100):
response = session.get('https://api.example.com/data')
5.2 使用异步请求
对于需要大量并发请求的场景，异步是更好的选择：
import aiohttp
import asyncio
async def fetch(session, url):
async with session.get(url) as response:
return await response.json()
async def main():
async with aiohttp.ClientSession() as session:
tasks = [fetch(session, f'https://api.example.com/data/{i}') for i in range(100)]
results = await asyncio.gather(*tasks)
return results
# 运行
results = asyncio.run(main())
5.3 启用Gzip压缩
import requests
# 请求时请求压缩
headers = {
'Accept-Encoding': 'gzip, deflate'
}
response = requests.get(url, headers=headers)
# requests会自动解压
# 发送时压缩数据
import gzip
data = gzip.compress(json.dumps(data).encode('utf-8'))
response = requests.post(url, data=data, headers={
'Content-Encoding': 'gzip'
})
好了，朋友们，今天的分享就到这里。HTTP网络编程说难不难，说简单也不简单，关键在于多实践、多总结。遇到问题不要慌，一步一步排查，总能解决的。
记住几个要点：
- 连接超时要合理设置，别太短也别太长
- POST请求参数要匹配Content-Type
- 做好异常处理和重试机制
- 善用调试工具定位问题
祝你们编码愉快，少踩坑，多出活！