Python数据文件加载实战：从CSV到Parquet的生产级解决方案

1. 项目概述：为什么“加载不同数据文件”是每个Python从业者绕不开的基本功

“Loading Different Data Files in Python”——这个标题看似平淡，甚至有点教科书味儿，但在我带过的37个数据分析/工程落地项目里，超过82%的线上故障、调试卡点和交付延期，根源都出在“文件加载”这一步。不是模型不收敛，不是算法不精准，而是——CSV里藏着BOM头没处理，Excel的合并单元格把pandas读成NaN海，JSON嵌套太深导致json.loads()直接报RecursionError，或者更隐蔽的：Parquet文件用pyarrow读出来列类型全错，下游计算全崩。这些都不是理论问题，是每天发生在Jupyter Notebook、Airflow DAG、FastAPI服务启动日志里的真实现场。

我试过用open()硬读10GB的TSV，也踩过pd.read_csv()默认engine='c'却对含特殊转义符的字段静默截断的坑；见过同事为读一个带密码保护的Excel反复重装openpyxl和xlrd，最后发现只是版本冲突；也亲手把一个本该5秒加载的HDF5文件拖到47秒——只因没指定mode='r'，触发了全量元数据扫描。所以，“加载不同数据文件”从来不是“调个函数就行”的事，它是一条横跨编码解析、内存管理、IO调度、格式协议、库生态兼容性的隐性技术链。你面对的不是文件，是数据生产方的工具链、历史遗留习惯、甚至某次临时导出时鼠标多点的一下“UTF-8 with BOM”。

这篇文章写给三类人：刚学完pandas基础想实战的新手，能跑通demo但一碰真实数据就报错；做ETL的工程师，被业务方甩来五花八门的“原始数据包”，急需一套可复用、可审计、可监控的加载方案；还有架构师，需要评估不同格式在实时管道中的吞吐瓶颈与序列化开销。全文不讲抽象原理，只拆解真实场景下的加载动作：从最简单的文本到最复杂的嵌套二进制，每种格式我会告诉你——该用哪个库、为什么必须用它、参数怎么设（附计算依据）、常见陷阱在哪、以及当它突然不工作时，30秒内如何定位根因。所有代码均经Python 3.9+、pandas 2.0+、pyarrow 14+实测，拒绝“理论上可行”。

2. 核心思路拆解：为什么不能只靠pandas.read_*？加载策略的本质是“协议匹配”

2.1 文件加载不是I/O操作，而是“协议解析”过程

很多人误以为pd.read_csv("data.csv")只是把磁盘文件读进内存。错。它实际执行的是一个多层协议解析流水线：

1. 物理层：操作系统通过read()系统调用获取字节流（可能触发page cache、预读等）；
2. 编码层：将字节流按指定编码（如utf-8）解码为Unicode字符串（若编码错误，errors='replace'会悄悄替换掉乱码）；
3. 分隔层：按sep=','切分字符串，但需处理引号包裹的逗号（"a,b",c）、转义符（a\,b）等；
4. 类型推断层：扫描前100行（默认nrows=100）猜测每列是int64还是object，但遇到1,2,3,4.5会全推成float64，后续astype(int)直接报错；
5. 结构映射层：将解析结果映射为DataFrame的Index、Columns、values内存布局。

提示：pandas的read_*函数本质是封装了底层解析器的胶水层。read_csv()默认用C引擎（快但容错差），engine='python'则用纯Python实现（慢3-5倍但支持复杂分隔符）。这不是性能选择题，而是协议鲁棒性选择题——当你的CSV由老旧ERP系统导出，含\r\n混用、空行、注释行时，engine='python'是唯一活路。

2.2 格式选型逻辑：按“数据特征”而非“文件后缀”决策

业务方发来一个.txt文件，你第一反应是read_csv()？危险。.txt只是容器，内容可能是：

• 纯CSV（逗号分隔）→pd.read_csv(..., sep=',')
• 制表符分隔（TSV）→pd.read_csv(..., sep='\t')
• 固定宽度（银行对账单）→pd.read_fwf(...)
• JSON Lines（每行一个JSON对象）→pd.read_json(..., lines=True)

我见过最典型的误判：某电商日志是.log后缀，内容却是{"user_id":123,"event":"click","ts":"2023-01-01T10:00:00Z"}。团队用open().readlines()逐行json.loads()，耗时23秒；改用pd.read_json("data.log", lines=True)，耗时1.8秒——因为后者直接调用orjson（C实现）批量解析，且跳过Python GIL锁。

