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_excelExcelpd.read_excel("a.xlsx", sheet_name="Sheet1")
read_jsonJSONpd.read_json("a.json")
read_parquet列式,最快pd.read_parquet("a.parquet")
read_sql数据库pd.read_sql("SELECT * FROM t", conn)
read_picklepandas 专用二进制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="")
encoding=utf-8-sig 是中文 CSV 的关键

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_excelExcelsheet_name、index=False
to_jsonJSONorient="records"、force_ascii=False
to_parquet列式,最快最省index=False
to_pickle原样存(含类型)无
to_sql写数据库if_exists="append"、index=False
to_markdownMarkdown 表格需要 tabulate 包
to_dict字典orient="records"
to_numpyndarray无
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/DataFramedf["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")
query 的好处

不用写一堆 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=&#123;"a": "A"&#125;)
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)                       # 用另一张表的值覆盖
inplace=True 不推荐

它会原地修改,看起来省事,但破坏了链式调用的可能,而且 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(&#123;"销量": 0, "城市": "未知"&#125;)   # 按列填不同的值
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(&#123;"销量": "sum", "价格": "mean"&#125;)

# 命名聚合(结果列名可读)
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 的区别

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")
merge 后行数暴涨

右表同一个 id 有多行时,merge 会产生笛卡尔积。

合并前先查:b["id"].duplicated().sum()。

或者直接用 validate="many_to_one" 让它报错。

concat 参数表

参数作用
objs要拼的列表
axis0 上下(默认)/ 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.dayofweek0=周一 … 6=周日
.dt.day_name()"Monday"
.dt.quarter季度
.dt.date只要日期部分
.dt.strftime("%Y-%m")格式化字符串
.dt.daystimedelta 的天数
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()整个 DataFramedf.pipe(clean)
df["性别"].map(&#123;"男": 1, "女": 0&#125;)          # 查表替换
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))
apply 慢

它本质是 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 能省很多内存

一列只有几十个不同值的字符串(城市、等级),转成 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
用 == 判断 NaNpd.isna()
忘了重新赋值df = df.drop(...)
链式 df.drop().sort() 报错每步加括号,或分成多行
merge 后行数暴涨先检查 id 唯一性,或用 validate
中文 CSV Excel 打开乱码encoding="utf-8-sig"
存 CSV 多一列行号index=False
整数列有 NaN 变成 float正常现象(NaN 是浮点)
读进来多一列 Unnamed: 0index_col=0
SettingWithCopyWarning先 .copy(),或直接用 .loc
np.append / df.append 的陷阱

在循环里往 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