Python 爬虫进阶技巧：Cookie 持久化存储与复用

前言

在 Python 爬虫开发过程中，Cookie 是实现会话保持、登录状态维持、访问权限验证的核心技术。常规爬虫每次发起请求都会重新生成会话，无法复用登录信息、用户偏好等状态数据，不仅会大幅增加请求耗时，还容易触发网站的反爬机制。Cookie 持久化存储与复用，能够将服务器返回的 Cookie 信息保存至本地文件、数据库等介质中，后续爬虫程序直接读取复用有效 Cookie，无需重复执行登录、验证等操作，是提升爬虫稳定性、效率和隐蔽性的关键进阶技能。

本文将系统讲解 Cookie 的核心原理、Python 中 Cookie 操作的常用库、多种持久化存储方案、复用策略以及反爬规避实战技巧，结合完整可运行的代码案例与深度原理剖析，帮助开发者掌握 Cookie 持久化的全流程应用，解决爬虫会话失效、重复登录、访问受限等痛点问题。

本文涉及的核心依赖库及官方文档链接如下：

1. Requests：Python 最常用的 HTTP 请求库，内置 Cookie 管理功能
2. Requests-Http2：支持 HTTP/2 协议的 Requests 扩展，优化 Cookie 传输效率
3. Pickle：Python 内置序列化库，用于 Cookie 对象持久化
4. JSON：Python 内置 JSON 处理库，用于 Cookie 文本存储
5. SQLAlchemy：Python ORM 框架，用于数据库存储 Cookie
6. Redis：Redis Python 客户端，用于高性能缓存 Cookie

一、Cookie 核心基础认知

1.1 Cookie 的定义与工作原理

Cookie 是服务器发送到用户浏览器并保存在本地的小型文本数据，本质是键值对格式的会话标识，会在浏览器下次向同一服务器发起请求时，被自动携带并发送到服务器端。

Cookie 的完整工作流程分为四步：

1. 客户端首次向服务器发送 HTTP 请求，未携带任何 Cookie 信息；
2. 服务器验证请求后，在响应头中通过Set-Cookie字段返回 Cookie 数据；
3. 客户端接收响应，将 Cookie 存储在本地指定位置；
4. 客户端后续向该服务器发起请求时，自动在请求头中添加Cookie字段，携带存储的 Cookie 数据。

服务器通过解析 Cookie 中的会话 ID、用户信息等数据，识别用户身份、维持登录状态、记录用户行为，这也是爬虫必须复用 Cookie 才能访问需要登录的页面的核心原因。

1.2 Cookie 的核心属性详解

Cookie 包含多个关键属性，决定了其生效范围、有效期、安全性，爬虫开发中必须掌握这些属性的含义：

表格

1.3 爬虫中 Cookie 的核心痛点

1. 会话时效性：多数网站的 Cookie 有效期较短，手动复制 Cookie 无法长期使用；
2. 跨脚本失效：不同爬虫脚本、不同运行实例无法共享 Cookie 数据；
3. 重复登录损耗：每次运行爬虫都需要重新登录获取 Cookie，增加请求次数；
4. 反爬触发：频繁更换 Cookie、无 Cookie 访问，容易被服务器识别为异常请求；
5. 管理混乱：多域名、多账号的 Cookie 无统一存储方案，维护成本极高。

二、Python 爬虫 Cookie 操作基础

2.1 依赖库安装

在进行 Cookie 操作前，需安装核心依赖库，执行以下命令：

bash

运行

# 安装基础HTTP请求库 pip install requests # 安装HTTP/2支持库（可选，优化高性能爬虫） pip install requests-http2 # 安装Redis客户端（用于高性能缓存Cookie） pip install redis # 安装ORM框架（用于数据库存储Cookie） pip install sqlalchemy

2.2 Requests 库原生 Cookie 获取

Requests 是 Python 爬虫的标配库，其Response对象会自动存储服务器返回的 Cookie，可通过cookies属性直接获取：

python

运行