注意：文件后缀是谎言，内容结构才是真相。我的做法是：先用file命令（Linux/macOS）或chardet库探测编码，再用head -n 5 data.txt看前5行结构，最后决定解析器。永远不要凭后缀猜协议。

2.3 内存与性能的底层博弈：为什么大文件必须流式加载？

当文件体积超过可用内存的20%，pandas.read_*会触发OOM（Out of Memory）。但问题不在“读”，而在“全量加载”。例如一个8GB的CSV，read_csv()默认一次性载入全部数据，即使你只需要统计某列均值。

解决方案不是换更快的CPU，而是改变数据流动范式：

• 分块读取（Chunking）：pd.read_csv(..., chunksize=10000)返回TextFileReader迭代器，每次只加载1万行；
• 列裁剪（Column Pruning）：usecols=['id', 'amount']跳过无关列，减少内存占用40%-70%；
• 类型预设（Dtype Specification）：dtype={'id': 'category', 'amount': 'float32'}避免pandas自动推断的object类型（内存占用是float32的4倍）；
• 延迟解析（Lazy Evaluation）：Dask或Polars的read_csv()返回延迟对象，仅在.compute()时真正执行。

实测对比：读取5GB销售数据（1亿行×10列），pandas全量加载需12GB内存、耗时89秒；用chunksize=50000+dtype优化后，峰值内存压至2.3GB，总耗时61秒（含后续聚合）。

3. 六大核心格式深度解析：从文本到二进制的完整加载手册

3.1 CSV/TSV：最简单也最危险的格式

为什么危险？因为它的“简单”是假象——无统一标准，各系统导出规则天差地别。

核心参数配置逻辑：

• sep：必须显式指定！','（CSV）、'\t'（TSV）、';'（欧洲Excel）、'|'（某些ETL工具）。永远不要依赖默认值。
• encoding：中文环境首选'utf-8-sig'（自动跳过BOM头），而非'utf-8'。若报UnicodeDecodeError，用chardet.detect(open('f.csv','rb').read(10000))探测真实编码。
• quotechar&escapechar：当字段含逗号时，Excel用双引号包裹（"Smith, John",25），但有些系统用反斜杠转义（Smith\, John,25）。quotechar='"'（默认）和escapechar='\\'需同步设置。
• na_values：业务数据中'N/A'、'NULL'、'-'常被当作缺失值，需显式传入na_values=['N/A', 'NULL', '-']，否则pandas视其为字符串。

避坑实操：

# ❌ 危险写法：依赖默认，不处理BOM和异常字符 df = pd.read_csv("sales.csv") # ✅ 生产级写法：显式控制所有关键环节 import chardet with open("sales.csv", "rb") as f: raw = f.read(10000) encoding = chardet.detect(raw)['encoding'] or 'utf-8-sig' df = pd.read_csv( "sales.csv", encoding=encoding, sep=',', # 显式声明 quotechar='"', escapechar='\\', na_values=['N/A', 'NULL', '-', ''], keep_default_na=False, # 关闭pandas默认NA识别，完全由na_values控制 dtype={'order_id': 'string', 'amount': 'float32'} # 预设类型，省内存 )

实操心得：我在某金融项目中发现，上游系统导出的CSV在金额列插入了不可见的U+200E（左向箭头符），导致astype(float)失败。最终用df['amount'].str.replace(r'[\u200e\u200f\u202a-\u202e]', '', regex=True)清洗才解决。永远假设文本文件里藏着你看不见的Unicode控制符。

3.2 Excel（.xls/.xlsx）：微软生态的兼容性黑洞

为什么是黑洞？因为Excel文件本质是ZIP压缩包，内含XML、二进制流、公式缓存等。xlrd、openpyxl、pyxlsb三个库支持不同子格式，且版本间互不兼容。

选型决策树：

文件类型	推荐库	原因	限制
.xlsx（现代）	openpyxl	支持样式、图表、公式，内存友好	不支持.xls
.xls（旧版）	xlrd<2.0	唯一支持.xls的库	2.0+已移除.xls支持
.xlsb（二进制）	pyxlsb	加载速度最快（比.xlsx快3倍）	不支持样式

关键参数与陷阱：

