Python 爬虫数据处理：CSV 大文件分块读写解决爬虫内存溢出问题

前言

在 Python 爬虫实战开发中，爬取大规模数据（如千万级商品数据、海量日志数据、全网新闻数据）时，直接将所有数据加载到内存中进行 CSV 读写，极易触发内存溢出（OOM）问题，导致爬虫程序崩溃、服务器资源耗尽，甚至影响其他业务运行。传统的一次性读写 CSV 方案仅适用于小数据量场景，无法满足工业级爬虫的高并发、大数据量存储需求。

本文将深度剖析 Python 爬虫中 CSV 大文件处理的核心痛点，详解分块读写的底层原理与实战方案，结合完整可运行的爬虫代码案例，解决大数据量爬取场景下的内存瓶颈问题。本文所有依赖库均提供官方超链接，读者可直接访问获取安装与使用文档：

1. requests：Python 主流 HTTP 请求库
2. csv：Python 内置标准 CSV 处理库
3. pandas：高性能数据分析库（可选分块方案）
4. time：Python 内置时间控制库
5. random：Python 内置随机数库

本文聚焦无第三方依赖轻量化分块读写与高性能 pandas 分块读写两种方案，覆盖爬虫开发全场景，从原理剖析、代码实现、性能对比到问题排查，帮助开发者彻底解决爬虫 CSV 大文件内存溢出问题。

一、CSV 大文件处理核心痛点与内存溢出原理

1.1 传统 CSV 读写的缺陷

Python 爬虫开发中，开发者最常用的 CSV 读写方式为一次性读取 / 写入：通过csv.writer将所有爬取数据存储在列表中，最后统一写入文件；或通过csv.reader一次性加载整个文件到内存。这种方式的核心缺陷如下：

1. 内存占用与数据量正相关：爬取 10 万条数据占用 100MB 内存，爬取 1000 万条数据则会占用 10GB 以上内存，远超普通服务器的内存配置；
2. 程序稳定性极差：内存占用达到阈值后，操作系统会强制终止爬虫进程，导致已爬取数据丢失；
3. 无容错能力：写入过程中断电、程序崩溃，所有未写入数据全部失效，无法断点续存。

1.2 内存溢出（OOM）底层原理

内存溢出的本质是：爬虫程序向操作系统申请的内存空间，超过了系统分配的最大可用内存。

在 CSV 文件处理中，传统方案会将爬取的所有数据（字典、列表等对象）常驻内存，Python 的垃圾回收机制无法及时释放无用数据。随着爬取数据量持续增加，内存占用率不断攀升，最终触发MemoryError异常，程序直接崩溃。

对于 7×24 小时运行的分布式爬虫、全站爬虫而言，内存溢出是必须解决的核心问题，而分块读写是最轻量化、最高效的解决方案。

1.3 分块读写核心概念

分块读写，即将大文件拆分为多个固定大小的数据块（Chunk），爬虫程序每次仅处理一个数据块：写入时，累计指定数量的数据后批量写入文件并清空内存；读取时，每次仅加载指定行数的数据到内存，处理完成后立即释放。

核心优势：

1. 内存占用恒定，不受总数据量影响；
2. 程序稳定性大幅提升，支持超大规模数据处理；
3. 支持断点续存，写入中断后可从最后一个数据块恢复；
4. 无额外性能损耗，读写效率与一次性读写持平甚至更高。

二、前置环境准备与依赖库安装

2.1 环境要求

1. Python 版本：3.8 及以上（推荐 3.10+，兼容所有标准库与第三方库）；
2. 操作系统：Windows/Linux/MacOS（分块读写方案跨平台兼容）；
3. 内存配置：最低 2GB（分块方案可在低配置服务器稳定运行）。

2.2 依赖库安装

本文提供两种分块读写方案，依赖库分为标准库（无需安装）和第三方库（需安装）：

1. 标准库方案：csv、time、random、requests，其中requests需单独安装；
2. Pandas 方案：pandas，高性能分块处理首选。

安装命令：

bash

运行

# 安装HTTP请求库 pip install requests # 安装高性能数据分析库 pip install pandas

安装验证：

python

运行

# 验证库是否安装成功 import requests import csv import pandas as pd print("依赖库加载成功！")

三、方案一：Python 内置 csv 库实现轻量化分块读写（推荐爬虫原生方案）

3.1 核心原理

基于 Python内置 csv 标准库，无需安装任何第三方依赖，通过计数器 + 批量写入实现分块逻辑：