import requests # 目标请求地址（以GitHub登录页为例） url = "https://github.com/login" # 发送GET请求 response = requests.get(url) # 方式1：获取RequestsCookieJar对象（原生Cookie对象） cookie_jar = response.cookies print("CookieJar对象：", cookie_jar) # 方式2：将Cookie转换为字典格式 cookie_dict = requests.utils.dict_from_cookiejar(cookie_jar) print("Cookie字典：", cookie_dict) # 方式3：遍历CookieJar获取单条Cookie属性 for cookie in cookie_jar: print(f"名称：{cookie.name}, 值：{cookie.value}, 域名：{cookie.domain}, 有效期：{cookie.expires}")

代码原理剖析

1. requests.get()发起 HTTP 请求，服务器响应头中的Set-Cookie字段会被 Requests 自动解析；
2. response.cookies返回RequestsCookieJar对象，这是 Requests 封装的 Cookie 容器，兼容所有 Cookie 属性；
3. requests.utils.dict_from_cookiejar()是 Requests 内置工具函数，将 CookieJar 对象转换为字典格式，方便快速读取核心键值对；
4. 遍历 CookieJar 可获取完整的 Cookie 属性，包括 Domain、Path、Expires 等，为持久化存储提供全量数据。

2.3 Requests 库手动携带 Cookie

爬虫可通过cookies参数手动向请求中添加 Cookie，实现会话保持：

python

运行

import requests # 目标地址 target_url = "https://github.com/settings/profile" # 方式1：使用字典格式携带Cookie cookie_dict = {"user_session": "xxxxxx", "logged_in": "yes"} response1 = requests.get(target_url, cookies=cookie_dict) # 方式2：使用CookieJar对象携带Cookie cookie_jar = requests.cookies.RequestsCookieJar() cookie_jar.set("user_session", "xxxxxx", domain="github.com", path="/") response2 = requests.get(target_url, cookies=cookie_jar) print("响应状态码：", response1.status_code)

代码原理剖析

1. Requests 支持字典和RequestsCookieJar 对象两种格式的 Cookie 入参，字典格式适合简单场景，CookieJar 对象适合精细化配置；
2. cookie_jar.set()方法可手动创建 Cookie，指定 Name、Value、Domain、Path 等属性，完全模拟服务器返回的 Cookie；
3. 携带有效 Cookie 后，服务器会识别为已登录用户，返回对应权限的页面数据，这是 Cookie 复用的基础。

三、Cookie 持久化存储方案（核心进阶）

持久化存储的核心是将内存中的 Cookie 对象保存到本地磁盘、数据库、缓存等介质中，实现跨进程、跨时间、跨脚本的 Cookie 复用。本文提供四种主流存储方案，覆盖轻量、中型、高性能场景。

3.1 方案一：Pickle 序列化存储（本地文件，轻量首选）

Pickle 是 Python 内置的序列化库，可将 Python 对象（包括 RequestsCookieJar）转换为二进制字节流存储到本地文件，反序列化后可直接还原为原对象，无需解析属性，使用最简单。

3.1.1 Cookie 存储代码

python

运行

import requests import pickle # 1. 获取目标Cookie def get_target_cookie(): # 模拟登录获取Cookie（以示例网站为例） login_url = "https://passport.example.com/login" login_data = {"username": "test_user", "password": "test_pwd"} response = requests.post(login_url, data=login_data) return response.cookies # 2. Pickle序列化存储Cookie def save_cookie_with_pickle(cookie_jar, file_path="cookie.pkl"): with open(file_path, "wb") as f: # 序列化CookieJar对象并写入文件 pickle.dump(cookie_jar, f) print(f"Cookie已持久化存储至：{file_path}") # 执行存储 if __name__ == "__main__": cookie = get_target_cookie() save_cookie_with_pickle(cookie)

3.1.2 Cookie 复用代码

python

运行

