pandas 用法大全
按操作分类的字典。每个函数列常用参数和一个能跑的例。 基础概念在入门那课。
一、读取数据
read_csv —— 最常用
| 参数 | 作用 | 常用值 |
|---|---|---|
sep | 分隔符 | "," "\t" "\s+" |
header | 哪行是表头 | 0(默认)/ None(无表头) |
names | 自己指定列名 | ["a","b"] |
index_col | 用哪列当索引 | 0 / "id" / False |
usecols | 只读这几列 | ["a","b"] |
dtype | 指定列类型 | {"id": str} |
parse_dates | 把列解析成日期 | ["日期"] |
na_values | 哪些算缺失 | ["", "NA", "-"] |
encoding | 编码 | "utf-8" "gbk" "utf-8-sig" |
nrows | 只读前几行 | 1000(大文件先试读) |
skiprows | 跳过开头几行 | 3 |
chunksize | 分块读(返回迭代器) | 100000 |
# 最简
df = pd.read_csv("data.csv")
# 中文 GBK,第一列是索引
df = pd.read_csv("data.csv", encoding="gbk", index_col=0)
# 只读需要的列,并把日期列解析掉
df = pd.read_csv("log.csv", usecols=["日期", "损失"],
parse_dates=["日期"])
# 大文件先试读
df = pd.read_csv("big.csv", nrows=1000)
# 十万行一批
for chunk in pd.read_csv("big.csv", chunksize=100_000):
process(chunk)其他格式
| 函数 | 用途 | 例 |
|---|---|---|
read_excel | Excel | pd.read_excel("a.xlsx", sheet_name="Sheet1") |
read_json | JSON | pd.read_json("a.json") |
read_parquet | 列式,最快 | pd.read_parquet("a.parquet") |
read_sql | 数据库 | pd.read_sql("SELECT * FROM t", conn) |
read_pickle | pandas 专用二进制 | pd.read_pickle("a.pkl") |
read_table | 空白分隔 | pd.read_table("a.txt") |
read_html | 网页表格 | pd.read_html("https://...") |
二、保存写出
to_csv —— 最常用
| 参数 | 作用 | 常用值 |
|---|---|---|
path_or_buf | 目标文件或路径 | "out.csv" |
sep | 分隔符 | ","(默认) |
index | 要不要写行号 | False(几乎总是要关) |
header | 要不要写表头 | True / False |
encoding | 编码 | "utf-8-sig"(Excel 能开) |
columns | 只写这几列 | ["a","b"] |
float_format | 浮点格式 | "%.3f" |
na_rep | 缺失值写成什么 | "" / "NaN" |
mode | 写入模式 | "w"(覆盖)/ "a"(追加) |
date_format | 日期格式 | "%Y-%m-%d" |
quoting | 引号策略 | csv.QUOTE_ALL |
# 最常用:不要行号,不要索引
df.to_csv("out.csv", index=False, encoding="utf-8-sig")
# Excel 打开不乱码 ← 关键就是 utf-8-sig
df.to_csv("报表.csv", index=False, encoding="utf-8-sig")
# 浮点只保留 3 位
df.to_csv("out.csv", index=False, float_format="%.3f")
# 缺失值写成空
df.to_csv("out.csv", index=False, na_rep="")utf-8 存出来的中文 CSV,用 Excel 打开是乱码。
utf-8-sig 会在文件开头加三个字节的 BOM 标记,Excel 就知道这是 UTF-8 了。
代价:某些程序读到开头会多出奇怪字符。纯 Python 内部用就用 utf-8, 要给 Excel 看才用 utf-8-sig。
训练日志:追加写入
训练时每个 epoch 记一行,这是最常见的场景:
import os
import pandas as pd
LOG = "train_log.csv"
for epoch in range(1, EPOCHS + 1):
loss, acc = train_one_epoch()
row = pd.DataFrame([{"epoch": epoch, "loss": loss, "acc": acc}])
row.to_csv(
LOG,
mode="a", # 追加,不是覆盖
header=not os.path.exists(LOG), # 只有第一次写表头
index=False,
)mode="a":不加就是覆盖,只剩最后一行。
header=not os.path.exists(LOG):不加就每次写一遍表头,日志里全是重复行。
index=False:不加会多一列没用的行号。
频繁 open/close 文件慢,而且中途崩溃会留下半个文件。
records = []
for epoch in range(1, EPOCHS + 1):
loss, acc = train_one_epoch()
records.append({"epoch": epoch, "loss": loss, "acc": acc})
pd.DataFrame(records).to_csv("train_log.csv", index=False)长时间训练怕丢数据,可以每隔 N 个 epoch 存一次,不要每步都写。
其他格式
| 函数 | 用途 | 关键参数 |
|---|---|---|
to_excel | Excel | sheet_name、index=False |
to_json | JSON | orient="records"、force_ascii=False |
to_parquet | 列式,最快最省 | index=False |
to_pickle | 原样存(含类型) | 无 |
to_sql | 写数据库 | if_exists="append"、index=False |
to_markdown | Markdown 表格 | 需要 tabulate 包 |
to_dict | 字典 | orient="records" |
to_numpy | ndarray | 无 |
df.to_excel("a.xlsx", sheet_name="结果", index=False)
df.to_json("a.json", orient="records", force_ascii=False)
df.to_parquet("a.parquet", index=False)
df.to_pickle("a.pkl")
df.to_dict(orient="records") # [{"a":1}, {"a":2}]给人看 → CSV(utf-8-sig)或 Excel。
给自己下次读 → parquet(快、小、保留类型)或 pickle。
给别的程序 → JSON 或 parquet。
三、查看与摘要
| 方法 | 返回什么 | 例 |
|---|---|---|
head(n) / tail(n) | 前/后 n 行(默认 5) | df.head(10) |
sample(n) | 随机抽几行 | df.sample(5, random_state=0) |
info() | 类型 + 非空数 + 内存 | df.info() |
describe() | 数值统计 | df.describe(include="all") |
shape | 元组 (行, 列) | df.shape[0] |
dtypes | 每列类型 | df.dtypes |
memory_usage() | 内存占用(字节) | df.memory_usage(deep=True) |
nunique() | 每列有几个不同值 | df.nunique() |
value_counts() | 各值出现次数 | df["c"].value_counts(normalize=True) |
corr() | 相关系数矩阵 | df.corr(numeric_only=True) |
df.describe() # 只统计数值列
df.describe(include="all") # 连字符串列一起
df["城市"].value_counts() # 各城市出现几次
df["城市"].value_counts(normalize=True) # 占比
df.nunique() # 每列几个不同值
df.memory_usage(deep=True).sum() / 1024**2 # 占多少 MB四、选取
四种索引方式
| 写法 | 按什么 | 返回 | 例 |
|---|---|---|---|
df[] | 列名 | Series/DataFrame | df["a"] |
df.loc[] | 标签 | 同上 | df.loc[0, "a"] |
df.iloc[] | 位置 | 同上 | df.iloc[0, 1] |
df.at / df.iat | 单个值(快) | 标量 | df.at[0, "a"] |
df["a"] # 一列
df[["a", "b"]] # 多列
df.loc[3] # 标签为 3 的那一行
df.loc[3, "a"] # 单个值
df.loc[1:3, ["a","b"]] # 标签切片(含 3)+ 选列
df.iloc[0] # 位置第 0 行
df.iloc[-1] # 最后一行
df.iloc[0:3, 0:2] # 位置切片(不含 3)条件筛选
df[df["销量"] > 20]
df[(df["城市"] == "北京") & (df["销量"] > 20)] # 与:&,要括号
df[(df["城市"] == "北京") | (df["城市"] == "上海")] # 或:|
df[~(df["销量"] > 20)] # 非:~
df[df["城市"].isin(["北京", "上海"])]
df[df["销量"].between(10, 30)]
df[df["城市"].str.contains("京", na=False)]query —— 用字符串写条件
df.query("销量 > 20 and 城市 == '北京'")
df.query("10 < 销量 < 30")
df.query("城市 in ['北京', '上海']")
# 引用外部变量用 @
limit = 20
df.query("销量 > @limit")不用写一堆 df["..."],可读性高得多,而且列名有空格也能用反引号包起来。
大数据量时它比布尔索引略快。
filter —— 按名字筛行列
df.filter(items=["a", "b"]) # 只要这两列
df.filter(like="销量") # 列名含"销量"的
df.filter(regex="^col_") # 正则匹配列名
df.filter(axis=1, like="价") # 明确指定筛列取特定位置的元素
df.nlargest(3, "销量") # 销量最大的 3 行
df.nsmallest(3, "销量")
df.idxmax() # 每列最大值所在的行标签
df.head(1).to_dict("records")五、增删改
增
df["新列"] = df["a"] * 2 # 直接赋值
df["常量"] = 1 # 广播
df.insert(0, "序号", range(len(df))) # 插到指定位置
df.assign(利润=df["销量"] - df["成本"]) # 链式写法
df.loc[len(df)] = ["北京", 10] # 加一行删
df.drop(columns=["a"]) # 删列
df.drop(index=[0, 1]) # 删行
df.drop(columns=["a"], inplace=True) # 原地改(不推荐)
df = df.drop(columns=["a"]) # 推荐:重新赋值
df.pop("a") # 删掉并返回这一列改
df.rename(columns={"a": "A"})
df.rename(columns=str.lower) # 全部转小写
df["a"] = df["a"].astype(int) # 改类型
df["a"] = df["a"].replace(0, np.nan) # 值替换
df.loc[df["销量"] > 30, "等级"] = "高" # 按条件改
df.update(other) # 用另一张表的值覆盖它会原地修改,看起来省事,但破坏了链式调用的可能,而且 pandas 未来版本可能移除。
统一写 df = df.drop(...),语义更清晰。
六、缺失值
| 方法 | 参数 | 作用 |
|---|---|---|
isna() / notna() | 无 | 返回布尔表 |
isna().sum() | 无 | 每列缺几个 |
dropna() | how="any"/"all"、subset=[列]、thresh=n | 删含缺失的行 |
fillna() | value、method="ffill"/"bfill"、limit=n | 填充 |
ffill() / bfill() | limit | 用前/后一个值填 |
interpolate() | method="linear"/"time" | 线性插值 |
df.isna().sum() # 每列缺几个
df.dropna() # 有缺失就删整行
df.dropna(subset=["销量"]) # 只看这一列
df.dropna(thresh=5) # 至少 5 个非空才保留
df.fillna(0)
df.fillna({"销量": 0, "城市": "未知"}) # 按列填不同的值
df["销量"].ffill(limit=2) # 用前值填,最多填 2 个
df["销量"].interpolate() # 线性插值np.nan == np.nan 是 False。
用 pd.isna(x),或者 df["c"].isna()。
七、排序与去重
sort_values 参数表
| 参数 | 作用 |
|---|---|
by | 按哪列(可以是列表) |
ascending | 升序(默认 True) |
na_position | "last"(默认)/ "first" |
key | 排序前对值做变换 |
ignore_index | 排完重排行号 |
df.sort_values("销量")
df.sort_values("销量", ascending=False)
df.sort_values(["城市", "销量"], ascending=[True, False])
df.sort_values("城市", key=lambda s: s.str.len()) # 按字符串长度
df.sort_index() # 按行号排去重
df.drop_duplicates() # 整行去重
df.drop_duplicates(subset=["城市"]) # 按某列去重,保留第一条
df.drop_duplicates(subset=["城市"], keep="last")
df.drop_duplicates(keep=False) # 重复的全删
df.duplicated().sum() # 有多少重复行排名
df["销量"].rank() # 1,2,3...
df["销量"].rank(ascending=False)
df["销量"].rank(method="dense") # 并列后不跳号
df["销量"].rank(pct=True) # 百分位八、groupby
基本用法
df.groupby("城市")["销量"].sum()
df.groupby(["城市", "年份"])["销量"].mean()
df.groupby("城市")["销量"].agg(["sum", "mean", "count", "std"])agg:自定义聚合
# 不同列用不同函数
df.groupby("城市").agg({"销量": "sum", "价格": "mean"})
# 命名聚合(结果列名可读)
df.groupby("城市").agg(
总销量=("销量", "sum"),
平均价=("价格", "mean"),
样本数=("销量", "size"),
)常用聚合函数
| 写法 | 作用 |
|---|---|
sum / mean / median | 求和 / 平均 / 中位数 |
min / max / std / var | 最值 / 标准差 / 方差 |
count / size | 非空数量 / 总行数 |
nunique | 不同值个数 |
first / last | 第一个 / 最后一个 |
idxmax | 最大值所在的标签 |
transform:结果对齐回原表
# 每个城市的总销量,广播回每一行
df["城市总销量"] = df.groupby("城市")["销量"].transform("sum")
# 每行占本城市总量的比例
df["占比"] = df["销量"] / df.groupby("城市")["销量"].transform("sum")agg 每个分组返回一行,结果行数变少。
transform 返回和原表一样长的结果,可以直接当新列。
其他 groupby 方法
df.groupby("城市").filter(lambda g: len(g) > 10) # 整组筛选
df.groupby("城市").head(2) # 每组前 2 行
df.groupby("城市").apply(lambda g: g["销量"].max() - g["销量"].min())
df.groupby("城市", as_index=False)["销量"].sum() # 分组列保持普通列九、透视与变形
pivot_table 参数表
| 参数 | 作用 |
|---|---|
index | 行方向的分组列 |
columns | 列方向的分组列 |
values | 填什么值 |
aggfunc | 怎么聚合(默认 mean) |
fill_value | 空位置填什么 |
margins | 加总计行列 |
df.pivot_table(index="城市", columns="年份", values="销量",
aggfunc="sum", fill_value=0, margins=True)
# 更简单的 pivot(有重复会报错)
df.pivot(index="城市", columns="年份", values="销量")
# 交叉表:数频次
pd.crosstab(df["城市"], df["等级"])宽表长表互转
# 宽 → 长
pd.melt(df, id_vars=["城市"], value_vars=["2023", "2024"],
var_name="年份", value_name="销量")
# 长 → 宽
df.pivot(index="城市", columns="年份", values="销量")
# 多级索引与列互换
df.stack() # 列 → 行
df.unstack() # 行 → 列十、合并
merge 参数表
| 参数 | 作用 | 常用值 |
|---|---|---|
left / right | 两张表 | — |
on | 用哪列关联 | "id" / ["a","b"] |
left_on / right_on | 两表列名不同时 | "用户ID" / "id" |
how | 关联方式 | "inner"默认 / "left" / "right" / "outer" |
suffixes | 重名列加后缀 | ("_左", "_右") |
indicator | 加一列标记来源 | True |
validate | 检查关联是否唯一 | "one_to_one" / "many_to_one" |
pd.merge(订单, 用户, on="用户ID", how="left")
# 两表列名不同
pd.merge(a, b, left_on="用户ID", right_on="id")
# 用 validate 提前发现"一对多"导致的膨胀
pd.merge(a, b, on="id", validate="many_to_one")右表同一个 id 有多行时,merge 会产生笛卡尔积。
合并前先查:b["id"].duplicated().sum()。
或者直接用 validate="many_to_one" 让它报错。
concat 参数表
| 参数 | 作用 |
|---|---|
objs | 要拼的列表 |
axis | 0 上下(默认)/ 1 左右 |
ignore_index | 重排行号 |
keys | 加一级索引区分来源 |
join | "outer"(默认)/ "inner" |
pd.concat([df1, df2], ignore_index=True) # 上下拼
pd.concat([df1, df2], axis=1) # 左右拼
pd.concat([df1, df2], keys=["2023", "2024"]) # 加来源标记
df1.join(df2, how="left") # 按索引关联
df1.combine_first(df2) # 用 df2 补 df1 的空十一、时间序列
转换
pd.to_datetime("2024-01-15")
pd.to_datetime(df["日期"], errors="coerce") # 解析不了的变 NaT
pd.to_datetime("20240115", format="%Y%m%d").dt 属性表
| 属性 | 得到 |
|---|---|
.dt.year / .month / .day | 年月日 |
.dt.hour / .minute / .second | 时分秒 |
.dt.dayofweek | 0=周一 … 6=周日 |
.dt.day_name() | "Monday" |
.dt.quarter | 季度 |
.dt.date | 只要日期部分 |
.dt.strftime("%Y-%m") | 格式化字符串 |
.dt.days | timedelta 的天数 |
df["年"] = df["日期"].dt.year
df["月"] = df["日期"].dt.month
df["星期"] = df["日期"].dt.dayofweek
df["是否周末"] = df["日期"].dt.dayofweek >= 5重采样
df = df.set_index("日期")
df.resample("D")["销量"].sum() # 按天
df.resample("W")["销量"].mean() # 按周
df.resample("M")["销量"].sum() # 按月
df.resample("Q")["销量"].sum() # 按季
df.resample("Y")["销量"].sum() # 按年
df.resample("3D").sum() # 每 3 天滚动与位移
df["销量"].rolling(7).mean() # 7 天移动平均
df["销量"].shift(1) # 往前挪一位(昨天的值)
df["销量"].diff() # 和上一个的差
df["销量"].pct_change() # 变化率十二、字符串方法
用 .str. 前缀,就是对每个元素做字符串操作。
| 写法 | 作用 |
|---|---|
.str.lower() / .upper() | 大小写 |
.str.strip() | 去首尾空白 |
.str.replace("a","b") | 替换(默认当正则需要 regex=True) |
.str.contains("x", na=False) | 是否包含 |
.str.startswith / .endswith | 开头 / 结尾 |
.str.split(",", expand=True) | 拆成多列 |
.str.len() | 长度 |
.str[0:3] | 切片 |
.str.extract(r"(\d+)") | 正则提取 |
.str.cat(sep=",") | 拼成一串 |
.str.zfill(5) | 左侧补零 |
df["城市"].str.strip()
df["城市"].str.contains("京", na=False)
df["城市"].str.replace("市", "", regex=False)
df["地址"].str.split("省", expand=True) # 拆成两列
df["编号"].str.zfill(5) # 1 → 00001
df["文本"].str.extract(r"(\d+)") # 提取数字十三、apply / map / pipe
| 方法 | 作用范围 | 例 |
|---|---|---|
map() | Series 逐元素 | df["性别"].map({"男":1,"女":0}) |
apply() | Series 逐元素 / DataFrame 逐行或列 | df.apply(func, axis=1) |
pipe() | 整个 DataFrame | df.pipe(clean) |
df["性别"].map({"男": 1, "女": 0}) # 查表替换
df["销量"].apply(lambda x: x * 2) # 逐元素
df.apply(lambda row: row["a"] + row["b"], axis=1) # 逐行
df.pipe(lambda d: d.dropna().reset_index(drop=True))它本质是 Python 循环,比向量化慢一到两个数量级。
能用 df["a"] + df["b"] 就别用 apply;能用 .str / .dt 更好。
十四、索引操作
df.set_index("日期") # 用某列当索引
df.set_index("日期", drop=False) # 保留那一列
df.reset_index() # 索引变回列
df.reset_index(drop=True) # 直接丢掉
df.reindex([1, 2, 5]) # 按新索引对齐(缺的填 NaN)
df.index = range(len(df)) # 直接换索引十五、类型与内存
df.dtypes # 看类型
df["a"].astype(int) # 转类型
df["a"].astype("category") # 转分类(省内存)
pd.to_numeric(df["a"], errors="coerce") # 转数字,转不了的变 NaN
pd.to_datetime(df["日期"])一列只有几十个不同值的字符串(城市、等级),转成 category 能省 90% 以上内存。
df["城市"] = df["城市"].astype("category")
df.memory_usage(deep=True).sum() / 1024**2 # 看省了多少 MB十六、和 numpy 互通
df.to_numpy() # → ndarray
df["a"].to_numpy() # 单列
pd.DataFrame(arr, columns=["a","b"])
df["a"].sum() # pandas 自带聚合,通常够用
np.log(df["a"].to_numpy()) # 复杂运算转 numpy十七、性能
| 做法 | 效果 |
|---|---|
| 向量化代替 apply | 快 10~100 倍 |
用 category 存字符串 | 省内存,groupby 更快 |
df.query() 代替布尔索引 | 大数据集略快 |
pd.eval() 算复杂表达式 | 少建中间数组 |
读文件时指定 dtype 和 usecols | 读取快很多 |
| parquet 代替 CSV | 读写都快数倍 |
十八、容易踩的坑
| 坑 | 正确做法 |
|---|---|
df["a"][0] = 1 报警告 | df.loc[0, "a"] = 1 |
用 == 判断 NaN | pd.isna() |
| 忘了重新赋值 | df = df.drop(...) |
链式 df.drop().sort() 报错 | 每步加括号,或分成多行 |
| merge 后行数暴涨 | 先检查 id 唯一性,或用 validate |
| 中文 CSV Excel 打开乱码 | encoding="utf-8-sig" |
| 存 CSV 多一列行号 | index=False |
| 整数列有 NaN 变成 float | 正常现象(NaN 是浮点) |
读进来多一列 Unnamed: 0 | index_col=0 |
| SettingWithCopyWarning | 先 .copy(),或直接用 .loc |
在循环里往 DataFrame 追加行是 O(n²)——每次都重建整个表。
正确做法:先收集到 list[dict],最后一次性 pd.DataFrame(records)。
十九、一页速查
读 read_csv(sep header names index_col usecols dtype parse_dates encoding nrows chunksize)
写 to_csv(index=False encoding="utf-8-sig" mode="a" header float_format na_rep)
to_excel to_json to_parquet to_pickle to_sql to_dict to_numpy
看 head tail sample info describe shape dtypes nunique value_counts memory_usage
选 df["c"] df[[..]] loc iloc at iat query filter isin between nlargest
改 assign insert drop rename astype replace update pop
缺失 isna dropna(how subset thresh) fillna(value method limit) ffill interpolate
排 sort_values(by ascending na_position) sort_index drop_duplicates(keep) rank
分组 groupby(by as_index) agg transform filter head apply
透视 pivot_table(index columns values aggfunc fill_value margins) pivot crosstab melt stack
合并 merge(on how left_on suffixes validate) concat(axis ignore_index keys) join combine_first
时间 to_datetime dt.year resample("M") rolling(7).mean() shift diff pct_change
字串 .str.lower contains replace split(expand) len extract zfill
函数 map apply(axis) pipe
索引 set_index reset_index reindex
类型 astype category to_numeric to_datetime