1. 初始化空列表存储临时数据块；
2. 爬虫每爬取一条数据，将数据追加到临时列表；
3. 监听临时列表长度，达到设定的分块大小（chunk_size）时，批量写入 CSV 文件；
4. 写入完成后清空临时列表，释放内存；
5. 爬虫结束后，将剩余未达到分块大小的数据写入文件，保证数据完整性。

该方案的核心优势：零依赖、轻量级、兼容性拉满，适合所有爬虫项目，尤其是嵌入式、低配置服务器场景。

3.2 分块写入 CSV 完整爬虫代码实现

本案例以爬取全网公开新闻数据为例，模拟大规模数据爬取，通过分块写入解决内存溢出问题。代码包含完整的爬虫请求、数据解析、分块写入、异常处理逻辑。

python

运行

import csv import requests import time import random class CSVChunkCrawler: def __init__(self, chunk_size: int = 1000, output_file: str = "crawler_data.csv"): """ 初始化分块爬虫配置 :param chunk_size: 分块大小，每1000条数据批量写入一次（可自定义） :param output_file: 输出CSV文件路径 """ self.chunk_size = chunk_size # 分块大小，核心参数 self.output_file = output_file self.temp_data = [] # 临时数据存储列表 self.total_count = 0 # 总数据计数 self.headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" } # 初始化CSV文件，写入表头（仅执行一次） self.init_csv_header() def init_csv_header(self): """初始化CSV文件表头，避免重复写入""" # 表头字段：根据爬取数据自定义 header = ["新闻ID", "新闻标题", "发布时间", "来源", "内容摘要", "爬取时间"] with open(self.output_file, "w", newline="", encoding="utf-8-sig") as f: writer = csv.writer(f) writer.writerow(header) print(f"CSV文件初始化完成，表头已写入：{self.output_file}") def write_chunk_to_csv(self): """将临时数据块批量写入CSV文件，核心分块写入方法""" if not self.temp_data: return # 追加模式写入文件，不覆盖原有数据 with open(self.output_file, "a", newline="", encoding="utf-8-sig") as f: writer = csv.writer(f) writer.writerows(self.temp_data) # 打印写入日志 print(f"成功写入{len(self.temp_data)}条数据，累计总数据：{self.total_count}") # 清空临时列表，释放内存（关键步骤，解决内存溢出） self.temp_data.clear() def crawl_news_data(self, page: int): """模拟单页新闻数据爬取，替换为真实爬虫接口即可""" try: # 模拟请求延时，避免请求过快 time.sleep(random.uniform(0.5, 1.5)) # 模拟生成10条新闻数据（真实场景替换为接口请求+数据解析） for i in range(10): news_id = f"N{page}_{i}" title = f"Python爬虫分块读写技术实战_{page}_{i}" publish_time = time.strftime("%Y-%m-%d %H:%M:%S") source = "科技新闻网" summary = "CSV分块读写解决爬虫内存溢出问题，适用于大规模数据爬取场景" crawl_time = time.strftime("%Y-%m-%d %H:%M:%S") # 构造数据行 data_row = [news_id, title, publish_time, source, summary, crawl_time] # 将数据加入临时列表 self.temp_data.append(data_row) self.total_count += 1 # 判断是否达到分块大小，达到则批量写入 if len(self.temp_data) >= self.chunk_size: self.write_chunk_to_csv() except Exception as e: print(f"第{page}页爬取失败，错误原因：{str(e)}") def start_crawl(self, max_page: int = 1000): """启动爬虫，支持自定义最大爬取页数""" print(f"爬虫启动，分块大小：{self.chunk_size}，最大爬取页数：{max_page}") start_time = time.time() # 循环爬取所有页面 for page in range(1, max_page + 1): self.crawl_news_data(page) # 每爬取100页打印进度 if page % 100 == 0: print(f"当前爬取进度：{page}/{max_page}页") # 爬虫结束，写入剩余数据 self.write_chunk_to_csv() end_time = time.time() # 输出爬虫统计信息 print("=" * 50) print(f"爬虫执行完成！") print(f"总爬取数据量：{self.total_count}条") print(f"总耗时：{round(end_time - start_time, 2)}秒") print(f"内存占用恒定：约{self.chunk_size * 0.1}MB（无内存溢出风险）") print("=" * 50) if __name__ == "__main__": # 实例化爬虫，分块大小设置为1000，可根据内存大小调整（500-5000最优） crawler = CSVChunkCrawler(chunk_size=1000, output_file="爬虫分块写入数据.csv") # 启动爬虫，爬取1000页数据（模拟10000条大规模数据） crawler.start_crawl(max_page=1000)