import requests import pickle # 反序列化读取Cookie def load_cookie_with_pickle(file_path="cookie.pkl"): try: with open(file_path, "rb") as f: # 从文件读取并反序列化为CookieJar对象 cookie_jar = pickle.load(f) return cookie_jar except FileNotFoundError: print("Cookie文件不存在，请先执行存储操作") return None except Exception as e: print(f"读取Cookie失败：{str(e)}") return None # 使用复用的Cookie发起请求 def request_with_reused_cookie(): cookie_jar = load_cookie_with_pickle() if not cookie_jar: return target_url = "https://user.example.com/info" response = requests.get(target_url, cookies=cookie_jar) print(f"复用Cookie请求状态码：{response.status_code}") print(f"响应内容长度：{len(response.text)}") # 执行复用 if __name__ == "__main__": request_with_reused_cookie()

核心原理剖析

1. 序列化：pickle.dump()将内存中的RequestsCookieJar对象转换为二进制数据，写入本地.pkl文件，完整保留所有 Cookie 属性；
2. 反序列化：pickle.load()读取二进制文件，直接还原为RequestsCookieJar对象，与原 Cookie 完全一致，可直接传入 Requests 请求；
3. 优势：代码极简、无需处理 Cookie 解析、支持完整 Cookie 对象、适合单账号、单域名的轻量爬虫；
4. 缺陷：仅支持 Python 环境、二进制文件无法手动编辑、不适合多线程并发读写。

3.2 方案二：JSON 格式存储（本地文件，可读性优先）

JSON 是通用的文本格式，可将 Cookie 的核心属性转换为 JSON 字符串存储到本地文件，跨语言兼容、可手动编辑、适合需要查看 Cookie 内容的场景。

3.2.1 Cookie 存储代码

python

运行

import requests import json # 转换CookieJar为JSON兼容的列表格式 def cookiejar_to_json(cookie_jar): cookie_list = [] for cookie in cookie_jar: # 提取Cookie所有核心属性 cookie_dict = { "name": cookie.name, "value": cookie.value, "domain": cookie.domain, "path": cookie.path, "expires": cookie.expires, "secure": cookie.secure, "httponly": cookie.has_nonstandard_attr("HttpOnly") } cookie_list.append(cookie_dict) return cookie_list # JSON存储Cookie def save_cookie_with_json(cookie_jar, file_path="cookie.json"): cookie_data = cookiejar_to_json(cookie_jar) with open(file_path, "w", encoding="utf-8") as f: json.dump(cookie_data, f, ensure_ascii=False, indent=4) print(f"Cookie已JSON格式存储至：{file_path}") # 执行存储 if __name__ == "__main__": # 复用3.1.1中的get_target_cookie函数获取Cookie cookie = get_target_cookie() save_cookie_with_json(cookie)

3.2.2 Cookie 复用代码

python

运行

import requests import json # 转换JSON数据为CookieJar对象 def json_to_cookiejar(cookie_data): cookie_jar = requests.cookies.RequestsCookieJar() for item in cookie_data: cookie_jar.set( name=item["name"], value=item["value"], domain=item["domain"], path=item["path"], expires=item["expires"], secure=item["secure"] ) return cookie_jar # 读取JSON格式Cookie def load_cookie_with_json(file_path="cookie.json"): try: with open(file_path, "r", encoding="utf-8") as f: cookie_data = json.load(f) cookie_jar = json_to_cookiejar(cookie_data) return cookie_jar except FileNotFoundError: print("Cookie文件不存在") return None except Exception as e: print(f"读取失败：{str(e)}") return None # 测试复用 def test_json_cookie(): cookie_jar = load_cookie_with_json() if cookie_jar: response = requests.get("https://user.example.com/info", cookies=cookie_jar) print("JSON Cookie复用成功，状态码：", response.status_code) if __name__ == "__main__": test_json_cookie()

核心原理剖析