• engine：pd.read_excel()的engine参数必须匹配文件类型。.xlsx用'openpyxl'，.xls用'xlrd'（需pip install xlrd==1.2.0），.xlsb用'pyxlsb'。
• sheet_name：可为0（首张）、'Sheet1'（名称）、None（读取所有表，返回dict）。注意：None会消耗2倍内存，因需为每张表单独解析。
• header：Excel常有合并标题行（如第0行是公司名，第1行是部门名，第2行才是列名）。此时header=[1,2]可将第1、2行作为MultiIndex列。
• skiprows：跳过前N行（如报表页眉），但skiprows=2会跳过第0、1行，索引从第2行开始计数。

生产级代码：

# ✅ 自动识别Excel格式并加载 import pandas as pd from pathlib import Path def safe_read_excel(filepath): ext = Path(filepath).suffix.lower() if ext == '.xls': engine = 'xlrd' # xlrd 2.0+不支持.xls，强制降级 try: import xlrd if xlrd.__version__ >= '2.0': raise ImportError("xlrd>=2.0不支持.xls，请pip install xlrd==1.2.0") except ImportError: pass elif ext == '.xlsb': engine = 'pyxlsb' else: # .xlsx engine = 'openpyxl' return pd.read_excel( filepath, engine=engine, sheet_name=0, # 默认首张表，避免内存爆炸 header=1, # 跳过第0行标题，第1行为列名 skiprows=0, # 若需跳过页眉，此处设为具体行数 dtype=str # 先全读为字符串，后续再转换，避免数字截断 ) df = safe_read_excel("report.xls")

注意：Excel的日期列是最大雷区。openpyxl读出的是datetime对象，但xlrd读出的是浮点数（Excel日期序列号）。统一方案：加载后用pd.to_datetime(df['date'], unit='d', origin='1899-12-30')标准化。

3.3 JSON/JSONL：结构化数据的双刃剑

JSON vs JSONL（JSON Lines）：

• JSON：单个大对象，如{"users": [{"id":1}, {"id":2}]}→ 适合小数据，pd.read_json()直接解析。
• JSONL：每行一个独立JSON对象，如{"id":1}\n{"id":2}\n→ 适合大数据流，pd.read_json(..., lines=True)逐行解析。

核心痛点与解法：

• 嵌套过深：{"user": {"profile": {"name": "Alice"}}}→pd.json_normalize()展平：

  df = pd.json_normalize(data, sep='_') # 生成列'user_profile_name'

• 类型混乱：同一字段有时是int，有时是null→dtype无法预设，用convert_dtypes()自动推断：

  df = pd.read_json("data.json").convert_dtypes() # 将int64转为Int64（支持null）

• 大文件OOM：10GB JSONL文件不能read_json(lines=True)全量加载 → 改用生成器：

  def jsonl_generator(filepath, batch_size=10000): batch = [] with open(filepath, 'r', encoding='utf-8') as f: for line in f: if line.strip(): # 跳过空行 batch.append(json.loads(line)) if len(batch) >= batch_size: yield pd.DataFrame(batch) batch.clear() if batch: yield pd.DataFrame(batch) for batch_df in jsonl_generator("big.jsonl"): process(batch_df) # 每批处理，内存可控

实操心得：某物联网项目中，设备上报的JSONL含毫秒级时间戳"ts": 1712345678901。pd.read_json(lines=True)默认将其转为int64，但后续pd.to_datetime()需指定unit='ms'。若忘记，时间全错成1970年。所有时间戳字段，加载后第一件事就是pd.to_datetime(df['ts'], unit='ms')。

3.4 Parquet：大数据时代的事实标准

为什么Parquet是终极答案？它不是简单“存储格式”，而是列式存储+压缩+元数据+类型感知的综合体。相比CSV，优势如下：

维度	CSV	Parquet
存储大小	无压缩，纯文本	Snappy/Zstd压缩，体积减60%-80%
读取速度	全量扫描，IO密集	列裁剪（只读需列），跳过无关数据块
类型安全	字符串为主，易出错	内置Schema，int32/timestamp[ns]等精确类型
兼容性	所有工具支持	需Arrow生态（PyArrow/DuckDB/Spark）

PyArrow是Parquet的黄金搭档：

• pa.parquet.read_table()：返回Arrow Table（内存效率最高，零拷贝）；
• pq.read_pandas()：返回pandas DataFrame（兼容性好，但有内存拷贝）；
• datasetAPI：支持分区目录（/year=2023/month=01/），谓词下推（filter=ds.field('amount') > 100）。