3.3 代码核心原理详解

1. 分块大小配置：chunk_size是核心参数，推荐设置为500-5000。值越小，内存占用越低；值越大，写入效率越高，开发者可根据服务器内存灵活调整；
2. 临时数据列表：temp_data仅存储当前分块的数据，写入文件后立即调用clear()方法释放内存，从根源避免内存堆积；
3. 文件写入模式：表头使用w模式（覆盖创建），分块数据使用a模式（追加写入），保证文件数据连续性；
4. 编码格式：使用utf-8-sig编码，解决 CSV 文件在 Excel 中打开乱码的问题；
5. 异常处理：捕获爬取过程中的网络异常、数据解析异常，保证爬虫稳定性。

3.4 分块读取 CSV 大文件完整代码实现

爬虫不仅需要写入数据，还需要读取已存储的 CSV 大文件进行数据分析、去重等操作。以下是基于内置csv库的分块读取代码：

python

运行

import csv def read_csv_in_chunks(file_path: str, chunk_size: int = 1000): """ 分块读取CSV大文件，避免内存溢出 :param file_path: CSV文件路径 :param chunk_size: 每次读取的行数 """ chunk = [] with open(file_path, "r", encoding="utf-8-sig") as f: reader = csv.reader(f) # 跳过表头 header = next(reader) print(f"CSV表头：{header}") print("开始分块读取数据...\n") for index, row in enumerate(reader, 1): chunk.append(row) # 达到分块大小则处理数据 if len(chunk) >= chunk_size: print(f"处理第{index//chunk_size}个数据块，数据量：{len(chunk)}条") # 在此处添加数据处理逻辑（去重、分析、清洗等） chunk.clear() # 处理最后一个数据块 if chunk: print(f"处理最后一个数据块，数据量：{len(chunk)}条") print("分块读取完成！") if __name__ == "__main__": # 分块读取爬虫生成的CSV大文件 read_csv_in_chunks(file_path="爬虫分块写入数据.csv", chunk_size=1000)

3.5 分块读取原理

1. 逐行读取 CSV 文件，不一次性加载整个文件；
2. 累计达到分块大小后，执行数据处理逻辑，随后清空临时列表；
3. 跳过表头，仅处理业务数据，内存占用仅为单分块数据大小。

四、方案二：Pandas 库实现高性能分块读写（大数据量优选）

4.1 核心原理

Pandas 是 Python 生态中高性能数据分析库，内置chunksize参数原生支持 CSV 分块读写，底层基于 C 语言优化，读写速度比内置csv库快 3-5 倍，适合千万级以上超大规模数据处理。

核心逻辑：

1. 写入：将爬取数据分块生成 DataFrame，批量追加到 CSV 文件；
2. 读取：通过chunksize参数指定分块大小，迭代读取数据块；
3. 内存优化：Pandas 自动管理数据对象内存，无需手动清空列表。

4.2 Pandas 分块写入 CSV 爬虫代码

python

运行