1. 格式转换：遍历RequestsCookieJar对象，提取所有核心属性为字典，组合成列表后通过json.dump()写入.json文件；
2. 还原对象：读取 JSON 文件后，通过cookie_jar.set()方法逐条重建 Cookie 对象，完整还原所有属性；
3. 优势：文本格式可读可编辑、跨编程语言兼容、无序列化安全风险、适合开发调试；
4. 缺陷：需要手动处理属性转换、代码量高于 Pickle、大数量 Cookie 时读写效率较低。

3.3 方案三：关系型数据库存储（SQLAlchemy，中型爬虫）

对于多账号、多域名、需要持久化管理的中型爬虫，可将 Cookie 存储到 MySQL、SQLite 等关系型数据库中，实现 Cookie 的增删改查、批量管理。

3.3.1 数据库表设计与 Cookie 存储

python

运行

from sqlalchemy import create_engine, Column, String, Integer, Boolean, Text from sqlalchemy.orm import declarative_base, sessionmaker import requests # 1. 数据库初始化 Base = declarative_base() # 使用SQLite本地数据库（可替换为mysql+pymysql://user:pwd@host:port/db） engine = create_engine("sqlite:///cookie_db.db", echo=False) Session = sessionmaker(bind=engine) db_session = Session() # 2. Cookie数据表模型 class CookieData(Base): __tablename__ = "spider_cookie" # 主键ID id = Column(Integer, primary_key=True, autoincrement=True) # 站点名称，用于区分不同网站 site = Column(String(50), nullable=False, comment="站点名称") # Cookie名称 name = Column(String(100), nullable=False, comment="Cookie名称") # Cookie值 value = Column(Text, nullable=False, comment="Cookie值") # 生效域名 domain = Column(String(100), comment="生效域名") # 生效路径 path = Column(String(100), default="/") # 有效期时间戳 expires = Column(Integer, default=0, comment="有效期") # HTTPS标识 secure = Column(Boolean, default=False) # HttpOnly标识 httponly = Column(Boolean, default=False) # 创建数据表 Base.metadata.create_all(engine) # 3. 数据库存储Cookie def save_cookie_to_db(cookie_jar, site="example"): # 先删除该站点旧Cookie，避免重复 db_session.query(CookieData).filter(CookieData.site == site).delete() # 逐条存储Cookie for cookie in cookie_jar: cookie_item = CookieData( site=site, name=cookie.name, value=cookie.value, domain=cookie.domain, path=cookie.path, expires=cookie.expires, secure=cookie.secure, httponly=cookie.has_nonstandard_attr("HttpOnly") ) db_session.add(cookie_item) db_session.commit() print(f"{site}站点Cookie已存储至数据库") # 执行存储 if __name__ == "__main__": cookie = get_target_cookie() save_cookie_to_db(cookie, site="example")

3.3.2 数据库读取与 Cookie 复用

python

运行

import requests from sqlalchemy.orm import Session from cookie_db_model import db_session, CookieData # 导入上一步的数据库对象 # 从数据库读取Cookie并还原为CookieJar def load_cookie_from_db(site="example"): cookie_jar = requests.cookies.RequestsCookieJar() # 查询指定站点的所有Cookie cookie_list = db_session.query(CookieData).filter(CookieData.site == site).all() if not cookie_list: return None # 重建Cookie对象 for item in cookie_list: cookie_jar.set( name=item.name, value=item.value, domain=item.domain, path=item.path, expires=item.expires, secure=item.secure ) return cookie_jar # 数据库Cookie复用请求 def request_with_db_cookie(): cookie_jar = load_cookie_from_db(site="example") if cookie_jar: response = requests.get("https://user.example.com/info", cookies=cookie_jar) print("数据库Cookie复用成功，状态码：", response.status_code) return response print("无有效Cookie") if __name__ == "__main__": request_with_db_cookie()

核心原理剖析

1. ORM 映射：通过 SQLAlchemy 定义数据表结构，将 Cookie 属性与数据库字段一一映射，无需编写原生 SQL；
2. 数据管理：支持按站点、域名筛选 Cookie，自动覆盖旧数据，实现 Cookie 的统一管理；
3. 持久化优势：数据永久存储、支持多线程访问、适合多站点多账号的中型分布式爬虫；
4. 适用场景：企业级爬虫、需要长期管理 Cookie 的项目。