生产级加载代码：

import pyarrow as pa import pyarrow.parquet as pq import pyarrow.dataset as ds # ✅ 方案1：小文件，直接读Table（推荐） table = pq.read_table("data.parquet") df = table.to_pandas() # 或直接用table，避免转pandas # ✅ 方案2：大文件+列裁剪 table = pq.read_table( "data.parquet", columns=['user_id', 'event_type', 'ts'], # 只读这三列 use_pandas_metadata=True # 读取pandas自定义元数据（如category） ) # ✅ 方案3：分区数据集，带过滤 dataset = ds.dataset("s3://bucket/logs/", format="parquet") filtered_table = dataset.to_table( filter=ds.field("date") == "2023-01-01" )

注意：Parquet的timestamp类型默认时区为UTC。若数据是本地时区（如Asia/Shanghai），需在写入时指定use_deprecated_int96_timestamps=False并设置timezone='Asia/Shanghai'，否则读取后tz_localize()会出错。

3.5 HDF5：科学计算的老牌劲旅

适用场景：需要随机访问、多数据集共存、支持压缩的科研数据（如气象、基因测序）。

核心概念：

• File：HDF5文件容器；
• Group：类似文件夹，组织数据集；
• Dataset：实际数据数组（支持NumPy所有类型）；
• Attribute：元数据（如单位、创建时间）。

pandas与HDF5的协作模式：

• pd.HDFStore：pandas专用接口，支持put/get，但已标记为deprecated；
• h5py：底层库，直接操作Dataset，灵活性高；
• PyTables：面向表格数据优化，支持查询（where条件）。

安全加载流程：

import h5py import numpy as np def load_hdf5_dataset(filepath, dataset_path, start=0, end=None): """安全加载HDF5中指定Dataset的切片""" with h5py.File(filepath, 'r') as f: dset = f[dataset_path] # 检查数据类型和形状 print(f"Dataset {dataset_path}: shape={dset.shape}, dtype={dset.dtype}") # 分块读取，避免大数组OOM if end is None: end = dset.shape[0] data = dset[start:end] # 触发实际读取 # 若为字符串，需解码（HDF5存bytes） if dset.dtype == 'object': data = np.array([s.decode('utf-8') for s in data]) return data # 示例：加载气象数据中的温度数组 temp_data = load_hdf5_dataset("weather.h5", "/2023/temperature", start=0, end=10000)

提示：HDF5的object类型（存储Python对象）是性能杀手。生产环境应避免，改用vlen（可变长字符串）或结构化dtype（np.dtype([('name', 'S10'), ('value', 'f4')])）。

3.6 数据库导出文件（SQL Dump）：被忽视的结构化宝藏

典型场景：DBA提供dump.sql，内容是INSERT INTO users VALUES (1,'Alice');。这不是SQL执行文件，而是结构化数据源。

解析策略：

• 小文件（<10MB）：用sqlite3内存数据库导入再导出：

  import sqlite3 import pandas as pd conn = sqlite3.connect(':memory:') with open('dump.sql', 'r') as f: conn.executescript(f.read()) # 执行所有SQL df = pd.read_sql_query("SELECT * FROM users;", conn)

• 大文件（>10MB）：正则提取INSERT语句，用csv.reader解析VALUES：

  import re import csv from io import StringIO def parse_sql_inserts(sql_file): with open(sql_file, 'r', encoding='utf-8') as f: content = f.read() # 匹配 INSERT INTO table (...) VALUES (...), (...); pattern = r"INSERT\s+INTO\s+`?(\w+)`?\s*\((.*?)\)\s*VALUES\s*(\(.*?\));" matches = re.findall(pattern, content, re.DOTALL | re.IGNORECASE) for table, cols, values_block in matches: # 清理列名和值 columns = [c.strip().strip('`') for c in cols.split(',')] # values_block形如 "(1,'Alice'),(2,'Bob')" values_str = re.sub(r'[();]', '', values_block) reader = csv.reader(StringIO(values_str), quotechar="'", skipinitialspace=True) for row in reader: yield table, columns, row # 使用 for table, cols, row in parse_sql_inserts("dump.sql"): if table == 'users': df = pd.DataFrame([row], columns=cols)

注意：SQL dump中的转义符（\'）和NULL值（NULL）需特殊处理。csv.reader的quotechar="'"和escapechar='\\'可应对大部分情况。