import pandas as pd import requests import time import random class PandasChunkCrawler: def __init__(self, chunk_size: int = 1000, output_file: str = "pandas_chunk_data.csv"): self.chunk_size = chunk_size self.output_file = output_file self.temp_df = [] self.total_count = 0 self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"} # 初始化表头 self.init_header() def init_header(self): """初始化表头""" columns = ["新闻ID", "新闻标题", "发布时间", "来源", "内容摘要", "爬取时间"] empty_df = pd.DataFrame(columns=columns) empty_df.to_csv(self.output_file, index=False, encoding="utf-8-sig") def write_pandas_chunk(self): """Pandas分块写入""" if not self.temp_df: return df = pd.DataFrame(self.temp_df) # 追加模式写入 df.to_csv(self.output_file, mode="a", header=False, index=False, encoding="utf-8-sig") print(f"Pandas写入{len(self.temp_df)}条数据，累计：{self.total_count}") self.temp_df.clear() def crawl_data(self, page): """模拟爬取数据""" time.sleep(random.uniform(0.2, 0.8)) for i in range(10): data = { "新闻ID": f"P{page}_{i}", "新闻标题": f"Pandas分块爬虫实战_{page}_{i}", "发布时间": time.strftime("%Y-%m-%d %H:%M:%S"), "来源": "Pandas大数据平台", "内容摘要": "Pandas分块读写高性能处理爬虫大数据", "爬取时间": time.strftime("%Y-%m-%d %H:%M:%S") } self.temp_df.append(data) self.total_count += 1 if len(self.temp_df) >= self.chunk_size: self.write_pandas_chunk() def start(self, max_page=1000): """启动爬虫""" start_time = time.time() print("Pandas分块爬虫启动...") for page in range(1, max_page+1): self.crawl_data(page) self.write_pandas_chunk() print(f"爬取完成，总数据：{self.total_count}条，耗时：{round(time.time()-start_time,2)}s") if __name__ == "__main__": crawler = PandasChunkCrawler(chunk_size=1000) crawler.start(max_page=1000)

4.3 Pandas 分块读取大文件代码

python

运行

import pandas as pd def pandas_read_chunk(file_path, chunk_size=1000): """Pandas分块读取CSV大文件""" # 迭代读取分块数据 chunk_iter = pd.read_csv(file_path, chunksize=chunk_size, encoding="utf-8-sig") for i, chunk in enumerate(chunk_iter, 1): print(f"第{i}个分块，数据量：{len(chunk)}条") # 数据处理逻辑 print(f"分块数据预览：\n{chunk.head(2)}\n") print("Pandas分块读取完成！") if __name__ == "__main__": pandas_read_chunk("pandas_chunk_data.csv", chunk_size=1000)

五、两种分块方案性能对比与选型指南

5.1 性能测试数据

测试环境：Python3.10、8GB 内存、Windows11，测试数据量：100 万条

表格

5.2 选型指南

1. 选择内置 csv 库方案：

   • 爬虫项目要求零第三方依赖；
   • 服务器内存极低（2GB 以下）；
   • 数据量在百万级以内；
   • 跨平台兼容性要求极高。

2. 选择 Pandas 分块方案：

   • 数据量超过千万级；
   • 需要同时进行数据清洗、分析、可视化；
   • 追求极致的读写效率；
   • 服务器配置较高（4GB 以上内存）。

六、爬虫 CSV 分块读写高级优化技巧

6.1 分块大小动态调整

固定分块大小无法适配所有场景，推荐根据数据大小动态调整：

• 单条数据小于 1KB：分块大小设置为 5000；
• 单条数据 1KB-10KB：分块大小设置为 1000；
• 单条数据大于 10KB：分块大小设置为 500。

6.2 断点续存实现

在分块写入时，记录最后写入的数据 ID，爬虫重启后从该 ID 继续爬取，避免数据重复爬取：

python

运行

# 断点续存核心代码 def save_last_id(self, last_id): with open("last_id.txt", "w") as f: f.write(str(last_id))

6.3 内存实时监控

结合psutil库实时监控内存占用，超过阈值自动调整分块大小：

bash

运行

pip install psutil

python

运行

import psutil # 获取当前进程内存占用（MB） memory_usage = psutil.Process().memory_info().rss / 1024 / 1024

6.4 数据压缩存储

对于超大规模数据，分块写入时同时压缩文件，减少磁盘占用：

python

运行

import gzip # 分块写入压缩CSV文件 with gzip.open("data.csv.gz", "at", encoding="utf-8-sig") as f: writer = csv.writer(f)

七、常见问题与解决方案

7.1 CSV 文件打开乱码

问题原因：编码格式不统一；解决方案：所有文件读写使用utf-8-sig编码，强制兼容 Excel、WPS 等软件。

7.2 分块写入后数据重复

问题原因：爬虫异常中断后，临时数据未写入文件，重启后重复爬取；解决方案：每次写入数据后记录断点，异常重启后从断点恢复。

7.3 内存溢出仍出现

问题原因：分块大小设置过大，或未清空临时列表；解决方案：减小分块大小，严格执行temp_data.clear()释放内存。

7.4 写入速度过慢

问题原因：分块大小过小，频繁 IO 操作；解决方案：适当增大分块大小，或使用 Pandas 方案提升效率。

八、总结

本文深度剖析了 Python 爬虫中 CSV 大文件处理的内存溢出问题，从底层原理、两种分块读写方案、代码实战、性能优化到问题排查，提供了全链路解决方案：

1. 传统一次性 CSV 读写是内存溢出的核心原因，分块读写是最有效的解决方式；
2. 内置 csv 库方案零依赖、轻量级，适合轻量化爬虫；Pandas 方案高性能，适合大数据量场景；
3. 分块大小、编码格式、临时数据清空是保证方案稳定运行的核心关键点；
4. 结合断点续存、内存监控、数据压缩等优化技巧，可实现工业级稳定爬虫。