3.4 方案四：Redis 缓存存储（高性能，分布式爬虫首选）

Redis 是高性能内存数据库，支持键值对存储、自动过期淘汰，适合分布式爬虫、高并发场景下的 Cookie 临时存储与复用，读写速度毫秒级，支持自动清理过期 Cookie。

3.4.1 环境准备

1. 安装 Redis 服务：Redis 官方下载地址
2. 启动 Redis 服务，默认端口：6379

3.4.2 Redis 存储与复用 Cookie 代码

python

运行

import requests import redis import json # 1. Redis连接初始化 redis_client = redis.Redis( host="localhost", port=6379, db=0, decode_responses=False # 关闭解码，存储二进制/字符串数据 ) # 2. Cookie存储到Redis def save_cookie_to_redis(cookie_jar, site="example", expire=3600): """ expire: Cookie过期时间，单位秒，默认1小时 """ cookie_data = [] for cookie in cookie_jar: cookie_dict = { "name": cookie.name, "value": cookie.value, "domain": cookie.domain, "path": cookie.path, "expires": cookie.expires, "secure": cookie.secure } cookie_data.append(cookie_dict) # 以站点名为Key，Cookie列表为Value，序列化后存储 redis_key = f"spider:cookie:{site}" redis_client.set(redis_key, json.dumps(cookie_data), ex=expire) print(f"Cookie已存储至Redis，过期时间：{expire}秒") # 3. 从Redis读取Cookie def load_cookie_from_redis(site="example"): redis_key = f"spider:cookie:{site}" cookie_data = redis_client.get(redis_key) if not cookie_data: return None # 反序列化并重建CookieJar cookie_list = json.loads(cookie_data) cookie_jar = requests.cookies.RequestsCookieJar() for item in cookie_list: cookie_jar.set( name=item["name"], value=item["value"], domain=item["domain"], path=item["path"], expires=item["expires"], secure=item["secure"] ) return cookie_jar # 4. Redis Cookie复用测试 def test_redis_cookie(): cookie_jar = load_cookie_from_redis() if cookie_jar: response = requests.get("https://user.example.com/info", cookies=cookie_jar) print("Redis Cookie复用成功，状态码：", response.status_code) # 执行存储与复用 if __name__ == "__main__": cookie = get_target_cookie() # 存储Cookie，有效期24小时 save_cookie_to_redis(cookie, expire=86400) test_redis_cookie()

核心原理剖析

1. 键值设计：采用spider:cookie:站点名的命名规范，区分不同站点的 Cookie，避免键名冲突；
2. 过期机制：利用 Redis 的ex参数设置 Cookie 过期时间，自动清理无效 Cookie，无需手动判断；
3. 高性能：Redis 基于内存读写，响应速度远高于磁盘文件和关系型数据库，支持高并发爬虫；
4. 分布式：Redis 支持多服务器共享访问，适合分布式爬虫集群统一获取 Cookie；
5. 适用场景：高并发爬虫、分布式爬虫、需要自动过期管理的场景。

四、Cookie 复用高级策略

4.1 Cookie 有效性自动校验

持久化存储的 Cookie 可能过期、失效，爬虫需自动校验 Cookie 有效性，避免无效请求：

python

运行

import requests # 校验Cookie是否有效 def check_cookie_valid(cookie_jar, check_url="https://user.example.com/info"): try: # 携带Cookie发起请求 response = requests.get(check_url, cookies=cookie_jar, timeout=5) # 判断响应内容是否包含登录标识（根据实际网站调整） if "退出登录" in response.text or response.status_code == 200: return True return False except Exception as e: print(f"Cookie校验失败：{str(e)}") return False # 智能复用Cookie：无效则重新获取 def smart_reuse_cookie(): # 读取本地Cookie cookie_jar = load_cookie_with_pickle() # 校验Cookie if cookie_jar and check_cookie_valid(cookie_jar): print("使用本地有效Cookie") return cookie_jar # 无效则重新获取并存储 print("本地Cookie无效，重新获取") new_cookie = get_target_cookie() save_cookie_with_pickle(new_cookie) return new_cookie