4. 统一加载框架设计：让10种格式共用一套API

4.1 为什么需要框架？——重复造轮子的代价

在3个不同项目中，我写了3次几乎相同的Excel加载逻辑：检测后缀、选引擎、处理日期、清洗空值。每次微调都需回归测试。直到我把逻辑抽象为DataLoader类：

from abc import ABC, abstractmethod from pathlib import Path import pandas as pd class DataLoader(ABC): @abstractmethod def load(self, filepath: str, **kwargs) -> pd.DataFrame: pass class CSVLoader(DataLoader): def load(self, filepath: str, **kwargs) -> pd.DataFrame: # 合并默认参数与用户参数 params = { 'encoding': 'utf-8-sig', 'na_values': ['N/A', 'NULL', '-', ''], 'keep_default_na': False, } params.update(kwargs) return pd.read_csv(filepath, **params) class ExcelLoader(DataLoader): def load(self, filepath: str, **kwargs) -> pd.DataFrame: ext = Path(filepath).suffix.lower() engine_map = {'.xls': 'xlrd', '.xlsx': 'openpyxl', '.xlsb': 'pyxlsb'} params = {'engine': engine_map.get(ext, 'openpyxl')} params.update(kwargs) return pd.read_excel(filepath, **params) # 工厂函数 def get_loader(filepath: str) -> DataLoader: ext = Path(filepath).suffix.lower() loaders = { '.csv': CSVLoader(), '.tsv': CSVLoader(), '.xls': ExcelLoader(), '.xlsx': ExcelLoader(), '.xlsb': ExcelLoader(), '.json': JSONLoader(), '.parquet': ParquetLoader(), } return loaders.get(ext, CSVLoader()) # 默认CSV # 统一调用 loader = get_loader("data.xlsx") df = loader.load("data.xlsx", sheet_name=0)

框架价值：

• 一致性：所有CSV加载共享encoding、na_values等安全参数；
• 可扩展性：新增格式只需继承DataLoader，注册到loaders字典；
• 可测试性：每个Loader可独立单元测试，无需启动真实文件。

4.2 参数标准化：消除read_*函数的参数碎片

pandas的read_csv()有47个参数，read_excel()有32个，read_json()有28个……用户根本记不住。框架应提供领域语义化参数：

业务需求	框架参数	映射到pandas参数
“我要跳过前3行页眉”	skip_header=3	skiprows=3
“日期列叫‘created_at’，转成datetime”	date_columns=['created_at']	parse_dates=['created_at']
“只读这三列，省内存”	columns=['id','name','amount']	usecols=['id','name','amount']

实现：

class StandardizedLoader(DataLoader): def load(self, filepath: str, skip_header: int = 0, date_columns: list = None, columns: list = None, **kwargs) -> pd.DataFrame: # 构建pandas参数 params = {} if skip_header > 0: params['skiprows'] = skip_header if date_columns: params['parse_dates'] = date_columns if columns: params['usecols'] = columns # 合并用户传入的原始参数（优先级更高） params.update(kwargs) # 调用具体加载器 loader = get_loader(filepath) return loader.load(filepath, **params) # 使用：业务语言，非技术参数 df = StandardizedLoader().load( "sales.xlsx", skip_header=2, date_columns=['order_date'], columns=['order_id', 'customer_name', 'amount'] )

4.3 错误分类与重试机制：让加载失败变得可预测

文件加载失败通常分三类：

• IO错误：文件不存在、权限不足、磁盘满 → 可重试；
• 解析错误：编码错误、JSON格式错误、Excel损坏 → 需人工介入；
• 逻辑错误：列名不存在、类型转换失败 → 配置修正。

智能重试策略：

import time from functools import wraps def resilient_load(max_retries=3, backoff_factor=1): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): for attempt in range(max_retries): try: return func(*args, **kwargs) except (FileNotFoundError, PermissionError, OSError) as e: if attempt == max_retries - 1: raise e wait = backoff_factor * (2 ** attempt) # 指数退避 time.sleep(wait) except Exception as e: # 解析错误不重试，直接抛出 raise e return None return wrapper return decorator @resilient_load(max_retries=2) def load_with_retry(filepath): return pd.read_csv(filepath, encoding='utf-8-sig')

实操心得：在某云环境，S3挂载的NFS偶尔返回OSError: Input/output error。加了指数退避重试后，失败率从12%降至0.3%。IO错误重试是生产环境的标配，不是可选项。

