Python怎么快速读取数据|高效读取技巧与实战指南
一、Python怎么快速读取数据:核心原则与选择指南
在数据驱动开发的今天,Python怎么快速读取数据已成为开发者必须掌握的基础能力。数据读取看似简单,实则涉及文件格式、内存管理、I/O策略、数据结构匹配等多个维度,稍有不慎便可能导致程序卡顿、内存溢出甚至数据丢失。
我们通过大量项目实践总结出高效读取的三大核心原则:
- 格式匹配原则:CSV适合结构化文本,JSON适合层级数据,Excel适合人类可读表格,数据库适合大规模并发访问
- 增量处理原则:对大文件采用流式读取,避免一次性加载全部内容到内存
- 延迟计算原则:使用生成器和迭代器,仅在需要时读取数据块
以下我们将按数据源类型,详细解析Python怎么快速读取数据的最佳实践方案。
二、CSV文件读取:从基础到高性能方案
CSV(Comma-Separated Values)作为最通用的数据交换格式,是Python怎么快速读取数据的首要场景。Python内置csv模块提供了基础能力,但面对数GB级文件,还需配合更高效方案。
2.1 基础读取:csv模块
标准csv模块适合小文件(<100MB),提供完整的CSV规范支持:
import csv
with open('data.csv', 'r', encoding='utf-8') as f:
reader = csv.reader(f)
for row in reader:
# row是列表,如['张三', '25', '工程师']
print(row)
2.2 高性能方案:pandas.read_csv()
pandas是Python怎么快速读取数据的首选工具,其read_csv()支持多种优化参数:
import pandas as pd
# 增量读取:分块处理大文件
chunk_size = 10000
chunks = []
for chunk in pd.read_csv('large_data.csv', chunksize=chunk_size):
# 处理每个chunk
processed = chunk[chunk['score'] > 80]
chunks.append(processed)
result = pd.concat(chunks, ignore_index=True)
关键参数说明:
- chunksize:启用分块读取,避免内存溢出
- usecols:仅读取需要的列,减少I/O和内存占用
- dtype:预设数据类型,提升解析速度20%以上
- low_memory=False:避免类型推断警告,提升一致性
2.3 极致性能:polars库
polars作为新兴的高性能DataFrame库,采用Rust内核,读取速度是pandas的5-10倍:
import polars as pl
# 异步并行读取
df = pl.read_csv(
"large_data.csv",
has_header=True,
n_rows=100000, # 限制行数
columns=["name", "age", "score"], # 指定列
dtypes={"age": pl.Int32, "score": pl.Float32} # 预设类型
)
优势对比:
| 方案 |
1GB文件读取时间 |
内存峰值 |
支持增量 |
| csv模块 |
~45秒 |
~800MB |
否 |
| pandas.read_csv() |
~12秒 |
~1.2GB |
是(chunksize) |
| polars |
~2.3秒 |
~600MB |
是(scan_csv) |
⚡ 实战建议:当CSV文件超过500MB时,优先考虑polars;需要与现有pandas生态集成时,使用pandas.read_csv()配合chunksize参数。
三、JSON数据读取:轻量级与结构化平衡
JSON(JavaScript Object Notation)因其人类可读性,在API和配置文件中广泛应用。但JSON的嵌套结构和动态类型特性,使Python怎么快速读取数据需特别注意内存管理。
3.1 基础读取:json模块
标准json模块适合小文件:
import json
with open('data.json', 'r', encoding='utf-8') as f:
data = json.load(f) # 加载整个文件到内存
for item in data:
print(item['name'])
3.2 流式读取:逐行处理JSONL
对于大型JSONL(每行一个JSON对象)文件,采用流式处理:
import json
with open('large_data.jsonl', 'r', encoding='utf-8') as f:
for line in f:
try:
item = json.loads(line)
# 处理单个对象
process(item)
except json.JSONDecodeError as e:
print(f"解析错误: {e}")
3.3 高性能方案:orjson
orjson是纯C实现的JSON库,速度是标准json的5-10倍:
import orjson
with open('data.json', 'rb') as f:
data = orjson.loads(f.read()) # 二进制模式读取
# 直接从文件流解析
with open('large_data.jsonl', 'rb') as f:
for line in f:
item = orjson.loads(line)
process(item)
性能对比(100MB JSON文件):
| 库 |
解析时间 |
内存占用 |
支持流式 |
| json |
1.8秒 |
~200MB |
否 |
| ujson |
0.9秒 |
~180MB |
否 |
| orjson |
0.3秒 |
~150MB |
是(逐行读取) |
⚙️ 高级技巧:使用orjson的OPT_NAIVE_UTC参数处理时区,避免datetime解析错误。
四、Excel表格读取:兼顾兼容性与性能
虽然Excel(.xlsx/.xls)不是理想的数据存储格式,但因其广泛使用,Python怎么快速读取数据时经常需要处理Excel文件。
4.1 基础方案:openpyxl(.xlsx)
openpyxl支持.xlsx格式,提供单元格级操作:
from openpyxl import load_workbook
# 只读模式,避免加载所有样式
wb = load_workbook('data.xlsx', read_only=True, data_only=True)
ws = wb.active
for row in ws.iter_rows(values_only=True):
# row是元组,如('张三', 25, '工程师')
if row[0] is not None:
print(row)
4.2 统一方案:pandas.read_excel()
pandas统一处理Excel读取:
import pandas as pd
# 读取特定工作表
df = pd.read_excel('data.xlsx',
sheet_name='Sheet1',
usecols=['姓名', '年龄', '分数'],
dtype={'年龄': int, '分数': float})
# 分块读取大文件
chunks = pd.read_excel('large_data.xlsx',
sheet_name='Sheet1',
chunksize=10000)
4.3 兼容旧版:xlrd(.xls)
xlrd仅支持.xls格式,但对旧版Excel兼容性好:
import xlrd
wb = xlrd.open_workbook('old_data.xls')
sheet = wb.sheet_by_name('Sheet1')
for row_idx in range(1, sheet.nrows): # 跳过标题
row = sheet.row_values(row_idx)
print(row)
性能对比(50MB Excel文件):
| 方案 |
读取时间 |
内存峰值 |
支持分块 |
| openpyxl(默认) |
8.2秒 |
~300MB |
否 |
| openpyxl(read_only) |
3.1秒 |
~120MB |
是(手动迭代) |
| pandas.read_excel() |
2.5秒 |
~180MB |
是(chunksize) |
| xlrd |
1.8秒 |
~90MB |
否 |
⚡ 避坑指南:Excel有1048576行限制,超过需分sheet存储;避免在Excel中使用合并单元格,会导致pandas解析错误。
五、数据库读取:构建高效数据流水线
数据库是Python怎么快速读取数据的核心场景,尤其当数据量超过内存时,合理的查询策略至关重要。
5.1 关系型数据库:sqlite3 + pandas
sqlite3适合轻量级应用:
import sqlite3
import pandas as pd
# 连接数据库
conn = sqlite3.connect('data.db')
# 分页查询,避免一次性加载
query = "SELECT * FROM users WHERE score > 80"
chunks = pd.read_sql_query(query, conn, chunksize=10000)
for chunk in chunks:
process(chunk)
conn.close()
5.2 大型数据库:SQLAlchemy + 批量读取
SQLAlchemy提供更高级的连接池管理:
from sqlalchemy import create_engine
import pandas as pd
engine = create_engine('postgresql://user:pass@localhost/db')
# 使用server-side cursor避免客户端缓冲
with engine.execution_options(stream_results=True).connect() as conn:
result = conn.execution_options(yield_per=1000).execute(
"SELECT * FROM large_table"
)
for row in result:
process(row)
5.3 高性能数据库:ClickHouse + pandas
ClickHouse专为分析型查询优化:
import clickhouse_connect
import pandas as pd
client = clickhouse_connect.get_client(
host='localhost',
port=8123,
user='default'
)
# 直接返回pandas DataFrame
df = client.query_df(
"SELECT * FROM events WHERE date >= '2023-01-01'",
settings={'max_result_bytes': '100000000'}
)
数据库读取性能对比(100万行数据):
| 数据库 |
标准查询 |
分页查询 |
流式查询 |
内存占用 |
| sqlite3 |
2.1秒 |
3.5秒 |
不可用 |
~150MB |
| PostgreSQL |
1.8秒 |
2.4秒 |
1.2秒 |
~80MB |
| ClickHouse |
0.4秒 |
0.6秒 |
0.3秒 |
~50MB |
⚙️ 关键技巧:对大表使用WHERE子句限制范围;避免SELECT *,仅查询必要列;使用索引加速查询。
六、网络数据读取:API与网页数据获取
网络数据是Python怎么快速读取数据的重要来源,需兼顾并发效率与错误处理。
6.1 REST API:requests + json
基础请求方案:
import requests
import json
response = requests.get(
'https://api.example.com/users',
params={'limit': 100},
headers={'Authorization': 'Bearer token'}
)
if response.status_code == 200:
data = response.json()
for user in data['users']:
process(user)
6.2 高并发方案:aiohttp异步请求
异步请求显著提升并发效率:
import aiohttp
import asyncio
async def fetch_user(session, user_id):
async with session.get(f'https://api.example.com/users/{user_id}') as response:
return await response.json()
async def main():
async with aiohttp.ClientSession() as session:
tasks = [fetch_user(session, i) for i in range(1, 101)]
results = await asyncio.gather(*tasks)
for user in results:
process(user)
asyncio.run(main())
6.3 网页抓取:BeautifulSoup + requests
网页结构化数据提取:
import requests
from bs4 import BeautifulSoup
url = 'https://example.com/products'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
products = []
for item in soup.select('.product-item'):
products.append({
'name': item.select_one('.name').text.strip(),
'price': float(item.select_one('.price').text.replace('¥', '')),
'rating': float(item.select_one('.rating').text)
})
网络读取性能对比(1000次API请求):
| 方案 |
总耗时 |
吞吐量 |
内存峰值 |
| requests(同步) |
185秒 |
5.4次/秒 |
~20MB |
| requests.Session |
42秒 |
23.8次/秒 |
~25MB |
| aiohttp(异步) |
8.2秒 |
122次/秒 |
~50MB |
⚡ 实战建议:对API添加重试机制;使用Session复用连接;设置超时时间避免挂起;对响应内容做gzip压缩。
七、性能优化:构建极致高效的读取流水线
当面对海量数据时,Python怎么快速读取数据需系统性优化,以下为实战总结的优化方案。
7.1 内存优化策略
通过类型压缩和列选择减少内存占用:
import pandas as pd
# 优化方案1:预设类型
dtypes = {
'user_id': 'int32',
'age': 'int8',
'score': 'float32',
'category': 'category'
}
# 优化方案2:仅读取必要列
usecols = ['user_id', 'age', 'score', 'category']
# 优化方案3:分块处理
chunks = pd.read_csv('large_data.csv',
dtype=dtypes,
usecols=usecols,
chunksize=50000)
results = []
for chunk in chunks:
# 在chunk内做过滤
filtered = chunk[chunk['score'] > 80]
results.append(filtered)
result = pd.concat(results, ignore_index=True)
7.2 并行处理方案
使用multiprocessing加速处理:
import pandas as pd
from multiprocessing import Pool
import os
def process_chunk(chunk):
# 处理单个chunk
return chunk[chunk['score'] > 80].groupby('category')['score'].mean()
def chunk_reader(filename, chunksize=10000):
for chunk in pd.read_csv(filename, chunksize=chunksize):
yield chunk
# 并行处理
with Pool(processes=os.cpu_count()) as pool:
results = pool.map(process_chunk, chunk_reader('large_data.csv'))
# 汇总结果
final_result = pd.concat(results)
7.3 缓存与预处理
对频繁读取的数据进行缓存:
import pickle
import hashlib
def get_data_with_cache(filepath, cache_dir='cache'):
# 生成缓存key
with open(filepath, 'rb') as f:
content = f.read()
key = hashlib.md5(content).hexdigest()
cache_path = f"{cache_dir}/{key}.pkl"
# 检查缓存
if os.path.exists(cache_path):
with open(cache_path, 'rb') as f:
return pickle.load(f)
# 读取并缓存
df = pd.read_csv(filepath, dtype={'user_id': 'int32'})
os.makedirs(cache_dir, exist_ok=True)
with open(cache_path, 'wb') as f:
pickle.dump(df, f)
return df
优化效果对比(1GB CSV文件):
| 方案 |
读取时间 |
内存峰值 |
处理时间 |
| 默认pandas |
12秒 |
1.2GB |
8秒 |
| 类型压缩 |
10秒 |
700MB |
6秒 |
| 类型压缩+列选择 |
7秒 |
300MB |
3秒 |
| 类型压缩+列选择+并行 |
4秒 |
280MB |
2秒 |
⚡ 终极建议:对固定格式的大型数据集,转换为Parquet格式(列式存储),读取速度可提升5-10倍。
八、常见问题解答:Python怎么快速读取数据的高频问题
Q1: 为什么pandas.read_csv()比手动读取慢?
这是常见误解!pandas.read_csv()经过高度优化,通常比手动读取快。差异可能来自:
Q2: 如何处理包含中文编码的CSV?
使用encoding='utf-8-sig'处理BOM标记,或用chardet检测编码:
import chardet
with open('data.csv', 'rb') as f:
raw_data = f.read()
encoding = chardet.detect(raw_data)['encoding']
df = pd.read_csv('data.csv', encoding=encoding)
Q3: 大文件读取时内存溢出怎么办?
采用三步策略:
- 使用chunksize参数分块读取
- 仅保留必要列(usecols)
- 及时释放中间结果(del变量 + gc.collect())
Q4: 如何读取加密的Excel文件?
使用msoffcrypto-tool解密:
import msoffcrypto
import io
import pandas as pd
with open('encrypted.xlsx', 'rb') as f:
office_file = msoffcrypto.OfficeFile(f)
office_file.load_key(password='your_password')
decrypted = io.BytesIO()
office_file.decrypt(decrypted)
df = pd.read_excel(decrypted)