核心原理

通过访问需要登录的校验地址，判断响应状态码和页面内容，识别 Cookie 有效性；若无效，自动重新获取并覆盖本地存储，实现无人值守的 Cookie 智能复用。

4.2 多账号 Cookie 轮换策略

针对限制单账号访问频率的网站，可存储多账号 Cookie，实现轮换复用，规避反爬：

python

运行

import random import requests # 多账号Cookie列表（可从数据库/Redis加载） MULTI_ACCOUNT_COOKIES = [ load_cookie_from_db(site="example_account1"), load_cookie_from_db(site="example_account2"), load_cookie_from_db(site="example_account3") ] # 随机获取有效Cookie def get_random_valid_cookie(): valid_cookies = [cookie for cookie in MULTI_ACCOUNT_COOKIES if check_cookie_valid(cookie)] if not valid_cookies: raise Exception("无有效账号Cookie") # 随机返回一个有效Cookie return random.choice(valid_cookies) # 多账号轮换请求 def multi_account_request(url_list): for url in url_list: cookie = get_random_valid_cookie() response = requests.get(url, cookies=cookie) print(f"请求地址：{url}，使用Cookie账号：{cookie.get('username')}，状态码：{response.status_code}")

核心原理

筛选所有有效账号的 Cookie，通过随机函数实现轮换使用，降低单账号的请求频率，有效规避网站的账号限流反爬机制。

4.3 Cookie 自动更新机制

服务器会在响应中更新 Cookie（如刷新会话有效期），爬虫需自动捕获更新后的 Cookie 并覆盖存储：

python

运行

import requests # 带Cookie自动更新的请求函数 def request_with_auto_update_cookie(url, cookie_jar): response = requests.get(url, cookies=cookie_jar) # 判断服务器是否返回新Cookie if response.cookies: print("检测到Cookie更新，重新存储") # 覆盖存储更新后的Cookie save_cookie_with_pickle(response.cookies) return response # 使用示例 if __name__ == "__main__": cookie = smart_reuse_cookie() response = request_with_auto_update_cookie("https://user.example.com/info", cookie)

核心原理

每次发起请求后，检查响应中的 Cookie 数据；若服务器返回新的 Cookie，立即更新本地持久化存储，保证 Cookie 始终为最新有效状态。

五、Cookie 持久化与复用反爬规避技巧

5.1 规避 Cookie 异常检测技巧

1. 完整携带 Cookie 属性：仅携带name和value容易被识别，必须还原domain、path、secure等所有属性；
2. 禁止篡改 Cookie 有效期：手动修改expires会导致服务器校验失败，使用原始有效期；
3. 匹配请求头信息：Cookie 对应的 User-Agent、IP 地址需保持一致，避免 Cookie 与请求头不匹配；
4. 控制 Cookie 复用频率：同一 Cookie 不要高频访问同一接口，结合延时、多账号轮换降低风险。

5.2 处理 HttpOnly Cookie

HttpOnly 属性的 Cookie 无法通过 JavaScript 读取，但爬虫基于 HTTP 请求获取，不受影响：

python

运行

# 读取HttpOnly Cookie for cookie in cookie_jar: if cookie.has_nonstandard_attr("HttpOnly"): print(f"HttpOnly Cookie：{cookie.name}={cookie.value}")

原理：HttpOnly 是浏览器安全限制，爬虫直接解析 HTTP 响应头的Set-Cookie字段，可正常获取所有 Cookie 数据。

5.3 处理 SameSite Cookie 限制

针对 SameSite=Lax/Strict 的跨域 Cookie 限制，爬虫需保证请求域名与 Cookie 的domain完全一致：

python

运行