5. 常见问题与排查技巧实录：那些让你抓狂的加载故障

5.1 编码错误：UnicodeDecodeError的终极排查表

现象	根因	快速诊断	解决方案
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 0	文件含BOM头（0xff 0xfe）	xxd -l 4 data.csv查看前4字节	改用encoding='utf-8-sig'
UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 100	文件是UTF-8但被误标为GBK	file -i data.csv或chardet	用chardet探测后指定正确编码
中文显示为某人	UTF-8字节被当Latin-1解码	print(repr(line[:20]))看原始字节	强制encoding='utf-8'，errors='replace'

万能诊断脚本：

def diagnose_encoding(filepath, sample_size=10000): with open(filepath, 'rb') as f: raw = f.read(sample_size) print("=== 编码诊断报告 ===") print(f"文件头16字节: {raw[:16].hex()}") print(f"chardet推测: {chardet.detect(raw)}") print(f"file命令结果: ", end="") import subprocess try: print(subprocess.check_output(['file', '-i', filepath]).decode()) except: print("file命令不可用") # 尝试几种常见编码 for enc in ['utf-8', 'gbk', 'latin-1', 'utf-8-sig']: try: with open(filepath, 'r', encoding=enc) as f: f.read(100) print(f"✅ {enc} 可成功读取前100字符") except: print(f"❌ {enc} 失败") diagnose_encoding("broken.csv")

5.2 内存爆炸：MemoryError的5步定位法

当pd.read_csv()报MemoryError，按此顺序排查：

1. 估算理论内存：
   内存(MB) ≈ 行数 × 列数 × 每单元平均字节数
   例：1000万行×10列×20字节 = 2000MB → 需至少3GB内存。

2. 检查pandas类型推断：
   df.dtypes查看是否全为object（字符串），object列内存是string[pyarrow]的5倍。
   ✅ 修复：dtype={'col': 'string'}或convert_dtypes()。

3. 验证列裁剪效果：
   pd.read_csv(..., usecols=['id'])后df.memory_usage(deep=True).sum()是否显著下降？
   若无变化，说明usecols未生效（可能列名含空格，需skipinitialspace=True）。

4. 启用分块处理：
   reader = pd.read_csv(..., chunksize=50000)，打印next(reader).memory_usage(deep=True).sum()看单块内存。

5. 切换底层引擎：
   pd.read_csv(..., engine='c')（默认）vsengine='pyarrow'（需pip install pyarrow）。
   PyArrow引擎对大文件内存更友好，且支持batch_size参数。

5.3 日期解析失败：NaT泛滥的根因分析

pd.to_datetime()产生大量NaT，常见原因：

原因	诊断方法	修复方案
时间戳含非法值（'0000-00-00'）	df['date'].str.contains('0000').sum()	df['date'] = df['date'].replace('0000-00-00', pd.NaT)
格式不统一（'2023-01-01'vs'01/01/2023'）	df['date'].str.extract(r'(\d{4})').nunique()	用infer_datetime_format=False+format='%Y-%m-%d'
时区混淆（'2023-01-01T10:00:00'vs'2023-01-01T10:00:00+08:00'）	df['date'].str.contains('\+').sum()	统一utc=True，再dt.tz_convert('Asia/Shanghai')

安全日期加载函数：

def safe_to_datetime(series, errors='coerce', utc=False): """鲁棒日期解析，自动处理多种格式""" # 先尝试快速解析（常见格式） result = pd.to_datetime(series, errors='ignore', utc=utc) if result.isna().sum() == 0: return result # 对NaT值，用更慢但更全的解析 result = pd.to_datetime(series, errors=errors, utc=utc, infer_datetime_format=False) return result df['date'] = safe_to_datetime(df['date_str'])

5.4 格式混淆：.txt文件加载失败的真相

业务方说“这是个TXT文件”，但实际是：

• 固定宽度（FWF）：银行对账单，列宽严格为10+15+8字符。
  ✅ 用pd.read_fwf("data.txt", widths=[10,15,8], names=['acc','name','amt'])。

• INI配置风格：[section]\nkey=value\n。
  ✅ 用configparser.ConfigParser()解析，再转DataFrame。

• 日志格式：2023-01-01 10:00:00 INFO User login。
  ✅ 用正则提取：`df = pd.DataFrame(log_lines.str.extract(r'(\S+ \S+) (\S+)