# 创建Cookie时严格指定Domain cookie_jar.set("session", "xxxx", domain="example.com", path="/") # 请求时使用匹配的域名 requests.get("https://example.com/user", cookies=cookie_jar)

六、四种 Cookie 存储方案对比与选型

表格

选型建议

1. 个人轻量爬虫：优先选择 Pickle 方案，代码极简，无需额外依赖；
2. 开发调试阶段：使用 JSON 方案，可直接查看 Cookie 内容，快速排查问题；
3. 多账号管理爬虫：使用关系型数据库，实现 Cookie 的系统化管理；
4. 分布式 / 高并发爬虫：使用 Redis 方案，提升性能，支持集群共享。

七、完整实战案例：自动登录 + Cookie 持久化 + 数据爬取

本案例整合所有核心知识点，实现模拟登录→Cookie 持久化存储→智能复用 Cookie→爬取用户数据的全流程功能：

python

运行

import requests import pickle # ===================== 配置区域 ===================== LOGIN_URL = "https://passport.example.com/login" TARGET_URL = "https://user.example.com/data" USERNAME = "your_username" PASSWORD = "your_password" COOKIE_FILE = "user_cookie.pkl" # ===================== 核心函数 ===================== def login_and_get_cookie(): """模拟登录，获取有效Cookie""" headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" } login_data = { "username": USERNAME, "password": PASSWORD, "remember": "true" } response = requests.post(LOGIN_URL, data=login_data, headers=headers) if response.status_code == 200 and "登录成功" in response.text: print("登录成功，获取Cookie") return response.cookies raise Exception("登录失败，请检查账号密码") def save_cookie(cookie_jar): """Pickle持久化存储Cookie""" with open(COOKIE_FILE, "wb") as f: pickle.dump(cookie_jar, f) def load_cookie(): """读取本地Cookie""" try: with open(COOKIE_FILE, "rb") as f: return pickle.load(f) except: return None def check_cookie(cookie_jar): """校验Cookie有效性""" headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"} try: response = requests.get(TARGET_URL, cookies=cookie_jar, headers=headers, timeout=5) return "用户数据" in response.text except: return False def get_target_data(): """核心爬取函数""" # 1. 读取本地Cookie cookie = load_cookie() # 2. 校验Cookie，无效则重新登录 if not cookie or not check_cookie(cookie): cookie = login_and_get_cookie() save_cookie(cookie) # 3. 复用Cookie爬取数据 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"} response = requests.get(TARGET_URL, cookies=cookie, headers=headers) print("="*50) print("爬取成功！用户数据：") print(response.text) return response.text # ===================== 执行入口 ===================== if __name__ == "__main__": get_target_data()

案例功能说明

1. 首次运行：自动执行登录，获取 Cookie 并存储到本地user_cookie.pkl；
2. 二次运行：直接读取本地 Cookie，校验有效后直接爬取数据，无需重复登录；
3. Cookie 失效：自动重新登录，更新本地 Cookie，保证爬取任务不间断；
4. 反爬适配：添加请求头，模拟浏览器访问，提升爬虫隐蔽性。

八、常见问题与解决方案

8.1 Cookie 存储后复用失效

1. 原因：Cookie 的 Domain/Path 配置错误、Cookie 已过期、服务器刷新了会话；
2. 解决方案：严格还原 Cookie 所有属性、添加 Cookie 有效性校验、开启自动更新机制。

8.2 Pickle 序列化报错

1. 原因：Python 版本不兼容、Cookie 文件损坏；
2. 解决方案：统一 Python 环境、删除损坏文件，重新获取存储 Cookie。

8.3 Redis 连接失败

1. 原因：Redis 服务未启动、IP / 端口配置错误、密码验证失败；
2. 解决方案：启动 Redis 服务、检查连接参数、配置正确的认证信息。

8.4 多线程并发读写 Cookie 异常

1. 原因：多个线程同时读写本地文件 / 数据库，导致数据冲突；
2. 解决方案：使用线程锁、改用 Redis 支持高并发读写、单线程统一管理 Cookie。