Python 大数据分析基础 · 第 8 次课

第 8 章 Pandas 数据处理与分析

带标签的数据结构(Series / DataFrame)· 数据导入与导出 · 数据预处理(缺失 / 重复 / 异常)· 数据查询与排序 · 分组聚合与分箱 · 数据透视表 · 合并与连接 · 订单数据全流程 · AI 渗透(8 个知识模块 + 110 段实测代码 + 22 张插图 + 17 个动态演示图 + 8 个交互面板 + 可下载的代码与数据)

中华女子学院12 学时(讲授 2 + 上机 10)授课人:孙琪翔第 12—14 周
导

本讲导览

Lesson Overview · 从“一个一个算”到“一张表一起处理”

上一章 NumPy 教我们把一整批数当成一个对象来算,可它有一个前提:数据得是整齐的同类型数组。现实里的数据却是一张张表——一行是一条订单、一名学生、一次访问,每一列是名字、日期、单价、数量,每列类型还不一样。用 NumPy 处理这种表,你得自己记住“第 0 列是订单号、第 3 列是商品名”,代码里全是 a[:, 3] 这种天书。

这一章的主角 Pandas 就是为“表”而生的。它有两个核心对象:Series(带标签的一列)和 DataFrame(带标签的二维表)。有了标签,你写的是 df['金额'].sum()、df[df.商品名称 == '围巾']——说的是业务含义,不是第几列。Excel 能做的筛选、排序、分组、透视、合并,Pandas 都能用几行代码完成;而且步骤可复现、可批量、可自动化,数据量从 300 行涨到 300 万行也不用换方法。

这一章是整门课分量最重的一章(12 学时:讲授 2 + 上机 10),课件 92 页、例 8-1 到例 8-40。页面按“数据结构 → 导入导出 → 预处理 → 查询 → 聚合 → 透视 → 合并”的主线展开,最后用订单数据把全流程串一遍。示例和演示比前几章都多:每段代码都在本机真实运行、结果自动回填;每个抽象概念都配手绘插图、可单步播放的动画和可动手改参数的交互面板。

本课主线:一张表进去,一份结论出来 原始数据 订单.xlsx(310 行) 商品.csv 订单_J1 / J2.xlsx Excel / CSV / TXT Pandas 处理六步 ① 导入 ② 查看 ③ 清洗 ④ 查询 ⑤ 聚合 read_excel head / info 缺失·重复·异常 loc / 布尔索引 groupby / agg ⑥ 透视 · 合并 · 导出(pivot_table / merge / to_excel) 每一步都看得见中间结果:shape 怎么变、哪些行被删、哪几行命中 分析结论 每周各商品销售额 哪种商品最畅销 哪类订单异常 导出 Excel / CSV 这一章学会四件事,第 9 章可视化和期末综合都靠它 ① 造表 / 取数 ② 导入 / 清洗 ③ 查询 / 聚合 ④ 透视 / 合并 数据量越大、步骤越多,代码的优势越明显;而且每一版都能原样复现
本课主线:真实数据几乎都是“表”,Pandas 把导入、清洗、查询、聚合、透视、合并串成一条可复现的流水线

十二学时怎么排

第 12 周 · 讲授 2 + 上机 2 学时
数据结构 + 导入导出
Series / DataFrame 的创建与查看 · loc / iloc · 排序 · 数据分析五步 · read_excel / read_csv / to_csv;上机练习建表、取数与读写
第 13 周 · 上机 4 学时
数据预处理与查询
找缺失值 · dropna / fillna · 异常值查找与删除 · 重复值 duplicated / drop_duplicates · 类型转换与字段抽取 · 多条件查询 · isin / between / nlargest
第 14 周 · 上机 4 学时
聚合透视、合并连接与综合实战
groupby + agg · pd.cut 分箱 · resample · pivot_table 数据透视表 · concat 合并 · merge 四种连接 · 连接校验 · 订单数据全流程 · AI 数据管线中的 Pandas
学习目标:① 说清 Series 和 DataFrame 的“三部分”(index / columns / values),会用列表、字典、数组创建 Series 和 DataFrame;② 会用 shape / index / columns / dtypes / info() / describe() 看清一张表;③ 分得清 loc(按标签)和 iloc(按位置),会用 at / iat / df[ ] 和布尔索引取值;④ 会修改、增删列,会 sort_index / sort_values 排序;⑤ 会 read_excel / read_csv / read_table 导入、to_excel / to_csv 导出,知道 index=False 和编码参数的意义;⑥ 会用 isnull / dropna / fillna / duplicated / drop_duplicates 处理缺失、重复、异常值;⑦ 会用条件查询、between / isin / nlargest 和排序做数据查询;⑧ 会用 groupby + agg、pd.cut、resample 做统计汇总;⑨ 会用 pivot_table 建透视表;⑩ 会用 concat / merge 合并连接两张表,并能独立完成订单数据的全流程分析。

本课地图

本章知识点总览

点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。

第 8 章 Pandas 数据处理与分析
▶数据结构与访问模块一—三
为什么需要 Pandas
Series:索引 + 值
创建 Series 的五种方式
访问与修改 Series
Series 的运算与统计
时间索引与 date_range
DataFrame:二维表格的三部分
用嵌套列表创建
用字典创建
设置与修改 index / columns
查看基本信息
head / tail / info / describe
loc 与 iloc
at 与 iat
df[ ] 的三种用法
布尔索引:条件挑行
修改数据:改值 / 加列 / 转置 / drop
排序:sort_index 与 sort_values
▶数据处理流程模块四—六
数据分析的五个步骤
read_excel:读 Excel
read_csv / read_table:读 CSV 与文本
导入常用参数
导出:to_excel / to_csv
导入导出的常见问题
为什么要预处理
查找缺失值
删除缺失值:dropna
填充缺失值:fillna
异常值:查找与处理
重复值:duplicated 与 drop_duplicates
其它加工(选学):astype / str / dt
行与列的查询
条件查询:比较运算 + 布尔索引
多条件:& | ~ 与小括号
区间与集合:between / isin
top N 与排序组合
查询写法对照与链式赋值陷阱
▶分析、汇总与整合模块七—八
描述统计
频数统计:value_counts 与 mode
分组统计:groupby + agg
分组结果整形
分区统计:pd.cut 分箱
重采样:resample(选学)
数据透视表:pivot_table
合并:concat
连接:merge 与四种 how
连接校验
综合案例:订单数据全流程
AI 渗透:Pandas 在 AI 数据管线中的位置
本章知识地图与小结
说明:本章依据课程课件《8-Pandas 数据处理与分析新》(92 页,例 8-1—例 8-40)与教学进度表「CH8 Pandas数据处理与分析:Pandas基本数据结构(Series、DataFrame)· 数据导入与导出 · 数据预处理 · 数据查询、汇总、数据透视表 · 数据的连接与合并(讲授 2 + 上机 10 = 12 学时)」整理并扩充。课件完整数据 310 行(data\订单.xlsx),页面为便于阅读统一使用 12 行精简订单数据(保留了缺失值、重复值、异常值三类问题),课后练习请用完整数据。页面每段代码都在本机真实运行后回填(Python 3.14 / pandas 3.0.5),运行结果默认隐藏,点“运行”才显示。
先记住四句话:① 一切从“带标签”开始——Series 是带标签的一列,DataFrame 是带标签的表(index 行标签 + columns 列标签);② 取数据先想清楚“按标签还是按位置”——loc 看名字、iloc 看座号,条件筛选用布尔索引;③ 分析四板斧:筛选 → 分组(groupby)→ 汇总(agg)→ 透视(pivot_table);④ 数据不干净、分析全白搭:缺失 / 重复 / 异常值先处理,导出时记得 index=False。
最容易栽的六个坑:① pandas 3 里 freq='M' 已被删除(改 'ME' 月末 / 'MS' 月初),照抄旧教材会直接报 ValueError;② 多条件查询 每个条件都要加括号,df[(a > 1) & (b < 2)],少括号会报错;③ dropna(inplace=True) 的返回值是 None,别写 df = df.dropna(inplace=True);④ 链式赋值 df[df.x > 1]['y'] = 0 在 pandas 3 的写时复制下不生效,要用 df.loc[条件, 'y'] = 0;⑤ pivot_table 默认聚合是 mean 不是 sum,要 aggfunc='sum' 就写明;⑥ merge 时右表连接键有重复会让行数膨胀,连接后一定核对行数。
一

Pandas 入门与 Series 本章起点

为什么需要 Pandas · Series 的 index 与 values · 五种创建方式 · 访问与修改 · 运算统计 · 时间索引与 date_range

第 7 章我们学会了用 NumPy 数组装一大批数字,整块加减乘除,速度很快。但数组有一个天生的短板:它只有位置,没有名字。数组里的第 1 个元素是 89,可这个 89 是数学成绩、语文成绩,还是某个订单的金额?数组自己不知道,只能靠你在旁边再记一个列表。真实的数据分析几乎全是“带标签的表格”:每一列有列名(姓名、单价、金额),每一行有行标识(订单号、日期、学号)。

Pandas 就是为“带标签的表格”而生的库。它提供两个核心对象:Series(带标签的一维数据,可以想成“一列”)和 DataFrame(带标签的二维表格)。本模块先把 Pandas 是什么、为什么用它讲清楚,然后集中讲 Series——它既是 DataFrame 的“零件”(每一列就是一个 Series),本身也是处理单列数据的主力。下一模块再讲 DataFrame。

1.1 为什么需要 Pandas

先用一组最小的例子把痛点摆出来:四门课的成绩,分别是 93、89、80、92 分,科目依次是语文、数学、英语、Python。如果只用 Python 自带的列表,想取“数学”的成绩,就得先记住“数学排第 2 个”,再用下标 1 去取。

列表:值和名字是两列,靠下标硬对
scores = [93, 89, 80, 92]
subjects = ['语文', '数学', '英语', 'Python']

scores[1]              # 89
# 可 89 是哪门课?要靠 subjects[1] 反查
# 两个列表一旦有一处错位,全盘皆错
Series:名字和值绑在同一个对象里
import pandas as pd
s = pd.Series(scores, index=subjects)

s['数学']              # 89
# 名字写在 index 里,取数不用再数位置
# 顺序变了也不会取错

字典能解决“按名字取值”的问题,但一张表往往有好几列:姓名一列、成绩一列、班级一列。用字典就得维护好几个字典,而且一旦要加一行(加一个学生),每个字典都得同步加一项,非常容易漏。NumPy 数组能做整块运算,可它要求所有元素类型一致,姓名和成绩不能混在同一个数组里,`arr[1]` 也依旧是要数位置。“带标签”和“能整块运算”这两件事,列表、字典、NumPy 各占一半,Pandas 把它们合到了一起。

容器能按名字取吗能整块运算吗能混类型吗适合装什么
列表 list❌ 只能按下标❌ 要手写循环✅ 随便混少量、顺序固定的数据
字典 dict✅ 键就是名字❌ 要手写循环✅ 随便混一条记录的多个字段
NumPy 数组❌ 只有位置✅ 向量化运算❌ 类型必须统一大批同类型数值
Series✅ 标签即下标✅ 向量化运算✅ 每列各一个类型一列数据(一维表)
DataFrame✅ 行标签 + 列名✅ 按列向量化✅ 每列各自类型二维表(真正的数据表)

用一段代码把“按名字取”和“按位置取”放在一起跑一遍。注意看最后:Series 打印出来是“左边标签、右边值”的两列,这就是它和数组最直观的区别。

列表要对齐两列,Series 把名字和值绑在一起
import pandas as pd

scores = [93, 89, 80, 92]
subjects = ['语文', '数学', '英语', 'Python']
print('列表里"数学"的成绩:', scores[subjects.index('数学')])
print('顺序一旦写岔就取错:', scores[0])

s = pd.Series(scores, index=subjects)
print('Series 里"数学"的成绩:', s['数学'])
print(s)
运行结果(实测)
列表里"数学"的成绩: 89
顺序一旦写岔就取错: 93
Series 里"数学"的成绩: 89
语文        93
数学        89
英语        80
Python    92
dtype: int64
名字的来历:Pandas 这个名字来自 panel data(面板数据,经济学里对“多维表格数据”的叫法)。它是 Wes McKinney 在 2008 年前后为处理金融数据写出来的,底层大量复用了 NumPy 的数组,所以第 7 章学的 shape、dtype、向量化运算,在这里全都能用上。import pandas as pd 是全世界通用的惯例,pd 这两个字母几乎出现在每一份数据分析代码里。
✅ 本节小结:列表只有位置、字典只有名字、NumPy 只有类型统一的数值,三者都凑不齐“带标签 + 能整块算”;Pandas 用 Series(带标签的一维)和 DataFrame(带标签的二维)补上了这块,import pandas as pd 是固定写法。

1.2 Series:索引 + 值

把一个 Series 打印出来,屏幕上永远是这样两列:左边一列是标签,叫 index(索引);右边一列是真正的数据,叫 values(值)。大括号外面没有花哨的东西,就这两部分。上面那段代码打出来的:

s = pd.Series([93, 89, 80, 92], index=['语文','数学','英语','Python'])
语文        93
数学        89
英语        80
Python    92
dtype: int64
拆开看就是两块
index  → 语文 / 数学 / 英语 / Python
values → 93 / 89 / 80 / 92

左边是"名字",右边是"数"
最后一行的 dtype 说明值全是 int64

创建时如果没写 index=,Pandas 会自动补一个从 0 开始的编号索引(0、1、2、3……),和列表下标一模一样。这个默认索引在 Pandas 3 里显示成 RangeIndex(start=0, stop=4, step=1),含义就是“0 到 3,一步一个”。

可以这样理解:Series 就是“一个字典”加“一整块数组”。index 是键那一半(负责按名字找),values 是值那一半(负责整块运算)。两半都存在于同一个对象里,所以既不会错位,也不用手动同步。下图把这个结构拆开画了一遍。

Series = 一列标签(index)+ 一列值(values) 位置 index(标签) values(值) 0 语文 93 1 数学 89 2 英语 80 3 Python 92 位置是数出来的:0、1、2、3(没写 index 时它就是标签) 标签是写进去的:语文、数学、英语、Python(类似字典的键) 值只有一列,类型统一(这里是 int64) s.index —— 标签那一半 Index(['语文', '数学', '英语', 'Python'], dtype='str') 类型是 Index,可以像列表一样转成 list 看 s.values —— 值那一半 array([93, 89, 80, 92]) 类型是 ndarray:第 7 章的数组,能整块算 两种取法,取到同一个 89 s['数学'] → 89 按“名字”找(标签) s.iloc[1] → 89 按“第几个”找(位置) pandas 3 里 s[1] 已不再按位置取,会报 KeyError
图 8-1 Series 的两半:左边 index 管“叫什么”,右边 values 管“是多少”;位置编号只是默认标签

用一段代码把这两个属性和默认索引都打出来看一眼。注意 values 的类型是 numpy.ndarray——它其实就是第 7 章那个数组,只是外面套了一层“标签”。

index 与 values:默认索引 0..n-1,values 就是 ndarray
import pandas as pd

s = pd.Series([93, 89, 80, 92])
print('默认索引:', s.index)
print('值:', s.values)
print('类型:', type(s).__name__)

t = pd.Series([93, 89, 80, 92], index=['语文', '数学', '英语', 'Python'])
print('自定义索引:', t.index)
print('values 的类型:', type(t.values).__name__)
print('index 的类型:', type(t.index).__name__)
运行结果(实测)
默认索引: RangeIndex(start=0, stop=4, step=1)
值: [93 89 80 92]
类型: Series
自定义索引: Index(['语文', '数学', '英语', 'Python'], dtype='str')
values 的类型: ndarray
index 的类型: Index

下图之前先插一段动态演示,把“标签”和“位置”这两种坐标在 Series 上分别对应哪一格走一遍。看完再往下读 1.4 节的访问规则会顺很多。

🎬 动态演示:Series 的 index 与 values
一句话记住:Series 只由两部分组成——index(标签,像字典的键)和 values(值,底层是 ndarray)。不写 index 时,Pandas 自动补 0、1、2… 的默认索引。
✅ 本节小结:Series = index(标签)+ values(值);s.index 是 Index 对象、s.values 是 ndarray;不写 index= 时自动使用 0..n-1 的默认索引,写了之后标签就类似字典的键。

1.3 创建 Series 的五种方式

实际写代码时,Series 的数据来源五花八门:有时候是一串数(列表),有时候是现成的字典,有时候是 range 生成的一串编号。Pandas 的 pd.Series() 都能接住,常用的写法有五种,下图把它们的结果并排放在一起对比。

同样得到一个 Series,index 从哪来? 数据来源 写法 生成的 index 生成的 values ① 列表 pd.Series([90, 75, 80]) 0 1 2 90 75 80 ② 元组 pd.Series((90, 75, 80)) 0 1 2 90 75 80 ③ range pd.Series(range(1, 6)) 0 1 2 3 4 1 2 3 4 5 ④ 字典 {'语文': 90, '数学': 75, '英语': 80} 语文 数学 英语 90 75 80 ⑤ 一维数组 pd.Series(np.array([90, 75, 80])) 0 1 2 90 75 80 两个可选参数:index= 自定义标签(个数必须与数据个数一致);dtype= 指定类型(如 'float64') 只有字典是“自带标签”的:键直接变成 index;其余四种不写 index= 就统一用 0..n-1
图 8-2 五种创建方式的结果对照:只有字典自带标签,其余四种的 index 要么是默认编号,要么靠 index= 指定

下面这段代码把五种方式各跑一遍。为了输出短一点,取值时用了 .tolist(),它把 Series 里的值转成普通列表;字典那种用 .to_dict(),能看清“键变成了 index”。

五种创建方式:列表 / 元组 / range / 字典 / 一维数组
import pandas as pd
import numpy as np

print('列表:', pd.Series([90, 75, 80]).tolist())
print('元组:', pd.Series((90, 75, 80)).tolist())
print('range:', pd.Series(range(1, 6)).tolist())
print('字典:', pd.Series({'语文': 90, '数学': 75, '英语': 80}).to_dict())
print('数组:', pd.Series(np.array([90, 75, 80])).tolist())

s = pd.Series([90, 75, 80], index=['语文', '数学', '英语'], dtype='float64')
print('加 index 和 dtype 之后:')
print(s)
运行结果(实测)
列表: [90, 75, 80]
元组: [90, 75, 80]
range: [1, 2, 3, 4, 5]
字典: {'语文': 90, '数学': 75, '英语': 80}
数组: [90, 75, 80]
加 index 和 dtype 之后:
语文    90.0
数学    75.0
英语    80.0
dtype: float64

自定义索引时有一条铁律:标签个数必须等于数据个数。三个数据配两个标签,Pandas 不知道该把哪个数放在哪个标签上,会直接报错。这不是 Pandas 挑剔,而是它宁可报错,也不肯猜你的意思(猜错了比报错更麻烦)。

故意报错:标签个数与数据个数不一致
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
data = [90, 75, 80]
labels = ['语文', '数学']
print('数据', len(data), '个,标签', len(labels), '个')
s = pd.Series(data, index=labels)
print(s)
运行结果(实测)
数据 3 个,标签 2 个
ValueError: Length of values (3) does not match length of index (2)
报错信息要会看:Length of values (3) does not match length of index (2) 直译就是“值的长度 3 和索引长度 2 对不上”。看到 Length of values、Length of index 这两个词,先数一数 index= 给了几个标签、数据给了几个,九成是这里错了。
✅ 本节小结:pd.Series() 接列表、元组、range、字典、一维数组;字典的键直接变 index;index= 自定义标签、dtype= 指定类型;标签个数必须与数据个数一致,否则报 ValueError。

1.4 访问与修改 Series

Series 有了标签之后,取数就有两套坐标:按标签和按位置。按标签写 s['数学'],按位置写 s.iloc[1]。为什么按位置要加 .iloc?因为方括号里的整数有歧义:它到底是“第 2 个”还是“名字叫 1 的那一格”?早期 Pandas 遇到整数会先当标签找、找不到再退回去当位置,容易出 bug;Pandas 3 已经把这个“退回位置”的老规矩删掉了——方括号里的整数只按标签找,找不到就报 KeyError。所以取位置请老老实实写 .iloc。

按标签取、按位置取、切片、多个标签一起取
import pandas as pd

s = pd.Series([93, 89, 80, 92], index=['语文', '数学', '英语', 'Python'])
print('按标签取:', s['数学'])
print('按位置取:', s.iloc[1])
try:
    print(s[1])
except KeyError:
    print('s[1] 报错:KeyError(pandas 3 不再把整数下标当位置)')
print('标签切片(含终点):')
print(s['数学':'英语'])
print('多个标签一起取:')
print(s[['语文', '英语']])
运行结果(实测)
按标签取: 89
按位置取: 89
s[1] 报错:KeyError(pandas 3 不再把整数下标当位置)
标签切片(含终点):
数学    89
英语    80
dtype: int64
多个标签一起取:
语文    93
英语    80
dtype: int64

切片这里有个容易踩的坑,必须记清楚:用标签切片时终点是包含的,用位置切片时终点不包含。上面 s['数学':'英语'] 取到了数学和英语两门;如果写成 s.iloc[1:3],也会得到数学和英语两门,但规则不同(位置 1 和 2)。两者碰巧结果一样,只是因为标签顺序刚好和位置顺序一致。把索引顺序打乱,结果就会分家——这也是为什么一定要分清“标签”和“位置”。

布尔筛选是数据分析里用得最多的取数方式:先做一次比较,得到一排 True/False,再把这排 True/False 当筛子丢进方括号。下一段代码演示,注意 s >= 85 的结果本身也是一个 Series,只是值全变成了 True/False。

布尔筛选:先比较出一排 True/False,再当筛子用
import pandas as pd

s = pd.Series([93, 89, 80, 92], index=['语文', '数学', '英语', 'Python'])
print('比较得到一排 True/False:')
print(s >= 85)
print('把这些 True 当筛子:')
print(s[s >= 85])
print('不及格的科目:', list(s[s < 85].index))
运行结果(实测)
比较得到一排 True/False:
语文         True
数学         True
英语        False
Python     True
dtype: bool
把这些 True 当筛子:
语文        93
数学        89
Python    92
dtype: int64
不及格的科目: ['英语']

改值、新增、删除也都是一行的事。改值用“标签 + 赋值”,新增就是“给一个不存在的标签赋值”,删除用 drop()。

改一个值、加一门课、drop 掉再确认
import pandas as pd

s = pd.Series([93, 89, 80, 92], index=['语文', '数学', '英语', 'Python'])
s['英语'] = 85
print('改一个值:')
print(s)
s['Java'] = 78
print('加一门课:')
print(s)
print('drop 之后还在不在:', 'Java' in s.drop('Java').index, '|', 'Java' in s.index)
运行结果(实测)
改一个值:
语文        93
数学        89
英语        85
Python    92
dtype: int64
加一门课:
语文        93
数学        89
英语        85
Python    92
Java      78
dtype: int64
drop 之后还在不在: False | True
三个高频坑:① 按位置取值必须写 s.iloc[1],Pandas 3 里写 s[1] 会直接 KeyError;② 标签切片 s['数学':'英语'] 含终点,而位置切片 s.iloc[1:3] 不含终点;③ drop() 默认返回新 Series,原 Series 不会被改动——想真正删掉得把结果重新赋给 s。
✅ 本节小结:按标签 s['数学']、按位置 s.iloc[1];标签切片含终点、位置切片不含终点;s[[标签1, 标签2]] 一次取多个;布尔筛选 s[s >= 85];改值/新增直接赋值,drop() 返回新对象、不改原对象。

1.5 运算与统计

Series 的运算和 NumPy 数组一样是“逐元素”的:s + 5 是每个分数加 5,s * 1.1 是每个分数乘 1.1,循环不用写。统计更省事,求和、平均、最大、最小、计数各有一个方法,直接点在 Series 后面就行。注意 mean() 有时会算出 81.66666666666667 这样的长尾巴(比如 245 ÷ 3),展示时用 round(x, 1) 收一下;本页的成绩表均值正好是 88.5,不用收。

与标量运算逐元素生效;sum / mean / max / min / count
import pandas as pd

s = pd.Series([93, 89, 80, 92], index=['语文', '数学', '英语', 'Python'])
print('每门加 5 分:')
print(s + 5)
print('总分:', s.sum())
print('平均分:', s.mean(), '→ 保留一位', round(s.mean(), 1))
print('最高分:', s.max(), '| 最低分:', s.min(), '| 科目数:', s.count())
运行结果(实测)
每门加 5 分:
语文        98
数学        94
英语        85
Python    97
dtype: int64
总分: 354
平均分: 88.5 → 保留一位 88.5
最高分: 93 | 最低分: 80 | 科目数: 4

Series 还有一项别的容器都没有的能力:自动对齐。两个 Series 相加时,Pandas 不是按“第几个”相加,而是先按标签把两边的数据配好对,再相加;某一边缺这个标签,结果就是 NaN(Not a Number,缺失值)。这听起来有点绕,但它恰恰是现实中最常见的场景——两个月的销售数据,月份不一定完全对得上。

两个 Series 相加:按标签配对,缺标签补 NaN
import pandas as pd

a = pd.Series([90, 75, 80], index=['语文', '数学', '英语'])
b = pd.Series([5, 10, 0], index=['英语', '语文', '数学'])
print('a + b(标签顺序不同也能对上):')
print(a + b)

c = pd.Series([1, 2], index=['语文', '数学'])
print('a + c(英语在 c 里没有,结果补 NaN):')
print(a + c)
运行结果(实测)
a + b(标签顺序不同也能对上):
数学     75
英语     85
语文    100
dtype: int64
a + c(英语在 c 里没有,结果补 NaN):
数学    77.0
英语     NaN
语文    91.0
dtype: float64
对齐是 Pandas 的招牌能力:两个 Series 做运算时,Pandas 会先把两边的 index 取并集,再按标签逐个配对;只有一边有的标签,另一边的值当作缺失(NaN)。所以你看到 a + b 的结果索引顺序可能和你写的不一样——那是合并后的标签顺序,不影响结果对不对。先对齐、再计算这个思路,到了 DataFrame 的列运算、数据合并(第 8.8 节)还会反复出现。
✅ 本节小结:Series 与标量运算逐元素生效;sum/mean/max/min/count 一行出统计,长小数用 round() 收;两个 Series 运算会按标签自动对齐,只有一边有的标签结果补 NaN。

1.6 时间索引与 date_range

真实数据里最常见的索引是日期:每天、每周、每月都有一个数。逐天手写日期太累,Pandas 提供 pd.date_range() 自动生成一串日期。它的参数有四件套:start(开始)、end(结束)、periods(要几个)、freq(间隔规则)。记忆口诀是“三选二”:start、end、periods 三个里给两个,Pandas 就能算出第三个;freq 决定日期的粒度。

freq 取值含义实测生成的日期(start='2022-01-01',periods=5)
'D'每天一个01-01、01-02、01-03、01-04、01-05
'W'每周一个(默认周日)01-02、01-09、01-16、01-23、01-30
'ME'每月月末一个01-31、02-28、03-31、04-30、05-31
'MS'每月月初一个01-01、02-01、03-01、04-01、05-01
'h'每小时一个00:00、01:00、02:00…(按小时递增)
date_range 三种频率:D 按日、W 按周、ME 按月末
import pandas as pd

d1 = pd.date_range(start='2022-01-01', periods=5, freq='D')
d2 = pd.date_range(start='2022-01-01', periods=5, freq='W')
d3 = pd.date_range(start='2022-01-01', periods=5, freq='ME')

print('D  按日:', [d.strftime('%m-%d') for d in d1])
print('W  按周(周日):', [d.strftime('%m-%d') for d in d2])
print('ME 按月末:', [d.strftime('%m-%d') for d in d3])
运行结果(实测)
D  按日: ['01-01', '01-02', '01-03', '01-04', '01-05']
W  按周(周日): ['01-02', '01-09', '01-16', '01-23', '01-30']
ME 按月末: ['01-31', '02-28', '03-31', '04-30', '05-31']
同一个起点,三种频率 → 三条不同的时间轴 pd.date_range(start='2022-01-01', periods=5, freq='___') start / end / periods 三个参数里给两个即可,剩下一个由 Pandas 推算;freq 决定“多久取一个点” D 每天 01-01 01-02 01-03 01-04 01-05 W 每周 01-02 01-09 01-16 01-23 01-30 每 7 天 ME 每月末 01-31 02-28 03-31 04-30 05-31 月底那天的日期 ⚠ pandas 3:旧教材的 freq='M' 已被删除,月末要写 'ME';月初写 'MS'。写 'M' 会直接报 ValueError
图 8-3 date_range 的三条时间轴:D 每天、W 每周、ME 每月末;同一句代码只换 freq,打点的疏密完全不同

最典型的应用是给销售额配上月份索引(课件例 8-1 的简化版)。有了日期索引之后,取“3 月的数据”可以直接写 sales['2022-03'],取“一季度”可以写 sales['2022-01':'2022-03'],不用记行号。

例 8-1 简化版:12 个月销售额 + 按月份查询
import pandas as pd

date = pd.date_range(start='20220101', freq='ME', periods=12)
money = [1580, 2000, 1250, 1760, 2180, 2100, 1890, 2016, 2210, 1908, 1500, 1786]
sales = pd.Series(money, index=date)
print(sales.head())
print('2022 年 3 月:', sales['2022-03'].iloc[0])
print('一季度(1—3 月):')
print(sales['2022-01':'2022-03'])
运行结果(实测)
2022-01-31    1580
2022-02-28    2000
2022-03-31    1250
2022-04-30    1760
2022-05-31    2180
Freq: ME, dtype: int64
2022 年 3 月: 1250
一季度(1—3 月):
2022-01-31    1580
2022-02-28    2000
2022-03-31    1250
Freq: ME, dtype: int64

时间索引还能直接参与条件筛选和统计。下面把“超过 2000 的月份”“全年总额”“月均”一起算出来——这些操作在普通列表上要写好几层循环,在 Series 上各是一行。

时间索引 Series 的筛选与统计:超过 2000 的月份 / 全年总额 / 月均
import pandas as pd

date = pd.date_range(start='20220101', freq='ME', periods=12)
money = [1580, 2000, 1250, 1760, 2180, 2100, 1890, 2016, 2210, 1908, 1500, 1786]
sales = pd.Series(money, index=date)
print('全年销售额:', sales.sum())
print('月均销售额:', round(sales.mean(), 1))
print('超过 2000 的月份:')
print(sales[sales >= 2000])
运行结果(实测)
全年销售额: 22180
月均销售额: 1848.3
超过 2000 的月份:
2022-02-28    2000
2022-05-31    2180
2022-06-30    2100
2022-08-31    2016
2022-09-30    2210
dtype: int64

最后要专门提醒一件事:网上和旧教材里大量出现 freq='M',在本机这个 pandas 3.0.5 里已经跑不通了。Pandas 从 2.2 版起把频率别名规范化成“Month End = ME、Month Start = MS”(旧的 'M' 先标记为废弃),到 pandas 3 就彻底删掉了旧别名 'M'。下面这段代码故意让它报错,报错信息里会明确告诉你“请改用 'ME'”。

故意报错:旧写法 freq='M' 在 pandas 3 已被删除
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
print('旧教材里的 freq="M":')
d = pd.date_range(start='2022-01-01', periods=3, freq='M')
print(d)
运行结果(实测)
旧教材里的 freq="M":
ValueError: 'M' is no longer supported for offsets. Please use 'ME' instead.

During handling of the above exception, another exception occurred:

ValueError: Invalid frequency: M. Failed to parse with error message: ValueError("'M' is no longer supported for offsets. Please use 'ME' instead.")
pandas 3 的频率别名变化:月末用 'ME'、月初用 'MS',不要再写 'M'。报错信息 Invalid frequency: M … Please use 'ME' instead 已经把答案写在里面了,照着改即可。其他常用别名还有 'D'(日)、'W'(周)、'h'(小时)、'YE'(年末)。

把时间索引的用法先记到这里,本章第七模块讲分组统计时会看到:有了 datetime 类型的列,就能用 .dt.year、.dt.month 拆出年、月、周,再按它们分组汇总——那才是时间索引真正发力的地方。

🎬 动态演示:date_range 的三选二参数
✅ 本节小结:pd.date_range(start, end, periods, freq) 里 start/end/periods 三选二,freq 决定粒度;常用 'D'/'W'/'ME'/'MS'/'h';pandas 3 里 'M' 已被删除,月末写 'ME';日期索引的 Series 可以直接用 sales['2022-03']、sales['2022-01':'2022-03'] 查询,还能筛选、求和、求均值。
二

DataFrame 的创建与查看 二维表格

三部分解剖 · 嵌套列表建表 · 字典建表(最常用)· 改 index 与 columns · 基本信息五件套 · head / tail / info / describe

Series 是“一列”,而真实的数据表是“多列”:既有姓名、班级这样的文字列,又有成绩、金额这样的数值列,列与列的类型还不一样。能装下这种二维表格的对象就是 DataFrame——本课、本章、乃至整个 Pandas 最重要的数据结构。后面第 8.4 节的数据预处理、第 8.5 节的查询筛选、第 8.6 节的分组汇总、第 8.7 节的透视表,全部是在 DataFrame 上操作。

这一模块解决两个问题:表怎么造出来(2.1—2.4),造出来之后怎么快速看清它(2.5—2.6)。造表有两种常用方式:嵌套列表适合“手上已经有一堆数”,字典适合“知道每一列叫什么”。看清一个表只需要五个属性加四个方法,记住之后任何陌生数据拿到手都不慌。

2.1 DataFrame:二维表格的三部分

一个 DataFrame 也是由“两列标签 + 一块值”组成的,只不过这里的两列标签变成了行索引(index)和列索引(columns):

① index(行索引)

  • 竖着排在表格最左边,标识“这是第几条记录”
  • 可以是 0、1、2…,也可以是科目名、日期、订单号
  • 默认是从 0 开始的编号

② columns(列索引)

  • 横着排在表格最上面,标识“这一列是什么字段”
  • 就是 Excel 里的表头:姓名、单价、金额
  • 每一列的类型(dtype)可以各不相同

③ values(值矩阵)

  • 中间那一块数字,是一个二维 ndarray
  • 只有值、没有名字,靠行列标签定位
  • 行数 × 列数 = shape

还有一条非常重要的对应关系:DataFrame 的每一列,单独拿出来就是一个 Series,而且这些 Series 共享同一套行索引。所以第 1 模块学的所有 Series 操作(按标签取、布尔筛选、统计)都能直接用在列上。反过来说,DataFrame 就是“若干个共享行标签的 Series 并排拼在一起”。

一个 DataFrame = 行索引 + 列索引 + 值矩阵 columns(列索引) index(行索引) zhao wang 语文 93 90 数学 89 80 英语 80 70 Python 92 75 ③ values(值矩阵) df.values → 4 行 × 2 列 一个二维 ndarray:8 个数 只有位置,没有名字 shape = (4, 2) 4 行:语文 / 数学 / 英语 / Python 2 列:zhao / wang 行数 = shape[0],列数 = shape[1] 一行 = 一条记录,一列 = 一个字段 这张演示表里行是科目、列是学生;真实数据里通常行是订单/学生,列是订单号/姓名/金额等字段 关键:每一列单独拿出来,就是一个 Series(共享同一套行索引)
图 8-4 DataFrame 的三部分:index 管行、columns 管列、values 是中间那块值矩阵,三者合起来才是一张表

先跑一段代码,把这三个部分分别打印出来,再单独取一列看看它是不是 Series。这段代码也是后面所有 demo 的“标准成绩表”。

index / columns / values 三部分,以及“一列就是一个 Series”
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('行索引:', list(df.index))
print('列索引:', list(df.columns))
print('值矩阵:')
print(df.values)
print('shape:', df.shape)
print('取一列(Series):')
print(df['zhao'])
运行结果(实测)
行索引: ['语文', '数学', '英语', 'Python']
列索引: ['zhao', 'wang']
值矩阵:
[[93 90]
 [89 80]
 [80 70]
 [92 75]]
shape: (4, 2)
取一列(Series):
语文        93
数学        89
英语        80
Python    92
Name: zhao, dtype: int64
为什么说“每一列都是 Series”:df['zhao'] 返回的是一个 Series,它的 index 就是 df.index,values 就是那一列的数值。所以 df['zhao'].mean()、df['zhao'][df['zhao'] > 85] 这些写法全是合法的——你等于把表拆成一列一列地处理。反过来说,任何“按列算”的需求,第一步几乎都是先把列取出来。
🎬 动态演示:DataFrame 的三部分
✅ 本节小结:DataFrame 由 index(行标签)、columns(列标签)、values(值矩阵)三部分组成;一行是一条记录、一列是一个字段;每一列单独取出来就是一个 Series,所有 Series 操作都能用在列上。

2.2 用嵌套列表创建

如果数据本来就是一格一格的(比如从某个系统里导出的二维数组),最直接的建表方式是把“每一行包成一个列表,再把所有行放进一个大列表”,这叫嵌套列表。它长这样:[[93, 90], [89, 80], ...]——外层方括号代表整张表,每个内层方括号代表一行。

嵌套列表建表:行列名默认都是 0、1、2…
import pandas as pd

data = [[93, 90], [89, 80], [80, 70], [92, 75]]
df = pd.DataFrame(data)
print('默认行列名:')
print(df)
print('行名:', list(df.index))
print('列名:', list(df.columns))
运行结果(实测)
默认行列名:
    0   1
0  93  90
1  89  80
2  80  70
3  92  75
行名: [0, 1, 2, 3]
列名: [0, 1]

默认的行列名都是 0、1、2…,看不出任何含义。要让它变成一张能读懂的表,得再加两个参数:index= 指定行标签、columns= 指定列名。个数必须和数据的行列数对得上——4 行数据配 4 个行名,2 列数据配 2 个列名。

嵌套列表 + index / columns:给表配上行列名
import pandas as pd

data = [[93, 90], [89, 80], [80, 70], [92, 75]]
df = pd.DataFrame(data,
                  index=['语文', '数学', '英语', 'Python'],
                  columns=['zhao', 'wang'])
print(df)
print('shape:', df.shape)
运行结果(实测)
        zhao  wang
语文        93    90
数学        89    80
英语        80    70
Python    92    75
shape: (4, 2)

列名个数写错了会怎样?直接报错,而且报错信息写得很清楚:“传了 3 个列名,数据只有 2 列”。这类错误好查,看到 columns passed 就去数列名。

故意报错:4 行 2 列的数据,给了 3 个列名
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
data = [[93, 90], [89, 80], [80, 70], [92, 75]]
print('每行有几个数:', len(data[0]))
df = pd.DataFrame(data, columns=['zhao', 'wang', 'li'])
print(df)
运行结果(实测)
每行有几个数: 2
AssertionError: 3 columns passed, passed data had 2 columns

The above exception was the direct cause of the following exception:

ValueError: 3 columns passed, passed data had 2 columns
页面里“故意报错”的 demo 是怎么处理的:代码开头有一行 sys.tracebacklimit = 0,它让 Python 只打印错误本身、不打印库内部那一长串调用栈(那里全是安装路径,对学习没帮助)。另外 pandas 有些错误会“先抛一次、再包装成原因抛一次”,所以屏幕上可能出现两行同样的错误——看最后一行就够了。
嵌套列表的三条规矩:① 每个内层列表的长度要一样(都是 2 个数);长度不一致时 pandas 3 不报错,而是给短的那行末尾悄悄补 NaN、把整列变成 float64——数据反而更脏,所以建表前先检查;② columns= 的个数必须等于每行的元素个数;③ index= 的个数必须等于行数。嵌套列表最大的缺点是没有字段名,所以真实项目里更常用下面这种“字典建表”。
✅ 本节小结:pd.DataFrame(嵌套列表) 里外层列表是整张表、内层列表是一行;行列名默认 0..n-1;用 index= / columns= 指定名字,个数必须与行数、列数一致,否则抛 ValueError。

2.3 用字典创建(最常用)

真实项目里用得最多的是字典建表:字典的键变成列名,值列表变成那一列的数据。这样写代码时列名和列数据挨在一起,不容易错位,可读性也最好——想加一列就加一个键值对,想删一列就删一个键。

字典建表:键 → 列名,值列表 → 每一列的数据
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92],
                   'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print(df)
print('列名就是字典的键:', list(df.columns))
print('行名由 index 指定:', list(df.index))
运行结果(实测)
        zhao  wang
语文        93    90
数学        89    80
英语        80    70
Python    92    75
列名就是字典的键: ['zhao', 'wang']
行名由 index 指定: ['语文', '数学', '英语', 'Python']

字典建表还有一个“副作用”很有用:如果每一列的值不是列表、而是 Series,Pandas 会按 Series 的标签自动对齐,对不上的位置补 NaN。这正好对应现实中“两个表字段数不一样”的情况:某个学生没有 Python 成绩,那一格就空着,而不是整行作废。

两列长度不同:按标签对齐,缺的格子补 NaN
import pandas as pd

zhao = pd.Series([93, 89, 80], index=['语文', '数学', '英语'])
wang = pd.Series([90, 80, 70, 75], index=['语文', '数学', '英语', 'Python'])
df = pd.DataFrame({'zhao': zhao, 'wang': wang})
print(df)
print('行索引是两边标签的并集:', list(df.index))
运行结果(实测)
        zhao  wang
Python   NaN    75
数学      89.0    80
英语      80.0    70
语文      93.0    90
行索引是两边标签的并集: ['Python', '数学', '英语', '语文']

但如果直接传两个列表、长度还不一样,Pandas 就无法判断该怎么对齐了,只能报错:“所有数组长度必须一致”。

故意报错:字典里两列列表长度不一致
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
print('两列分别有 3 个和 2 个数:')
df = pd.DataFrame({'zhao': [1, 2, 3], 'wang': [1, 2]})
print(df)
运行结果(实测)
两列分别有 3 个和 2 个数:
ValueError: All arrays must be of the same length
同样是 4 行 2 列,列名从哪来? ① 嵌套列表:只有值,没有名字 [[93, 90], [89, 80], [80, 70], [92, 75]] 0 1 0 93 90 1 89 80 2 80 70 列名是 0、1 —— 因为列表里没写名字,只能从 0 开始自动编号 要名字?必须额外写 columns=['zhao', 'wang'] ② 字典:键就是列名 {'zhao': [93, 89, ...], 'wang': [90, 80, ...]} zhao wang 0 93 90 1 89 80 2 80 70 键 zhao / wang 直接变成列名,不用再写 columns 值列表的长度必须一致;行标签仍然可以用 index= 指定 结论:优先用字典建表 —— 列名和列数据写在一起,不会错位;嵌套列表只在“数据本来就是二维数组”时用 两种方式都支持 index= / columns=;区别只在于“列名是自动编号还是你自己起的”
图 8-5 嵌套列表 vs 字典建表:一个只知道“第几列”,一个从代码里就能读出“这一列叫什么”

下面这个动画把两种建法的过程逐步放一遍,重点看“列名是从哪里冒出来的”。

🎬 动态演示:嵌套列表 vs 字典建表
建表口诀:有列名就写字典(键是列名),没列名才用嵌套列表(再补 columns=)。不管哪种,行数、列数、标签个数三者必须对得上。
✅ 本节小结:字典建表是最常用的方式,键变列名、值列表变列数据;各列长度必须一致,长度不同会报 ValueError;如果值是 Series,Pandas 会按标签自动对齐、缺的补 NaN;行标签仍可用 index= 指定。

2.4 设置与修改 index / columns

表建好之后,行列名往往还要调整:比如默认的 0、1、2 想换成科目名,或者英文列名想换成中文。最直接的做法是直接给 df.index 或 df.columns 赋一个新列表,长度要等于行数/列数,顺序就是对应关系。

直接赋值:改行索引、改列索引,改完再看一眼
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]})
df.index = ['语文', '数学', '英语', 'Python']
print('改行索引后:')
print(df)
df.columns = ['赵敏', '王芳']
print('改列索引后:')
print(df)
运行结果(实测)
改行索引后:
        zhao  wang
语文        93    90
数学        89    80
英语        80    70
Python    92    75
改列索引后:
        赵敏  王芳
语文      93  90
数学      89  80
英语      80  70
Python  92  75

直接赋值是“整个换掉”,如果只想改其中几个名字,用 rename() 更安全:传一个字典说明“旧名 → 新名”,没提到的列名保持不变。rename() 默认返回一张新表,原表不动。

rename:只改想改的名字,返回新表、原表不变
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89], 'wang': [90, 80]},
                  index=['语文', '数学'])
df2 = df.rename(columns={'zhao': '赵敏', 'wang': '王芳'},
                index={'语文': '语文课'})
print('rename 之后的新表:')
print(df2)
print('原表没变:', list(df.columns))
运行结果(实测)
rename 之后的新表:
     赵敏  王芳
语文课  93  90
数学   89  80
原表没变: ['zhao', 'wang']
两个容易忽略的点:① 直接给 df.index / df.columns 赋值时,列表长度必须与行数 / 列数相等,否则报 ValueError;② rename()、drop() 这类方法默认都返回新对象,改完一定要重新打印或重新赋值,否则你会以为“怎么没生效”。
✅ 本节小结:df.index = [...] / df.columns = [...] 整体替换行列名(长度要匹配);rename(columns={旧: 新}, index={旧: 新}) 只改指定名字,返回新表、不修改原表。

2.5 查看基本信息

拿到一个陌生的表,第一件事不是算,而是看清它:多少行多少列?列名是什么?值的类型是什么?Pandas 把这几个信息放在几个属性上,统称“基本信息五件套”。

属性 / 方法看什么典型输出
df.shape形状:行数、列数(4, 2)(注意是元组,带括号)
df.index行索引Index(['语文', '数学', ...], dtype='str')
df.columns列索引Index(['zhao', 'wang'], dtype='str')
df.values值矩阵(二维 ndarray)array([[93, 90], ...])
df.dtypes每一列的类型zhao int64、姓名 str……
shape / index / columns / values 一把打完,values 是 ndarray
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('shape:', df.shape)
print('index:', list(df.index))
print('columns:', list(df.columns))
print('values:')
print(df.values)
print('values 的类型:', type(df.values).__name__)
运行结果(实测)
shape: (4, 2)
index: ['语文', '数学', '英语', 'Python']
columns: ['zhao', 'wang']
values:
[[93 90]
 [89 80]
 [80 70]
 [92 75]]
values 的类型: ndarray

dtypes 单独讲一下:它会逐列告诉你这一列是什么类型。数值列是 int64 / float64,字符串列在 pandas 3 里显示为 str(旧教材里是 object),布尔列是 bool。看 dtype 很重要:类型不对,后面的筛选、统计、合并都可能出问题(第 8.4 节会用 astype 做转换)。

dtypes:数值列 int64、字符串列 str、布尔列 bool
import pandas as pd

df = pd.DataFrame({'姓名': ['赵敏', '王芳', '李雷'],
                   '成绩': [93, 89, 80],
                   '及格': [True, True, False]})
print(df.dtypes)
print('字符串列的 dtype:', df['姓名'].dtype)
print('单独一列的类型:', type(df['姓名']).__name__)
运行结果(实测)
姓名      str
成绩    int64
及格     bool
dtype: object
字符串列的 dtype: str
单独一列的类型: Series
shape 是元组,不是函数:df.shape 后面不加括号,写 df.shape() 会报错。df.shape[0] 是行数、df.shape[1] 是列数——因为元组可以用下标取。另外 df.values 是 ndarray,意味着第 7 章学的数组切片、reshape、向量化运算全都能直接用在它身上。
✅ 本节小结:shape 看 (行数, 列数)、index 看行索引、columns 看列名、values 取值矩阵(是 ndarray)、dtypes 看每列类型;pandas 3 里字符串列的 dtype 显示为 str,不再是 object。

2.6 head / tail / info / describe

表一大,打印出来就会刷屏,还看不全。Pandas 给了四个“看表”的方法:head(n) 看前 n 行、tail(n) 看后 n 行、info() 看结构(行数、非空个数、类型)、describe() 看数值列的统计摘要。

head / tail:只看前几行、后几行
import pandas as pd

df = pd.DataFrame({'姓名': ['赵敏', '王芳', '李雷', '韩梅', '张伟', '刘洋'],
                   '成绩': [93, 89, 80, 92, 78, 85]})
print('前 3 行:')
print(df.head(3))
print('后 2 行:')
print(df.tail(2))
运行结果(实测)
前 3 行:
   姓名  成绩
0  赵敏  93
1  王芳  89
2  李雷  80
后 2 行:
   姓名  成绩
4  张伟  78
5  刘洋  85

info() 是“体检报告”:总共有几行、几列,每列有几个非空值,每列是什么类型,占多少内存。这段 demo 一口气踩中三种类型:姓名是字符串(str)、成绩因为有一个空值被提升成 float64、入学日期是 datetime64[us]。同时它会引出 pandas 3 的三处版本差异(见下面的 warn)。

info():行数 / 非空计数 / 每列 dtype(str、float64、datetime64[us])
import pandas as pd

df = pd.DataFrame({'姓名': ['赵敏', '王芳', '李雷'],
                   '成绩': [93, None, 80],
                   '入学日期': pd.to_datetime(['2021-09-01', '2021-09-01', '2022-09-01'])})
df.info()
print('--- 直接打印看内容 ---')
print(df)
运行结果(实测)
<class 'pandas.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   姓名      3 non-null      str           
 1   成绩      2 non-null      float64       
 2   入学日期    3 non-null      datetime64[us]
dtypes: datetime64[us](1), float64(1), str(1)
memory usage: 204.0 bytes
--- 直接打印看内容 ---
   姓名    成绩       入学日期
0  赵敏  93.0 2021-09-01
1  王芳   NaN 2021-09-01
2  李雷  80.0 2022-09-01

describe() 是“成绩单”:count、mean、std、min、25%、50%、75%、max 一次给全。注意它默认只统计数值列,字符串列会被跳过;如果想连字符串列一起看,加 include='all'。

describe():数值列的八项统计摘要
import pandas as pd

df = pd.DataFrame({'姓名': ['赵敏', '王芳', '李雷', '韩梅'],
                   '班级': ['一班', '二班', '一班', '二班'],
                   '成绩': [93, 89, 80, 92]})
print(df.describe())
print('字符串列被跳过了,单独看它:')
print(df['班级'].describe())
运行结果(实测)
             成绩
count   4.00000
mean   88.50000
std     5.91608
min    80.00000
25%    86.75000
50%    90.50000
75%    92.25000
max    93.00000
字符串列被跳过了,单独看它:
count      4
unique     2
top       一班
freq       2
Name: 班级, dtype: object

字符串列的 describe() 统计的是“个数、去重个数、出现最多的值、它出现了几次”,也就是 count / unique / top / freq 四行——这其实就是频数统计的雏形,第 8.6 节会正式讲 value_counts()。

df.info() 在屏幕上长这样(pandas 3 实测) 终端输出:df.info() <class 'pandas.DataFrame'> RangeIndex: 3 entries, 0 to 2 Data columns (total 3 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 姓名 3 non-null str 1 成绩 2 non-null float64 2 入学日期 3 non-null datetime64[us] dtypes: datetime64[us](1), float64(1), str(1) memory usage: 204.0 bytes 成绩列有 1 个空值 → 非空计数是 2,dtype 变成 float64 字符串列 姓名 → dtype 显示为 str(旧版是 object) 日期列 → dtype 显示 datetime64[us](旧版是 [ns]) ① RangeIndex: 3 entries 一共 3 行;行索引是默认的 0 到 2 换成自定义索引会显示成 Index ② Non-Null Count 这一列“非空”的个数:3 / 2 / 3 比总行数少,就说明有缺失值 ③ Dtype 每列的数据类型:str / float64 类型决定了它能做哪些运算 ④ 日期列 DATETIME64[us] us = 微秒;旧版本显示 [ns] 纳秒 这是 pandas 3 的实测结果 旧教材的输出格式不同,以本机实测为准
图 8-6 df.info() 的四块信息:行数、每列非空计数、每列 dtype、日期列的 datetime64[us];pandas 3 的首行与 dtype 写法都和旧教材不同
pandas 3 的 info() 与旧教材有三处不同(上面这段 demo 的实测输出里全都能看到,本页所有输出均为本机实测):① 首行显示 <class 'pandas.DataFrame'>,旧版是 <class 'pandas.core.frame.DataFrame'>;② 字符串列的 dtype 显示 str,旧版是 object;③ 日期时间列显示 datetime64[us](微秒),旧版是 datetime64[ns]。考试时按课件写,自己做题、上机时以实测输出为准。
✅ 本节小结:head(n) / tail(n) 看前几行 / 后几行;info() 看行数、非空计数、dtype、内存;describe() 给数值列八项统计,字符串列要单独 df['列'].describe();pandas 3 的 info 输出格式与旧教材不同,字符串 dtype 是 str。
三

访问、修改与排序 高频操作

loc 与 iloc · at 与 iat · df[] 的三种用法 · 布尔索引挑行 · 改值 / 加列 / 转置 / drop · sort_index 与 sort_values

上一模块把表造出来了,这一模块开始“动手”:怎么从表里精确取数、怎么按条件挑行、怎么改值加列、怎么排序。这几件事占据了日常数据分析八成的代码量,也是上机考试最常考的操作。它们的共同点是——都在方括号或 loc/iloc 里完成。

学习顺序很清楚:先学两把“精确取数的钳子”loc(按名字)和 iloc(按座位),再学最常用的 df[] 三种用法,然后用布尔索引实现“满足条件的行”,接着学改数据,最后学排序。学完这一模块,一张表你想取哪块就能取哪块。

3.1 loc 与 iloc

DataFrame 有两个下标:行和列。loc 和 iloc 就是用来同时指定这两个下标的,写法是 df.loc[行, 列],中间的逗号前面管行、后面管列。区别只有一条,但必须记死:

loc:按“名字”找
df.loc['数学', 'wang']
# 行名是 数学,列名是 wang
# 方括号里写的是标签(名字)
df.loc['语文':'英语', 'wang']
# 切片也按标签,含终点 英语
iloc:按“座位号”找
df.iloc[1, 1]
# 第 1 行(从 0 数),第 1 列
# 方括号里写的是位置(整数)
df.iloc[0:2, 1]
# 切片按位置,不含终点 2

口诀:loc 看名字,iloc 看座号。名字是建表时你起的,座号是数据排队的顺序,两者在默认情况下恰好重合(0、1、2…),所以新手容易混。下图把同一张表的“名字坐标”和“座位坐标”叠在一起画了一遍,同一个 80 分,两种坐标写法不同。

同一个格子,两种坐标:loc 看名字,iloc 看座号 loc:方括号里写标签 zhao wang 语文 93 90 数学 89 80 英语 80 70 Python 92 75 df.loc['数学', 'wang'] → 80 iloc:方括号里写位置 0 1 0 93 90 1 89 80 2 80 70 3 92 75 df.iloc[1, 1] → 80 口诀:loc 看名字,iloc 看座号 切片差别:loc['语文':'英语'] 含终点「英语」;iloc[0:2] 不含终点 2 —— 一个闭区间、一个半开区间 找不到名字:loc 抛 KeyError;座号越界:iloc 抛 IndexError
图 8-7 loc 认标签、iloc 认位置:同一个 80 分,左边用“数学 + wang”取,右边用“1 + 1”取
loc:取一个格子、取一行、取一列、取一块
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('一个格子:', df.loc['数学', 'wang'])
print('一行:')
print(df.loc['数学'])
print('一列(冒号表示所有行):')
print(df.loc[:, 'wang'])
print('行列子集:')
print(df.loc[['语文', '英语'], ['wang']])
运行结果(实测)
一个格子: 80
一行:
zhao    89
wang    80
Name: 数学, dtype: int64
一列(冒号表示所有行):
语文        90
数学        80
英语        70
Python    75
Name: wang, dtype: int64
行列子集:
    wang
语文    90
英语    70
iloc:按位置取,负数从末尾数、切片不含终点
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('第 2 行第 2 列:', df.iloc[1, 1])
print('前两行前两列:')
print(df.iloc[0:2, 0:2])
print('第 1、3 行,第 2 列:')
print(df.iloc[[0, 2], [1]])
print('最后一行:')
print(df.iloc[-1])
运行结果(实测)
第 2 行第 2 列: 80
前两行前两列:
    zhao  wang
语文    93    90
数学    89    80
第 1、3 行,第 2 列:
    wang
语文    90
英语    70
最后一行:
zhao    92
wang    75
Name: Python, dtype: int64

记住 loc 只认标签的好处是:查找不存在的标签它会立刻报错,而不是悄悄返回一个错位的结果。下面这段代码故意写一个表里没有的科目,看看报什么错。

故意报错:loc 查一个不存在的行标签
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
df = pd.DataFrame({'zhao': [93, 89], 'wang': [90, 80]},
                  index=['语文', '数学'])
print('表里没有"物理"这门课:')
print(df.loc['物理', 'zhao'])
运行结果(实测)
表里没有"物理"这门课:
KeyError: '物理'

The above exception was the direct cause of the following exception:

KeyError: '物理'

还有一个更隐蔽的坑:行索引是自定义的(语文、数学……)时,写 df.loc[0] 想取“第 0 行”是取不到的——因为 loc 把 0 当成行标签去找,而表里没有叫 0 的行。想看第几行,请改用 iloc。

故意报错:自定义行索引时 df.loc[0] 取不到“第 0 行”
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
df = pd.DataFrame({'zhao': [93, 89], 'wang': [90, 80]},
                  index=['语文', '数学'])
print('想取第 0 行,于是写了 df.loc[0]:')
print(df.loc[0])
print('正确写法是 df.iloc[0]')
运行结果(实测)
想取第 0 行,于是写了 df.loc[0]:
KeyError: 0

The above exception was the direct cause of the following exception:

KeyError: 0
🎬 动态演示:loc 按标签,iloc 按位置
loc / iloc 的四个坑:① loc 的切片含终点,iloc 的切片不含终点;② loc 找不到标签抛 KeyError,iloc 位置越界抛 IndexError;③ 行索引是自定义标签时,df.loc[0] 会 KeyError,取第几行要用 df.iloc[0];④ df[0] 也不是“第 0 行”,而是“列名叫 0 的那一列”,同样会 KeyError。
✅ 本节小结:df.loc[行标签, 列标签] 按名字取、df.iloc[行位置, 列位置] 按位置取;: 表示全选,列表表示多选;loc 切片含终点、iloc 切片不含终点;loc 看名字,iloc 看座号。

3.2 at 与 iat

如果只需要一个格子的值,loc / iloc 也能取(写成 df.loc['数学', 'wang']),但 Pandas 还提供了两个更专门的写法:at 按标签取单值、iat 按位置取单值。它们不支持切片、不支持列表,只能一取一个,换来的是更快的访问速度。

at 按标签取单值、iat 按位置取单值,结果和 loc 一致
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('at 按标签:', df.at['英语', 'wang'])
print('iat 按位置:', df.iat[2, 1])
print('loc 也能取:', df.loc['英语', 'wang'])
print('三者取到同一个数:', df.at['英语', 'wang'] == df.iat[2, 1] == df.loc['英语', 'wang'])
运行结果(实测)
at 按标签: 70
iat 按位置: 70
loc 也能取: 70
三者取到同一个数: True
什么时候用 at / iat:只取一个单元格、并且这段代码要循环很多次时(比如逐个订单计算某个值),at / iat 比 loc / iloc 更省时间。但如果是整列整块的计算,仍然是向量化最快——能用一行算式解决的,就不要写循环。
✅ 本节小结:df.at[行标签, 列标签] 和 df.iat[行位置, 列位置] 都只取单个值,不支持切片和列表;语义与 loc / iloc 一致,只是更快、限制更多。

3.3 df[] 的三种用法

最常用的取数写法其实是直接给 DataFrame 加方括号 df[...]。它在三种情况下有三种含义,靠“方括号里放什么”来区分:放切片是选行,放一个列名是选一列(返回 Series),放一个列名列表是选多列(返回 DataFrame)。

写法方括号里是什么取到的是返回类型
df[0:2]一个切片(位置 0、1)前两行,所有列DataFrame
df['zhao']一个列名(字符串)zhao 这一列Series
df[['wang', 'zhao']]一个列名列表指定的几列DataFrame
df[] 三种用法:切片选行、单列变 Series、多列仍是 DataFrame
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('① 切片选行:')
print(df[0:2])
print('② 选一列(返回 Series):')
print(df['zhao'])
print('③ 选多列(返回 DataFrame):')
print(df[['wang', 'zhao']])
print('点号写法等价:', (df.zhao == df['zhao']).all())
运行结果(实测)
① 切片选行:
    zhao  wang
语文    93    90
数学    89    80
② 选一列(返回 Series):
语文        93
数学        89
英语        80
Python    92
Name: zhao, dtype: int64
③ 选多列(返回 DataFrame):
        wang  zhao
语文        90    93
数学        80    89
英语        70    80
Python    75    92
点号写法等价: True
方括号里放错东西,结果就完全不同:① df['zhao'] 返回 Series,df[['zhao']] 返回 DataFrame——多一层方括号,是一个很常见的“为什么我的结果少了一列/形状不对”的原因;② df[0:2] 里的 0:2 是位置切片(前两行),不是标签;③ df[0] 会被当成“列名叫 0 的列”,通常会 KeyError,取第一行要写 df[0:1] 或 df.iloc[0]。
✅ 本节小结:df[切片] 选行、df['列名'] 选一列返回 Series、df[['列1', '列2']] 选多列返回 DataFrame;列名是合法标识符时 df.zhao 与 df['zhao'] 等价。

3.4 布尔索引:条件挑行

“把 wang 成绩大于等于 80 的行挑出来”是数据分析里出现频率最高的需求,写法叫布尔索引。它分两步,必须分开理解:

第 1 步
造掩码
df['wang'] >= 80 得到一个和表一样高的 Series,值只有 True / False。True 表示“这一行符合条件”。
第 2 步
用掩码挑行
df[掩码] 只保留 True 对应的行;False 对应的行整行丢弃。行数一定变少。
布尔索引两步走:先造一排 True/False,再挑出 True 的行
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
mask = df['wang'] >= 80
print('掩码:')
print(mask)
print('只留 True 的行:')
print(df[mask])
运行结果(实测)
掩码:
语文         True
数学         True
英语        False
Python    False
Name: wang, dtype: bool
只留 True 的行:
    zhao  wang
语文    93    90
数学    89    80

多个条件就用 &(与)、|(或)、~(非)连起来。这里有个必须记住的语法细节:每个条件都要用圆括号包起来。因为 & 的优先级比 >= 高,不写括号会被算成 df['zhao'] >= (85 & (df['wang'] >= 80)) 这种荒唐的式子,直接报错。

between 区间筛选 + 两个条件用 & 连接(每个条件都要括号)
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('zhao 在 85 到 95 之间:')
print(df[df['zhao'].between(85, 95)])
print('两个条件同时满足(两个括号都不能少):')
print(df[(df['zhao'] >= 85) & (df['wang'] >= 80)])
print('再加一个 loc,只看某几列:')
print(df.loc[(df['zhao'] >= 85) & (df['wang'] >= 80), ['zhao']])
运行结果(实测)
zhao 在 85 到 95 之间:
        zhao  wang
语文        93    90
数学        89    80
Python    92    75
两个条件同时满足(两个括号都不能少):
    zhao  wang
语文    93    90
数学    89    80
再加一个 loc,只看某几列:
    zhao
语文    93
数学    89
布尔索引:一排 True/False 当筛子,只留下 True 的行 ① 原表 df 行标签 wang df['wang'] >= 80 语文 90 True 数学 80 True 英语 70 False Python 75 False 掩码是一个只有 True / False 的 Series 行数和原表一样高,一行对一个 df[掩码] ② 结果:只留 True 的行 行标签 wang 语文 90 数学 80 原来的 4 行变 2 行 行标签原样保留(语文、数学) 多条件:df[(df['zhao'] >= 85) & (df['wang'] >= 80)] 每个条件都必须加圆括号;& 与、| 或、~ 非;不能写 and / or / not(会报“真值不确定”)
图 8-8 布尔索引:条件先变成一条 True/False 的“掩码”,df[掩码] 再把 False 的行整行丢掉
🎬 动态演示:布尔索引先造掩码再挑行
多条件的三条铁律:① 每个条件外面必须加圆括号,否则 & 的优先级会先把两个整数“与”起来;② 连接符是 & / | / ~,不能用 and / or / not(它们要求整个表达式只有一个 True/False,而这里是一整列,会抛“truth value is ambiguous”);③ 掩码的行数必须和表一样高,所以它只能来自这张表自己的列。
✅ 本节小结:布尔索引两步——先 df['列'] >= 值 造出一排 True/False,再 df[掩码] 挑出 True 的行;区间用 between(下限, 上限);多条件用 & | ~ 且每个条件都要加括号;df.loc[掩码, 列] 可以只保留指定列。
课件例 8-2 对照:课件用同一张学生成绩表完成 5 个查询——① 查询 wang 的语文成绩 df.loc['语文', 'wang'](等价 df.iloc[0, 1]);② 查询 zhao 和 wang 的语文、数学成绩 df.iloc[0:2, :];③ 查询 zhao 的所有成绩 df.loc[:, 'zhao'](也可写 df['zhao']);④ 查询 zhao 的数学和 Python 成绩 df.loc[['数学', 'Python'], 'zhao'];⑤ 查询 wang 成绩 ≥80 的课程和成绩 df.loc[df['wang'] >= 80, 'wang']。这 5 问分别对应 3.1—3.4 的写法,可以拿上面的数据进行逐条验证。

3.5 修改数据:改值/加列/转置/drop

取数之外,另一类高频操作是改数。改单个值用 loc 定位后赋值;加一列直接给一个不存在的列名赋值;想整体换个方向看用转置 .T;想删列删行用 drop()。

改一个值(loc 定位)、加一列(新列名赋值)
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
df.loc['语文', 'wang'] = 95
print('改一个值:')
print(df)
df['li'] = [88, 91, 95, 90]
print('加一列:')
print(df)
运行结果(实测)
改一个值:
        zhao  wang
语文        93    95
数学        89    80
英语        80    70
Python    92    75
加一列:
        zhao  wang  li
语文        93    95  88
数学        89    80  91
英语        80    70  95
Python    92    75  90
转置 df.T:行列身份互换,shape 也跟着反过来
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('原表形状:', df.shape)
print('转置后:')
print(df.T)
print('转置后的形状:', df.T.shape)
运行结果(实测)
原表形状: (4, 2)
转置后:
      语文  数学  英语  Python
zhao  93  89  80      92
wang  90  80  70      75
转置后的形状: (2, 4)
drop 删列、删行:默认返回新表,原表不动
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('删一列:')
print(df.drop(columns=['wang']))
print('删一行:')
print(df.drop(index=['英语']))
print('原表没变:', df.shape)
运行结果(实测)
删一列:
        zhao
语文        93
数学        89
英语        80
Python    92
删一行:
        zhao  wang
语文        93    90
数学        89    80
Python    92    75
原表没变: (4, 2)
改数据的三个坑:① 加列时 df['li'] = [...] 的列表长度必须等于行数,否则报错;② drop() 默认返回新表,原表不会少一列——想真正删掉要写 df = df.drop(...)(它也有 inplace 参数,但本课统一用重新赋值,少用 inplace,避免“忘了返回值”的坑);③ 不要用链式赋值,例如 df[df['wang'] > 80]['zhao'] = 0,在 pandas 3 的写时复制(CoW)机制下这种写法不会生效,正确写法是 df.loc[df['wang'] > 80, 'zhao'] = 0(第 8.5 节细讲)。
✅ 本节小结:改值用 df.loc[行, 列] = 新值;加列用 df['新列名'] = 列表(长度必须一致);df.T 转置、行列互换;df.drop(columns=[...]) 删列、df.drop(index=[...]) 删行,默认返回新表。

3.6 排序:sort_index 与 sort_values

排序有两个入口:按行标签排用 sort_index(),按某一列的值排用 sort_values()。两者的共同参数是 ascending(True 升序、False 降序)和 axis(默认 0 按行,1 按列)。

sort_index:按行标签升序 / 降序
import pandas as pd

df = pd.DataFrame({'zhao': [93, 89, 80, 92], 'wang': [90, 80, 70, 75]},
                  index=['语文', '数学', '英语', 'Python'])
print('按行标签升序:')
print(df.sort_index())
print('按行标签降序:')
print(df.sort_index(ascending=False))
运行结果(实测)
按行标签升序:
        zhao  wang
Python    92    75
数学        89    80
英语        80    70
语文        93    90
按行标签降序:
        zhao  wang
语文        93    90
英语        80    70
数学        89    80
Python    92    75

按值排序是更常用的:sort_values(by='列名') 按一列排,by=['列1', '列2'] 按多列排(先按第一列,第一列相同再按第二列),这时 ascending 也要传一个同样长度的列表分别说明每列是升还是降。

sort_values:单列排序 + 多列排序(不同列不同方向)
import pandas as pd

df = pd.DataFrame({'班级': ['一班', '二班', '一班', '二班', '一班'],
                   '成绩': [93, 80, 88, 95, 93]})
print('按成绩升序:')
print(df.sort_values(by='成绩'))
print('班级升序、成绩降序:')
print(df.sort_values(by=['班级', '成绩'], ascending=[True, False]))
运行结果(实测)
按成绩升序:
   班级  成绩
1  二班  80
2  一班  88
0  一班  93
4  一班  93
3  二班  95
班级升序、成绩降序:
   班级  成绩
0  一班  93
4  一班  93
2  一班  88
3  二班  95
1  二班  80

排序也可以按“列”排:axis=1 时,sort_index(axis=1) 按列名排序,sort_values(by='赵敏', axis=1) 按“赵敏”这一行的值给各列排序。这个用法在“把每个学生的科目按分数排一排”时很好用。

axis=1:按列名排、按某一行的值给列排序
import pandas as pd

df = pd.DataFrame({'语文': [93, 89], '数学': [90, 80], '英语': [80, 70]},
                  index=['赵敏', '王芳'])
print('列名按字典序排(axis=1 排的是列):')
print(df.sort_index(axis=1))
print('按"赵敏"这一行的分数给列排序:')
print(df.sort_values(by='赵敏', axis=1, ascending=False))
运行结果(实测)
列名按字典序排(axis=1 排的是列):
    数学  英语  语文
赵敏  90  80  93
王芳  80  70  89
按"赵敏"这一行的分数给列排序:
    语文  数学  英语
赵敏  93  90  80
王芳  89  80  70
🎬 动态演示:sort_values 的排序过程
排序的四个注意点:① 排序方法默认返回新表,原表不变,要看结果就 print(df.sort_values(...)) 或重新赋值(它们也有 inplace 参数,但本课统一用重新赋值);② 缺失值默认排在最后(升序时),可用 na_position='first' 挪到最前;③ 多列排序时 ascending 传列表,长度要和 by 的列数一致;④ 值相同的行,排序后默认保持它们原来的相对顺序(稳定排序),所以“值相等但顺序看起来没变”是正常的。
✅ 本节小结:sort_index() 按行列标签排、sort_values(by=...) 按某一列的值排;ascending 控制升降,多列排序传列表;axis=1 时按列排;缺失值位置用 na_position 控制,排序默认返回新表。
课件例 8-3 对照:课件例 8-3 的 6 个操作正好覆盖本模块——① 增加一列 li:df['li'] = [87, 79, 67, 75];② 转置:df = df.T;③ 把 wang 的 Python 成绩改成 80:df.loc['wang', 'Python'] = 80;④ 删除 Python 一列:df.drop(columns='Python', inplace=True);⑤ 按学生姓名排序:df.sort_index(axis=0);⑥ 按数学成绩降序:df.sort_values(by='数学', axis=0, ascending=False)。注意 ③—⑥ 是在转置之后的 df 上做的(此时行是学生、列是课程),顺序不要乱。
四

数据分析流程与数据导入导出 数据入口

五步流程搭框架 · read_excel / read_csv / read_table 三个函数各管一种格式 · header / names / index_col / usecols / encoding 把表读准 · to_excel / to_csv 把结果交出去 · index=False 不许多出一列

前面三个模块,我们一直在跟“已经建好的表”打交道:Series 怎么造、DataFrame 怎么看、行和列怎么取。可真正做分析时,第一件事往往是打开一个 .xlsx 或 .csv 文件——数据不在代码里,而在硬盘上。于是问题变成两个:一份完整的数据分析要分几步走?文件怎么读成 DataFrame,算完又怎么交出去?

这一模块对应课件 8.2 数据分析概述和 8.3 数据的导入与导出。本课所有例子统一用一份 12 行的精简订单数据(课件完整数据 310 行,字段相同、问题类型相同,只是行数少、输出看得清)。这份数据里刻意“埋”了缺失值、重复值和异常值——第五节的数据预处理正好拿它开刀。

4.1 数据分析的五个步骤

课件 8.2 把一次完整的数据分析拆成五步。记住这五步,比记住任何一个函数都重要:它决定了你遇到问题时该往哪一步找答案。

  1. 问题定义:以解决业务问题为中心,明确“分析目的是什么、要回答什么”。比如商场经理想知道“2021 年 2 月哪类商品卖得最好、哪类最赚钱”,这句话就要翻译成字段:需要商品名称(分类)、数量(卖了多少)、金额(卖了多少钱)。
  2. 数据准备:按照字段清单去收集数据——从数据库、Excel/CSV 文件、网络接口里把数据取回来。本课的做法是 read_excel() / read_csv() 读进 DataFrame,也就是 8.3 节。
  3. 数据预处理:提高数据质量。包括数据清洗(缺失值、重复值、异常值、无意义数据)和数据加工(类型转换、字段拆分、计算新列),也就是 8.4 节。
  4. 数据分析:用适当的方法和工具,对干净的数据做查询、排序、分组、聚合、透视,提取有价值的信息,也就是 8.5—8.7 节。
  5. 数据展示与报告:把结论讲清楚——图表 + 分析报告,必要时把清洗后的数据导出成 Excel/CSV 交给别人,也就是 8.5—8.8 节的收尾。

这五步是有先后、也要能回头的。课件特别强调第 3 步:“如果数据本身存在异常或者不符合分析的要求,那么即使采用最先进的数据分析方法,所得到的结果也是错误的。”这就是数据分析里的“垃圾进,垃圾出”(Garbage In, Garbage Out)。下图把五步和本课的小节对应关系一次画清楚:

数据分析五步:从业务问题到分析报告 1 问题定义 要回答什么业务问题?需要哪些字段? 产出:分析目标 + 字段清单 2 数据准备(导入) 数据在 Excel 里还是 CSV 里?先读成 DataFrame 8.3 数据导入 read_excel / csv 3 数据预处理 缺失 3 个格、2 行重复、2 行异常——先洗干净再用 8.4 数据预处理 清洗 + 加工 4 数据分析 筛选、排序、分组、聚合、透视,回答第 1 步的问题 8.5—8.7 查询·分组·透视 5 数据展示与报告 图表把结论画出来,报告把事情讲清楚,结果交回去 8.6—8.8 图表·报告·导出 回退也是常态:分析时发现字段不够,就回到第 2 步重新取数——所以第 1 步的字段清单越清楚,来回越少。
图 8-9 数据分析五步流程:前两步决定“有没有数据”,中间两步决定“数据干不干净”,最后一步决定“结论说不说得清”

下面这段代码把五步在 12 行订单数据上“快速走一遍”。现在看不懂没关系——预处理、查询、汇总的细节后面几节都会展开,这里只看整条线是怎么串起来的。

五步在 12 行订单数据上走一遍:导入 → 检查 → 清洗 → 分析 → 结论
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
raw = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('① 数据准备:表', raw.shape)
print('② 先检查:缺失格', int(raw.isnull().sum().sum()), '个')
df = raw.dropna().drop_duplicates()                                # 去缺失、去重
df = df[(df['金额'] != 0) & ~((df['单价'] > 150) & (df['数量'] > 25))]  # 去异常
print('③ 清洗后:', df.shape[0], '行')
print('④ 分析:金额合计', round(df['金额'].sum(), 2), '元')
print('⑤ 结论:最大单笔', df['金额'].max(), '元')
运行结果(实测)
① 数据准备:表 (12, 7)
② 先检查:缺失格 3 个
③ 清洗后: 8 行
④ 分析:金额合计 11043.22 元
⑤ 结论:最大单笔 4284.0 元
五步不是一条直线:真实的项目里,第 4 步算着算着发现“需要进价字段才能算毛利”,就得回第 2 步去取商品表(第八节的 merge 就是这个动作)。所以流程图画成竖线,心里要当成环路——每回退一次,都是因为前面某一步没问清楚。
✅ 本节小结:数据分析五步——问题定义 → 数据准备 → 数据预处理 → 数据分析 → 数据展示与报告;前两步拿数据、中间两步保质量、最后一步出结论。本课的主线就是拿一份订单数据,把这五步完整走一遍。

4.2 read_excel:读 Excel

Excel 是办公室里最通用的数据载体,课件里的订单数据就是 订单.xlsx。Pandas 用 read_excel() 把它读成 DataFrame,语法是:

【语法】
read_excel(io, sheet_name, header,
           names, index_col, usecols)
一句话理解
告诉 Pandas:读哪个文件、读哪张工作表、
哪一行当列名、哪几列要、哪一列当行索引。
参数作用常用写法
io要读取的 Excel 文件(路径字符串或文件对象)'订单.xlsx'
sheet_name读哪张工作表,默认 0(第一张);写 None 返回“表名 → DataFrame”的字典'订单'、0、1
header哪一行当列名,默认 0(第一行)header=None 表示没有表头
names自己指定列名列表names=['编号','名称']
index_col用哪一列作为行索引index_col=0(第 1 列)
usecols只读哪几列[1,3,5] 或 'A:C'

读 Excel 依赖第三方库:.xlsx 用 openpyxl(Pandas 会自动调用),写 .xlsx 常用 xlsxwriter。本机两套都装好了,所以下面这段代码可以直接跑。例 8-4 是课件里“导入订单文件和商品文件”的完整版本,这里为了看清工作表,用一个 3 行小表先写两个 sheet、再分别读回来:

先写两个工作表,再用 sheet_name 分别读回来(例 8-4 的 Excel 部分)
import os, tempfile

import pandas as pd

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '订单.xlsx')
    df = pd.DataFrame({'订单编号': [302001, 302002, 302003],
                       '商品名称': ['围巾', '运动服', 'T恤'],
                       '金额': [259.2, 1470.0, 1342.32]})
    with pd.ExcelWriter(path) as writer:
        df.to_excel(writer, sheet_name='订单', index=False)
        df[['商品名称', '金额']].to_excel(writer, sheet_name='汇总', index=False)
    print('工作表“订单”:')
    print(pd.read_excel(path, sheet_name='订单'))
    print('工作表“汇总”:')
    print(pd.read_excel(path, sheet_name='汇总'))
运行结果(实测)
工作表“订单”:
     订单编号 商品名称       金额
0  302001   围巾   259.20
1  302002  运动服  1470.00
2  302003   T恤  1342.32
工作表“汇总”:
  商品名称       金额
0   围巾   259.20
1  运动服  1470.00
2   T恤  1342.32

真实文件常常“第一行是标题、第二行才是列名”“第一列是编号、不该当数据列”。这些都能在读取时用参数一次解决,不用读完再改:

index_col 把编号变成行索引,usecols 只读需要的列,nrows 只读前几行
import os, tempfile

import pandas as pd

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '成绩.xlsx')
    score = pd.DataFrame({'学号': ['2401', '2402', '2403'],
                          '姓名': ['赵敏', '王芳', '李娜'],
                          '成绩': [93, 89, 80]})
    score.to_excel(path, index=False)
    # 用第 0 列(学号)做行索引,只读 A:C 三列,只读前 2 行
    part = pd.read_excel(path, index_col=0, usecols='A:C', nrows=2)
    print(part)
    print('行索引:', list(part.index))
运行结果(实测)
      姓名  成绩
学号          
2401  赵敏  93
2402  王芳  89
行索引: [2401, 2402]
index_col=0 不是“删掉第 0 列”:这一列还在,只是从“数据列”搬到了“行标签”的位置上。好处是后面按编号查行更方便(df.loc[302001]);坏处是导出时它会以索引的身份出现,记得 index=False。同理,usecols 既能写列号列表 [1,3,5],也能写 Excel 的字母区间 'A:C',两者等价。
✅ 本节小结:read_excel() 读 Excel 靠 openpyxl 引擎;sheet_name 选工作表、index_col 定行索引、usecols 选列、header/names 管表头。能读的时候顺便解决的,就别留到读完再改。

4.3 read_csv / read_table:读 CSV 与文本

CSV(Comma-Separated Values,逗号分隔值)是最“轻”的数据格式:纯文本,一行一条记录,字段之间用逗号隔开。它的优点是任何软件都能打开、体积极小;缺点是没有任何类型信息——数字、日期读进来都是字符串,要靠 Pandas 去猜。

read_csv() 和 read_table() 是一对孪生兄弟,参数几乎一样,只有一个关键区别:read_csv 默认分隔符是逗号 ',',read_table 默认分隔符是 Tab 键 '\t'。读 .csv 用前者,读制表符分隔的 .txt 用后者;如果分隔符既不是逗号也不是 Tab,就给它一个 sep=。

选函数先看扩展名:三种文件,三个 read_* Excel 文件 订单.xlsx · 有工作表 pd.read_excel() sheet_name= / header= / index_col= usecols= / names= 依赖 openpyxl(.xlsx) 老格式 .xls 需要 xlrd CSV 文件 商品.csv · 逗号分隔 pd.read_csv() sep=',' / header= / index_col= usecols= / encoding= / parse_dates= 默认 sep=',' 默认编码 UTF-8 文本文件 订单.txt · Tab 分隔 pd.read_table() 默认 sep='\t' / header= / names= 其他分隔符用 sep= 指定 默认 sep=Tab(\t) 等价于 read_csv(sep='\t') 读进来都是 DataFrame —— 三种格式只是“入口”不同,进门之后都是同一套行 / 列 / 索引。 导出方向相反:df.to_excel(...) / df.to_csv(..., index=False);index=False 才不会多出一列行索引。
图 8-10 三种文件格式对应三个 read_* 函数:选错函数比写错参数更常见,先看扩展名,再看分隔符

先拿标准商品表(4.3 节那张 7 行商品表)走一个“写出去 → 读回来”的来回。注意导出时写了 index=False,读回来才有 5 列而不是 6 列:

商品表写成 CSV 再读回来:先 to_csv 再 read_csv,形状和内容都对得上
import os, tempfile
from io import StringIO

import pandas as pd

goods = pd.read_csv(StringIO("""商品名称,进价,产地,库存,销售价
围巾,15,江苏,50,21.6
运动服,130,北京,20,210.0
T恤,38,上海,125,65.8
卫衣,90,广东,62,126.5
休闲鞋,110,广东,210,162.0
运动鞋,152,福建,48,237.0
太阳帽,11,浙江,10,22.0
"""))
with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '商品.csv')
    goods.to_csv(path, index=False, encoding='utf-8')
    back = pd.read_csv(path)
    print('写出去再读回来:', back.shape)
    print(back.head(3))
运行结果(实测)
写出去再读回来: (7, 5)
  商品名称   进价  产地   库存    销售价
0   围巾   15  江苏   50   21.6
1  运动服  130  北京   20  210.0
2   T恤   38  上海  125   65.8

再看 read_table():同样是文本文件,只是字段之间用 Tab 而不是逗号。如果用 read_csv() 硬读,整行会被当成一列;改用 read_table(),或者给 read_csv() 加上 sep='\t',结果完全一样:

Tab 分隔的 .txt:read_table 默认就按 Tab 切,read_csv 要显式写 sep='\t'
from io import StringIO

import pandas as pd

txt = """商品名称\t进价\t库存
围巾\t15\t50
运动服\t130\t20
T恤\t38\t125
"""
t1 = pd.read_table(StringIO(txt))
print('read_table 默认按 Tab 分隔:')
print(t1)
t2 = pd.read_csv(StringIO(txt), sep='\t')
print('read_csv 指定 sep=Tab,结果一样吗?', t1.equals(t2))
运行结果(实测)
read_table 默认按 Tab 分隔:
  商品名称   进价   库存
0   围巾   15   50
1  运动服  130   20
2   T恤   38  125
read_csv 指定 sep=Tab,结果一样吗? True
CSV 没有“数据类型”:read_csv() 读进来的每一列都要靠 Pandas 推断——整数列推断成 int64,带小数点的推断成 float64,日期推断不出来,默认还是字符串(本页统一用 parse_dates=['订单日期'] 直接指定,或者读完用 pd.to_datetime() 转换)。这也解释了为什么 12 行数据里 数量 列有一个空值,整列就变成 float64:整数列里一旦混进 NaN,Pandas 只能改用浮点数装它。
✅ 本节小结:read_csv() 默认逗号、read_table() 默认 Tab,其他分隔符用 sep=;读进来的都是 DataFrame。CSV 是“纯文本”,类型靠推断,日期列要自己指定。

4.4 导入常用参数

实际拿到的数据文件,很少长得像教科书那样规整:有的没有表头、有的表头跟数据粘在一起、有的只要其中几列、有的一个文件里塞了三张表。这一节把导入时最常用的五个参数排一遍,记住它们的一句话用途就够了:

参数解决什么问题读进来会怎样
header=None文件第一行就是数据,没有列名列名自动变成 0、1、2……
names=[…]要给列起中文名,或替换掉原来的列名按顺序用你给的列表当列名
index_col=0第一列是编号,想拿它当行索引该列变成行标签,不再是普通数据列
usecols=[…]只要其中几列,别全读进来只保留指定的列,内存更省、表更清爽
encoding='gbk'中文文件是按 GBK 存的,直接读会报编码错按指定编码解码,中文正常显示

例 8-4 里课件用 index_col=0 把第一列(订单编号)指定成行索引,就是这个参数的用法。下面用一段没有表头的迷你数据,演示 header=None + names 的组合:

没有表头的 CSV:header=None 先占位,names 再起名,列名就正过来了
from io import StringIO

import pandas as pd

# 为了看清参数,这里用 4 行迷你表;12 行订单数据上写法完全一样
txt = """302001,2021-02-01,围巾,259.2
302002,2021-02-01,运动服,1470.0
302003,2021-02-01,T恤,1342.32
302004,2021-02-05,运动服,4284.0
"""
df = pd.read_csv(StringIO(txt), header=None,
                 names=['订单编号', '订单日期', '商品名称', '金额'])
print(df)
print('列名:', list(df.columns))
运行结果(实测)
     订单编号        订单日期 商品名称       金额
0  302001  2021-02-01   围巾   259.20
1  302002  2021-02-01  运动服  1470.00
2  302003  2021-02-01   T恤  1342.32
3  302004  2021-02-05  运动服  4284.00
列名: ['订单编号', '订单日期', '商品名称', '金额']

换回标准的 12 行订单数据,把 index_col 和 usecols 一起用上:只读 5 列、用订单编号当行标签。注意打印出来的第一列不再是 0 1 2 3,而是订单编号:

index_col 指定行索引 + usecols 只读 5 列:读进来就是一张“分析就绪”的表
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), usecols=['订单编号', '订单日期', '商品名称', '数量', '金额'],
                 index_col='订单编号', parse_dates=['订单日期'])
print(df.head(3))
print('行索引:', list(df.index[:3]))
print('列数:', df.shape[1])
运行结果(实测)
             订单日期 商品名称    数量       金额
订单编号                                 
302001 2021-02-01   围巾  12.0   259.20
302002 2021-02-01  运动服   7.0  1470.00
302003 2021-02-01   T恤  24.0  1342.32
行索引: [302001, 302002, 302003]
列数: 4

最后一步永远是导入后检查。课件例 8-5 用 shape、head()、info() 三件套确认“读对了没有”:行数对不对、列名有没有串位、每列的类型是什么、哪些列有缺失值。

导入后先 head 看长相、再 info 看类型:例 8-5 的检查习惯
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
print(df.head(2))
df.info()
运行结果(实测)
     订单编号       订单日期    用户ID 商品名称     单价    数量      金额
0  302001 2021-02-01  137401   围巾   21.6  12.0   259.2
1  302002 2021-02-01  177562  运动服  210.0   7.0  1470.0
<class 'pandas.DataFrame'>
RangeIndex: 12 entries, 0 to 11
Data columns (total 7 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   订单编号    12 non-null     int64         
 1   订单日期    12 non-null     datetime64[us]
 2   用户ID    12 non-null     int64         
 3   商品名称    11 non-null     str           
 4   单价      11 non-null     float64       
 5   数量      11 non-null     float64       
 6   金额      12 non-null     float64       
dtypes: datetime64[us](1), float64(3), int64(2), str(1)
memory usage: 804.0 bytes
pandas 3 的 info() 与旧教材不一样:上面实测输出里,第一行是 <class 'pandas.DataFrame'>(旧版是 <class 'pandas.core.frame.DataFrame'>);字符串列的 dtype 显示为 str(2.x 是 object);日期 dtype 是 datetime64[us](旧版是 datetime64[ns])。课件截图是按旧版本截的,对照时看“哪一列有缺失、类型是什么”就够了,不要纠结字面差异。另外 info() 是直接往屏幕上写的,不需要也不应该套 print()(套了会在最后多打一个 None)。
导入检查的三看:一看 shape——行数、列数对不对(310 行读成 309 行,八成是把表头当数据了);二看 head()——中文有没有乱码、列有没有串位;三看 info()——每列 dtype 对不对、非空计数是多少。这三眼不看,后面所有分析都可能是基于一张错表。
✅ 本节小结:header=None 对付无表头、names 起列名、index_col 定行索引、usecols 选列、encoding 管中文;导入后三看:shape、head、info。
🎬 动态演示:文件 → read_* → DataFrame → 导出

4.5 导出:to_excel / to_csv

分析做完了,结果得交出去:交给同事继续加工、交给领导看、或者存成下一次分析的输入。Pandas 的导出和导入是一一对应的:to_excel() 写 Excel,to_csv() 写 CSV。语法是:

导出 Excel
to_excel(excel_writer, sheet_name,
         columns, header, index)
导出 CSV
to_csv(path_or_buf, sep, columns,
       header, index)

两个方法共有的关键参数是 index。它的默认是 True,意思是“把行索引也写进去”——于是文件里会凭空多出一列 0 1 2 3(或者没名字的 Unnamed: 0),别人打开会以为那是数据。课件例 8-6 写得很清楚:导出时加 index=False。下面的例子读入 12 行订单、取 3 列、写成一个不带索引的 CSV,再把文件内容原样读出来检查:

取 3 列导出 CSV,index=False 保证文件第一行就是表头(例 8-6)
import os, tempfile

import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
part = df[['订单日期', '商品名称', '数量']].head(4)
with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '订单_part.csv')
    part.to_csv(path, index=False, encoding='utf-8')
    print(open(path, encoding='utf-8').read())
运行结果(实测)
订单日期,商品名称,数量
2021-02-01,围巾,12.0
2021-02-01,运动服,7.0
2021-02-01,T恤,24.0
2021-02-05,运动服,24.0

写 Excel 同理,只是多一个 sheet_name 可以指定工作表名,还能用 columns 挑要写的列、用 header=False 去掉表头:

to_excel 指定工作表名、挑列、不加索引,读回来核对形状
import os, tempfile

import pandas as pd

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '销售.xlsx')
    part = pd.DataFrame({'商品名称': ['围巾', '运动服', 'T恤', '卫衣'],
                         '金额': [259.2, 1470.0, 1342.32, 1897.5]})
    part.to_excel(path, sheet_name='销售',
                  columns=['商品名称', '金额'], index=False)
    back = pd.read_excel(path, sheet_name='销售')
    print('读回来:', back.shape)
    print(back)
运行结果(实测)
读回来: (4, 2)
  商品名称       金额
0   围巾   259.20
1  运动服  1470.00
2   T恤  1342.32
3   卫衣  1897.50
导出的索引,读回来要认得出来:如果忘了写 index=False,CSV 第一列会多出 0,1,2,3,Excel 里则是一列没名字的索引;下次 read_csv() 读回来,这列会变成名叫 Unnamed: 0 的普通列。补救办法是读的时候写 index_col=0,把它认回行索引。写的时候少一列,读的时候就少一个坑。
✅ 本节小结:to_excel() / to_csv() 与读入函数一一对应;columns 挑列、header=False 去表头、sheet_name 指定工作表,导出必写 index=False。

4.6 导入导出的常见问题

导入导出这一块,90% 的报错都能归到五类原因。遇到报错先别慌,按下面的顺序排查,一般三步之内就能定位:

1
看清报错类型:FileNotFoundError 是路径问题,UnicodeDecodeError 是编码问题,ParserError 多半是分隔符或表头错位,ModuleNotFoundError: openpyxl 是缺引擎。FileNotFoundError: [Errno 2] No such file or directory: '订单.xlsx'
2
先确认“文件在哪”:相对路径是相对当前运行的 .py 文件所在目录(或交互环境的工作目录),不是相对桌面、也不是相对上次的文件夹。最稳的做法是把数据文件和代码放同一个文件夹,写文件名即可。
3
再确认“编码”:中文 Windows 上 Excel 另存的 CSV 默认是 GBK,而 Pandas 默认按 UTF-8 读,于是UnicodeDecodeError。加 encoding='gbk' 通常能解决;反过来,别人给你的 UTF-8 文件用 gbk 读,会变成一堆乱码。
4
然后确认“表头”:表头行错位,会表现为“列名里混进一条数据、最后一列出现 NaN”。用 header=N 把列名行指对,或用 header=None + names 自己起名。
5
最后确认“导出格式”:行索引多一列(index=False)、列名被当成数据(header=False)、工作表名写错(sheet_name)——导出后读回来对一遍 shape,最省心。

先看路径错误的典型样子。下面这段代码故意读一个不存在的文件,报错信息会直接把文件名告诉你——这正是排查的起点:

故意读一个不存在的文件:FileNotFoundError 会指名道姓告诉你少了哪个文件
import sys
import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身,不打印一长串调用栈
# 文件名写错、路径不对,是导入数据时最常见的错误
path = '订单_不存在.csv'
print('准备读取:', path)
df = pd.read_csv(path)
print(df.head())
运行结果(实测,故意报错)
准备读取: 订单_不存在.csv
FileNotFoundError: [Errno 2] No such file or directory: '订单_不存在.csv'

再看编码错误:文件确实是按 GBK 存的,但读的时候没说,Pandas 用默认的 UTF-8 去解,第一个中文字就“解不动”了:

GBK 文件不指定 encoding 直接读:UnicodeDecodeError 的经典现场
import os, sys, tempfile

import pandas as pd

sys.tracebacklimit = 0        # 只打印错误本身
with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '商品_gbk.csv')
    goods = pd.DataFrame({'商品名称': ['围巾', '运动服'], '进价': [15, 130]})
    goods.to_csv(path, index=False, encoding='gbk')
    print('文件已按 gbk 写好,现在不指定 encoding 直接读:')
    print(pd.read_csv(path))
运行结果(实测,故意报错)
文件已按 gbk 写好,现在不指定 encoding 直接读:
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc9 in position 0: invalid continuation byte

对症下药就一行:读的时候把 encoding='gbk' 写上,中文立刻正常:

encoding='gbk' 读回来:同一个文件,指定编码就从报错变正常
import os, tempfile

import pandas as pd

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, '商品_gbk.csv')
    goods = pd.DataFrame({'商品名称': ['围巾', '运动服', 'T恤'],
                          '进价': [15, 130, 38]})
    goods.to_csv(path, index=False, encoding='gbk')
    back = pd.read_csv(path, encoding='gbk')
    print(back)
运行结果(实测)
  商品名称   进价
0   围巾   15
1  运动服  130
2   T恤   38
❌ 课件里的绝对路径,别照抄
df = pd.read_excel(r'盘符:\某台电脑上的完整路径\订单.xlsx')
# 换一台机器、换一个文件夹,
# 这一行立刻 FileNotFoundError
✅ 数据文件和代码放一起,写相对路径
df = pd.read_excel('订单.xlsx')
# 代码和数据在同一个文件夹,
# 换机器也不怕

本页所有读写 demo 都用 tempfile.TemporaryDirectory() 造一个临时目录,先写后读、用完即删——这是课程页面最干净的写法:既真实演示了文件读写,又不会在你电脑上留下垃圾文件,更不会因为路径不同而挂掉。

中文乱码的两个方向:UTF-8 文件用 encoding='gbk' 读,会读出“锟斤拷”之类的乱码但不报错;GBK 文件用默认 UTF-8 读,通常直接抛 UnicodeDecodeError。所以报错比乱码好排查——看到乱码,反而不容易发现读错了编码。经验法:Windows 上 Excel 另存的 CSV 大概率是 GBK,程序生成的文件默认 UTF-8。
✅ 本节小结:导入导出五类坑——路径、编码、引擎、表头、索引列。排查口诀:先看报错类型,再查文件在哪,再对编码,再校表头,最后对导出 shape。绝对路径能不用就不用。
配套视频黑马程序员 · 第 124 集 数据分析案例步骤1-文件读取该集是课程配套的数据分析案例总览(JSON 读取方向),本课 Pandas 的导入思路与之相同:先把文件读成表,再谈分析。
五

数据预处理 本章重点

数据清洗四件事:缺失值、重复值、异常值、无意义数据 · 先体检再动手 · dropna / fillna / drop_duplicates 三把手术刀 · 数据加工:astype、str 抽取、dt 提时间

数据读进来了,下一步不是马上算答案,而是先看这份数据能不能用。课件 8.4 说得很直白:数据预处理包括数据清洗和数据加工两部分——数据清洗是发现并处理原始数据里存在的缺失值、重复值、异常值、无意义的数据;数据加工是对原始数据做变换,通过计算、转换、分类、重组,发现更有价值的数据特征。

为什么这一步这么重要?因为“垃圾进,垃圾出”:数据本身有异常,再先进的分析方法算出来的结论也是错的,不但没有参考价值,还会误导决策。这一模块拿订单数据开刀,先认识它身上的“三宗罪”,再一条条处理掉。本模块也是本章考试的重点,例 8-7 到例 8-14 都出自这里。

5.1 为什么要预处理

把 12 行订单数据摊开看,它并不是一张“干净”的表。课件完整数据 310 行里,字段和问题类型与这张精简表相近(以缺失值、异常值为主;完整数据里没有完全重复的行,重复值用这张精简表来演示):

精简订单数据.csvCSV · 12 行 × 7 列(完整数据 310 行)
订单编号订单日期用户ID商品名称单价数量金额
03020012021-02-01137401围巾21.612.0259.2
13020022021-02-01177562运动服210.07.01470.0
23020032021-02-01133422T恤55.9324.01342.32
33020042021-02-05138462运动服178.524.04284.0
43020052021-02-05158949T恤65.814.0921.2
53020062021-02-08120957卫衣126.515.01897.5
63020062021-02-08120957卫衣126.515.01897.5
73020082021-02-12186059T恤65.85.0329.0
83020092021-02-15199357NaNNaNNaN540.0
93020102021-02-20149590休闲鞋162.030.04860.0
103020112021-02-25149590运动服178.50.00.0
113020122021-02-28137401围巾21.625.0540.0
红色格 = 缺失值(第 9 行 3 格) · 黄色行 = 两条完全重复的记录(第 6、7 行) · 橙色格 = 业务规则判定的异常值(单价 > 150 且数量 > 25;金额与数量都为 0)。日期跨度 2021-02-01—2021-02-28,正好用来按周统计。

四类问题各有一套处理思路,先认识它们长什么样:

数据清洗四件事 + 数据加工:先认出来,再决定怎么办 ① 缺失值(空值 NaN) 订单编号 商品名称 数量 302008 T恤 5.0 302009 NaN NaN 302010 休闲鞋 30.0 处理:能删能填,但一定要先看见它 ② 重复值(两条一模一样) 订单编号 商品名称 金额 302006 卫衣 1897.5 302006 卫衣 1897.5 302008 T恤 329.0 处理:duplicated 检查,drop_duplicates 去重 ③ 异常值(超出业务规则) 订单编号 单价 数量 金额 302010 162.0 30.0 4860.0 302011 178.5 0.0 0.0 302012 21.6 25.0 540.0 处理:按“单价 > 150 且数量 > 25”等业务规则判定,删或改 ④ 无意义数据 + 数据加工 用户ID 前两位 → 地区编码 137401 13 177562 17 订单日期 2021-02-01 周次 5 处理:astype 转类型、str 拆字段、dt 提年月日和周次
图 8-11 订单数据里的四类问题与一种加工:清洗是把不能用的处理掉,加工是从字段里“榨”出新的分析维度

处理之前先做一次“体检”:有多少缺失格、多少重复行、多少条记录触发了异常规则。三行代码就能摸清底细:

先体检:行列数、每列缺失数、重复行数、金额为 0 的行数
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('行列:', df.shape)
print('每列缺失数:')
print(df.isnull().sum())
print('完全重复的行:', df.duplicated().sum())
print('金额为 0 的行:', int((df['金额'] == 0).sum()))
运行结果(实测)
行列: (12, 7)
每列缺失数:
订单编号    0
订单日期    0
用户ID    0
商品名称    1
单价      1
数量      1
金额      0
dtype: int64
完全重复的行: 1
金额为 0 的行: 1
先诊断,后治疗:拿到任何一份数据,都别急着 dropna() 一把梭。先用 isnull().sum() 看缺失分布、duplicated().sum() 看重复、用业务条件数一数异常值——知道自己删掉的是什么、删了多少,才敢删。这一步在真实项目里往往比写代码本身更重要。
✅ 本节小结:数据预处理 = 数据清洗(缺失值、重复值、异常值、无意义数据)+ 数据加工(类型转换、字段抽取、计算新列);原则是垃圾进垃圾出——先体检、再动手,并且清楚每一步删/改了多少。

5.2 查找缺失值

缺失值就是空值(Null),在 Pandas 里统一显示成 NaN(Not a Number)。课件例 8-7 要查两件事:哪些列有缺失、具体是哪几行。对应的两个方法:

方法作用返回
df.isnull() / df.isna()逐格判断是不是缺失值,两个名字完全同义同形状的布尔表(True = 空)
df.notna()反过来判断“不是缺失值”同形状的布尔表(True = 不空)
df.isnull().any()每一列里有没有空值按列的一串 True/False
df.isnull().sum()每一列各有几个空值按列的一串整数
isnull().any() 看哪些列有缺失,sum() 数每列缺几个(例 8-7)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('哪些列有空值(any):')
print(df.isnull().any())
print('每列缺几个(sum):')
print(df.isnull().sum())
print('isna 与 isnull 同义:', df.isna().any().equals(df.isnull().any()))
运行结果(实测)
哪些列有空值(any):
订单编号    False
订单日期    False
用户ID    False
商品名称     True
单价       True
数量       True
金额      False
dtype: bool
每列缺几个(sum):
订单编号    0
订单日期    0
用户ID    0
商品名称    1
单价      1
数量      1
金额      0
dtype: int64
isna 与 isnull 同义: True

知道“商品名称、单价、数量三列各缺 1 个”还不够,还要把那一行揪出来看看。用布尔索引:先造一个“商品名称是空”的掩码,再拿它去挑行:

把含缺失值的行挑出来:df[df['商品名称'].isnull()]
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print(df[df['商品名称'].isnull()])
print('单价也空的订单编号:', df[df['单价'].isnull()]['订单编号'].tolist())
print('这一行有几格是空的:', int(df.loc[8].isnull().sum()))
运行结果(实测)
     订单编号       订单日期    用户ID 商品名称  单价  数量     金额
8  302009 2021-02-15  199357  NaN NaN NaN  540.0
单价也空的订单编号: [302009]
这一行有几格是空的: 3
🎬 动态演示:定位缺失值与 dropna
不要用 == None 或 == np.nan 判断空值:NaN 在浮点数里是“非数”,它连自己都不等于自己(np.nan == np.nan 的结果是 False)。所以 df['商品名称'] == None 得到的是一片 False,根本挑不出空行。判断缺失值只认 isnull() / notna() 这两个方法。
✅ 本节小结:查缺失值用 isnull()(同义 isna())和 notna();.any() 看“有没有”、.sum() 数“有几个”;具体行用 df[df['列'].isnull()] 挑。NaN 不等于它自己,判断空值只认 isnull。

5.3 删除缺失值:dropna

发现缺失值之后有两种处理方式:删掉(dropna)或填上(fillna,下一节)。先看删除。课件给出的语法是:

【语法】
dropna(axis, how, thresh,
       subset, inplace)
一句话理解
沿哪个方向删、什么条件下删、
哪些列参与判断、删完要不要覆盖原表。
参数作用默认 / 常写
axis删行还是删列:0 = 删记录,1 = 删字段默认 0
how'any':只要有空就删;'all':整行全空才删默认 'any'
thresh至少要有 n 个非空值,否则删掉这一行thresh=6
subset只看指定的列有没有空,别的列不管subset=['商品名称']
inplace是否直接改原表(返回 None)默认 False

how='any' 和 how='all' 的区别,画成图最清楚:前者是“身上有一个洞就淘汰”,后者是“整个都是洞才淘汰”。

dropna 的 how:删“有空的”,还是删“全空的”? 原始数据(示意,只看 2 列) 商品名称 数量 围巾 12 NaN NaN T恤 5 卫衣 NaN how='any' how='all' how='any'(默认):有 1 个 NaN 就删 → 保留 2 行 围巾 12 T恤 5 第 2 行(两格全空)、第 4 行(数量空)都被删掉 how='all':整行全空才删 → 保留 3 行 围巾 12  T恤 5 卫衣 NaN(只空了一格,留下) 只有第 2 行“两格全空”,被删掉 实际订单表没有整行全空的记录 → how='all' 一行都不删 还有第三条路 thresh=n(至少 n 个非空才留)和 subset=['商品名称'](只盯指定列),都比“整表一刀切”更精准。
图 8-12 dropna 的 how='any' 与 how='all':前者“见空就删”,后者“全空才删”;subset 和 thresh 是把删除条件说得更细的两个参数

回到订单数据:默认 dropna() 会把第 9 行(302009)整行删掉,只剩 11 行;how='all' 因为没有任何一行是整行全空,所以一行都不删:

默认 dropna() 删掉含空值的整行:12 行变 11 行,删的是 302009
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('删除前:', df.shape)
clean = df.dropna()
print('删除后:', clean.shape)
dropped = df.loc[df.index.difference(clean.index), '订单编号'].tolist()
print('被删掉的订单编号:', dropped)
print('删完还有空值吗?', clean.isnull().any().any())
运行结果(实测)
删除前: (12, 7)
删除后: (11, 7)
被删掉的订单编号: [302009]
删完还有空值吗? False

再用 how='all'、subset、axis=1 三种写法对比一下。注意 axis=1 是删列:商品名称、单价、数量三列各有空值,整列被删掉,只剩 4 列:

how='all' 一行不删、subset 只盯一列、axis=1 整列删掉:四种写法四种形状
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print("默认 any:", df.dropna().shape)
print("how='all':", df.dropna(how='all').shape)
print("subset 只看商品名称:", df.dropna(subset=['商品名称']).shape)
print('axis=1 删列:', df.dropna(axis=1).shape)
print('保留的列:', list(df.dropna(axis=1).columns))
运行结果(实测)
默认 any: (11, 7)
how='all': (12, 7)
subset 只看商品名称: (11, 7)
axis=1 删列: (12, 4)
保留的列: ['订单编号', '订单日期', '用户ID', '金额']
inplace=True 的返回值是 None:df = df.dropna(inplace=True) 是一句经典的错代码——原表确实被改了,但赋值时拿到的是 None,于是 df 变成了空值,后面一用就报 AttributeError。推荐统一写不覆盖的版本:df = df.dropna(),谁都能一眼看出 df 被替换了。
删之前先问三个问题:缺失的比例有多大?(少删多填)缺失的是关键字段吗?(订单编号空了,这行基本没用;备注空了无所谓)删除后会不会影响分组统计的基数?课件例 8-8 的做法是 df.dropna(inplace=True) 后直接导出清洗结果,实际项目里建议先另存一份、核对行数变化再覆盖。
✅ 本节小结:dropna() 默认 axis=0、how='any',删掉“有空的记录”;how='all' 删“全空的记录”、subset 只盯指定列、thresh 按非空个数删、axis=1 删列。别写 df = df.dropna(inplace=True)。

5.4 填充缺失值:fillna

删数据是“减少样本换质量”,如果缺失的只是一两个格子、而这一行别的信息很有价值(比如 302009 的金额 540 元还在),更合适的做法是把它填上。课件给出的语法是 fillna(value, method, axis, inplace, limit),常用的填充策略有三种:

① 固定值

业务上知道“空”代表什么:商品名称填 '未知商品'、数量填 0、备注填“无”。

df.fillna({'数量': 0})

② 均值 / 中位数

数值列用整列的均值或中位数“猜”一个合理的数,适合分布比较均匀的数据。

df['数量'].fillna(df['数量'].mean())

③ 前向填充

用上一行的值补(ffill),适合按时间顺序记录、相邻记录往往相似的数据。

df.ffill()

第一种:按列给固定值。这里给“商品名称”填“未知商品”,给“单价”“数量”填 0,再检查还剩几个空:

按列填固定值:fillna 传字典 {'列名': 值},缺失格一次补上
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

fixed = df.fillna({'商品名称': '未知商品', '单价': 0, '数量': 0})
print(fixed.loc[[8], ['商品名称', '单价', '数量']])
print('还剩下的缺失格:', int(fixed.isnull().sum().sum()))
运行结果(实测)
   商品名称   单价   数量
8  未知商品  0.0  0.0
还剩下的缺失格: 0

第二种:用数值列的均值填。数量列 11 个非空值的平均数是 15.55,就把空的那格补成 15.55。注意 mean() 默认会跳过 NaN,所以算出来的均值本身不受缺失值影响:

用均值填数量:非空值的平均值 15.55,填完这一列不再有 NaN
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

mean = round(df['数量'].mean(), 2)
print('数量列均值:', mean)
filled = df.copy()
filled['数量'] = filled['数量'].fillna(mean)
print(filled.loc[[8], ['数量']])
print('数量列还有空值吗?', filled['数量'].isnull().any())
运行结果(实测)
数量列均值: 15.55
      数量
8  15.55
数量列还有空值吗? False

第三种:前向填充。把第 7、8、9 行(302008、302009、302010)取出来对比——ffill 会把上一行的值“抄”到空位上:

前向填充 ffill:空格抄上一行的值,商品名称和数量都补齐
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

cols = ['商品名称', '数量']
print('填充前(第 7—9 行):')
print(df[cols].loc[[7, 8, 9]])
print('ffill 之后:')
print(df.ffill()[cols].loc[[7, 8, 9]])
运行结果(实测)
填充前(第 7—9 行):
  商品名称    数量
7   T恤   5.0
8  NaN   NaN
9  休闲鞋  30.0
ffill 之后:
  商品名称    数量
7   T恤   5.0
8   T恤   5.0
9  休闲鞋  30.0
🎬 动态演示:填充缺失值的三种策略
pandas 3 已经删掉了 fillna(method='ffill'):课件语法里的 method 参数在 pandas 2.1 起被标记弃用,pandas 3 里直接报 TypeError: NDFrame.fillna() got an unexpected keyword argument 'method'。现在统一写成 df.ffill()(前向填充)和 df.bfill()(后向填充)——功能一样,写法更清楚。旧教材、旧博客里的 fillna(method='ffill') 抄过来是跑不通的。
填什么值,是业务问题不是技术问题:商品名称缺了,填“未知商品”;数量缺了,用均值或 0 都行,但要说明口径;单价千万别填 0——0 会把“单价×数量=金额”的校验彻底搞乱,宁可填均值或直接删行。填完之后一定再跑一次 isnull().sum() 确认真的填干净了,别让某一列因为类型不匹配没填上。
✅ 本节小结:fillna() 三招——固定值(按列传字典)、均值/中位数(数值列常用)、前向填充(df.ffill())。pandas 3 没有 method= 参数了;填什么值要按业务口径定,单价不能填 0。

5.5 异常值:查找与处理

异常值一般指数据采集错误,或超出正常范围、不合逻辑的数据。它最麻烦的地方在于:缺失值和重复值都能用现成方法查,异常值却往往要你自己定义规则——课件 8.4.2 里商家认为“单价大于 150 的商品一次订购数量超过 25 件”是异常,这就是一条业务规则。

订单数据里有两类异常:

查找异常值靠条件查询 + 布尔索引,两个条件用 & 连起来,每个条件都要加小括号(不加括号的报错下一节会专门演示):

查异常值:单价 > 150 且数量 > 25(例 8-10)、金额为 0(例 8-9)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('单价 > 150 且数量 > 25:')
print(df[(df['单价'] > 150) & (df['数量'] > 25)][['订单编号', '单价', '数量']])
print('金额为 0:')
print(df[df['金额'] == 0][['订单编号', '数量', '金额']])
运行结果(实测)
单价 > 150 且数量 > 25:
     订单编号     单价    数量
9  302010  162.0  30.0
金额为 0:
      订单编号   数量   金额
10  302011  0.0  0.0

查到之后,处理方式有两种。删除用 drop(index=异常行的索引),这正是课件例 8-10 的做法:先拿到 df_err.index,再一次性删掉:

删除异常值:先取异常行的 index,再 drop(index=...) 一次性删掉
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

err = df[(df['单价'] > 150) & (df['数量'] > 25)]
print('异常行订单编号:', err['订单编号'].tolist())
print('删除前:', df.shape)
clean = df.drop(index=err.index)
print('删除后:', clean.shape)
print('还查得到 302010 吗?', 302010 in clean['订单编号'].values)
运行结果(实测)
异常行订单编号: [302010]
删除前: (12, 7)
删除后: (11, 7)
还查得到 302010 吗? False

另一种是替换:把明显不合理的值改成一个合理的上限/下限,比直接删掉保留更多信息。用 loc[条件, 列] = 值 精确修改,或者用 clip(lower, upper) 一次性把整列“裁剪”到区间内:

替换异常值:loc 精确改 + clip 批量裁剪,把超限值压回合理区间
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

fix = df.copy()
fix.loc[fix['数量'] == 0, '数量'] = 1
fix.loc[fix['单价'] > 150, '单价'] = 150
print(fix[fix['订单编号'].isin([302010, 302011])][['订单编号', '单价', '数量']])
print('clip 把数量压到 1—25:')
print(df['数量'].clip(lower=1, upper=25).tolist())
运行结果(实测)
      订单编号     单价    数量
9   302010  150.0  30.0
10  302011  150.0   1.0
clip 把数量压到 1—25:
[12.0, 7.0, 24.0, 24.0, 14.0, 15.0, 15.0, 5.0, nan, 25.0, 1.0, 25.0]
异常值的“阈值”是业务定的,不是 Pandas 定的:为什么单价 150、数量 25 是界限?因为商家说“一次订 25 件以上、单价还超过 150 的,不像正常零售”。换一家店、换一个品类,阈值全都要重定。所以看到异常值先别删,先跟业务确认;删之前可以另存一份原始数据(用 to_excel 备份),万一删错了还找得回来。
✅ 本节小结:异常值用业务规则 + 条件查询找((df['单价'] > 150) & (df['数量'] > 25),括号不能少);处理有两种——drop(index=err.index) 删除、loc 赋值或 clip 替换。规则由业务定,删改前先备份。

5.6 重复值:duplicated 与 drop_duplicates

重复值指不同记录在同一个字段上有相同的取值;通常把“所有字段值都相同”的记录视为重复记录。订单数据里第 6、7 行就是一对完全重复的 302006:订单编号、日期、用户、商品、单价、数量、金额全一样。

课件给出两个方法,一个用来查、一个用来删:

查:duplicated(subset, keep)
返回布尔序列:True = 这条是重复记录。
subset:按哪些列判断,默认全部列。
keep:'first' 默认 / 'last' / False。
删:drop_duplicates(subset, keep, inplace)
按同样的规则删掉重复行。
keep='first':保留第一次出现的;
keep='last':保留最后一次出现的;
keep=False:所有重复的全部删掉。

keep 的三种取值决定了“留哪一条”,下面这张图把三种结果摆在一起:

keep 决定留哪一条:first 留第一条、last 留最后一条、False 全删 行号 订单编号 商品名称 keep='first' keep='last' keep=False 5 302006 卫衣 保留 ✓ 删除 ✗ 删除 ✗ 6 302006 卫衣 删除 ✗ 保留 ✓ 删除 ✗ 7 302008 T恤 保留 ✓ 保留 ✓ 保留 ✓ 11 302012 围巾 保留 ✓ 保留 ✓ 保留 ✓ 结果行数:keep='first' → 11 行 · keep='last' → 11 行 · keep=False → 10 行 keep=False 的语义是“把重复的全部删掉”——所以 302006 的两条会一起消失,而不是留下一条。 subset 可以指定“按哪几列判重”:默认所有列;只按订单编号判重时,编号相同的就算重复。
图 8-13 重复值 keep 的三种取值:first 留第一条、last 留最后一条、False 把重复的全部删掉,所以行数会不一样

先用 duplicated(keep=False) 把“所有重复记录”都标出来(课件例 8-11 的第一步),再对比三种 keep 标记出来的数量:

duplicated(keep=False) 两行都标 True,方便把重复记录一起显示出来
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print("keep='first' 标出:", df.duplicated().sum(), '行')
print("keep='last'  标出:", df.duplicated(keep='last').sum(), '行')
print("keep=False   标出:", df.duplicated(keep=False).sum(), '行')
print(df[df.duplicated(keep=False)][['订单编号', '订单日期', '商品名称', '金额']])
print('按子集(去掉单价数量)判重:',
      df.duplicated(subset=['订单日期', '用户ID', '商品名称']).sum(), '行')
运行结果(实测)
keep='first' 标出: 1 行
keep='last'  标出: 1 行
keep=False   标出: 2 行
     订单编号       订单日期 商品名称      金额
5  302006 2021-02-08   卫衣  1897.5
6  302006 2021-02-08   卫衣  1897.5
按子集(去掉单价数量)判重: 1 行

删除就交给 drop_duplicates()。默认 keep='first' 只留第一次出现的那条;写 keep=False 会把两条都删掉:

drop_duplicates 去重:默认留一条变 11 行,keep=False 两条全删变 10 行
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('去重前:', df.shape)
print("keep='first':", df.drop_duplicates().shape)
print('keep=False:', df.drop_duplicates(keep=False).shape)
kept = df.drop_duplicates()
print('302006 还剩几条:', int((kept['订单编号'] == 302006).sum()))
运行结果(实测)
去重前: (12, 7)
keep='first': (11, 7)
keep=False: (10, 7)
302006 还剩几条: 1
🎬 动态演示:重复值 keep 的三种取值
重复 ≠ 错误:两条一模一样的记录,可能是系统重复写入的脏数据,也可能是顾客真的在同一时刻下了两单一样的商品。先看业务含义再删。另外,判重不一定要用全部字段:订单表里“订单编号”应该是唯一键,subset=['订单编号'] 判重往往比全字段判重更符合业务;而导出前要去掉重复,则常用全部字段,避免把两笔真实订单误删。
✅ 本节小结:duplicated() 查重复、drop_duplicates() 删重复;keep 三种取值——first 留第一条、last 留最后一条、False 全删;subset 指定按哪些列判重。同一个业务问题,判重口径不同,删掉的行数就不同。

5.7 其它加工(选学,课件 8.4.4 考试不要求)

课件把这一节标为“其它处理(考试不要求)”,但实际做数据分析时非常常用——它属于“数据加工”:把原始字段变成更适合分析的新字段。三件小事:

用户 ID 是 6 位数字,前两位代表地区。先 astype('str') 转成字符串,再用 .str[0:2] 切片抽取(注意:不转字符串直接切整数列会报错——整数没有 .str 访问器):

astype('str') 转类型 + .str[0:2] 抽地区编码(例 8-12、8-13)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

df['用户ID'] = df['用户ID'].astype('str')
df['地区编码'] = df['用户ID'].str[0:2]
print(df[['用户ID', '地区编码']].head(4))
print('用户ID 的 dtype:', df['用户ID'].dtype)
print('一共有几个地区:', df['地区编码'].nunique())
运行结果(实测)
     用户ID 地区编码
0  137401   13
1  177562   17
2  133422   13
3  138462   13
用户ID 的 dtype: str
一共有几个地区: 7

日期字段的 dt 访问器更好用:年、月、日、星期、季度、ISO 周次都能直接取。课件例 8-14 要统计每种商品每周的销量,第一步就是加一列“周次”:

dt.isocalendar().week 提周次、dt.year / dt.month 提年月(例 8-14)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

df['年'] = df['订单日期'].dt.year
df['月'] = df['订单日期'].dt.month
df['周次'] = df['订单日期'].dt.isocalendar().week.astype(int)
print(df[['订单日期', '年', '月', '周次']].head(4))
print('每个周次有几条订单:')
print(df['周次'].value_counts().sort_index())
运行结果(实测)
        订单日期     年  月  周次
0 2021-02-01  2021  2   5
1 2021-02-01  2021  2   5
2 2021-02-01  2021  2   5
3 2021-02-05  2021  2   5
每个周次有几条订单:
周次
5    5
6    3
7    2
8    2
Name: count, dtype: int64
为什么 .dt.isocalendar().week 后面要加 .astype(int):isocalendar() 返回的是特殊整数类型(dtype 显示 UInt32,无符号整数),直接打印或参与运算时容易和普通整数对不上;转成普通 int 最省事。另外周次按 ISO 标准算(周一是一周第一天),和日历上“第几周”可能有出入,做报表时口径要统一。
✅ 本节小结:数据加工三件套——astype() 转类型、.str[0:2] 抽字段、dt.year / month / day / isocalendar().week 提时间;加工出的新列(地区编码、周次)正是后面分组统计最好用的分组键。选学内容,但实战高频。
六

数据查询与筛选 高频操作

df[行][列] 先定范围再定字段 · 比较运算造布尔掩码 · 多条件 & | ~ 每个都加括号 · between / isin 偷懒写法 · nlargest 与 sort_values 取 Top N · 链式赋值在 CoW 下一定不生效

数据清洗干净了,接下来就是从表里把要的行、要的列找出来——这是数据分析中使用频率最高的一类操作。课件 8.5 节说:“数据查询是数据分析中最常用的方法,可以通过下标或筛选条件查询。”例 8-15 到例 8-27 全是这一节的内容。

查询的套路可以概括成一句话:先定行,再定列。df[行][列] 两个方括号,第一个管“要哪些行”(切片、条件、索引),第二个管“要哪些列”(列名、列名列表)。理解了这个结构,后面所有写法都是它的变体。

6.1 行与列的查询

最基础的三种查询方式,课件分别给了三个例子:

需求写法对应例子
从某个位置开始取几行df[100:105](按位置切,不含右端)例 8-15
只要某几列df[['商品名称','数量','周次']]例 8-16
先取前 3 行、再取其中几列df[:3][['商品名称','数量']]例 8-17

要点有两个。第一,方括号里给切片,选的是行;给列名或列名列表,选的是列。第二,df[a:b] 的切片是按位置数的,等价于 iloc[a:b],跟行索引的标签无关:写 df[2:5] 就是“从第 2 行开始、取到第 5 行之前”,一共 3 行。

课件在 310 行数据上写的是 df[100:105];本页的精简数据只有 12 行,所以改成 df[2:5],规则完全一样:

行切片 df[2:5] 取第 2—4 行、df[:3] 取前 3 行(例 8-15)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('df[2:5] —— 从第 2 行开始取 3 行(不含 5):')
print(df[2:5][['订单编号', '商品名称', '金额']])
print('df[:3] —— 前 3 行:')
print(df[:3][['订单编号', '商品名称', '金额']])
运行结果(实测)
df[2:5] —— 从第 2 行开始取 3 行(不含 5):
     订单编号 商品名称       金额
2  302003   T恤  1342.32
3  302004  运动服  4284.00
4  302005   T恤   921.20
df[:3] —— 前 3 行:
     订单编号 商品名称       金额
0  302001   围巾   259.20
1  302002  运动服  1470.00
2  302003   T恤  1342.32

选列同理:给一个列名得到的是 Series(一维),给一个列名列表得到的是 DataFrame(二维)。这个区别在链式操作时很重要——Series 上没有“列”的概念了:

选一列是 Series,选多列是 DataFrame;先取行再取列(例 8-16、8-17)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print(df[['商品名称', '数量']].head(3))
print('先取前 3 行、再取两列(例 8-17):')
print(df[:3][['商品名称', '数量']])
print('df["商品名称"] 的类型:', type(df['商品名称']).__name__)
print('df[["商品名称", "数量"]] 的类型:', type(df[['商品名称', '数量']]).__name__)
运行结果(实测)
  商品名称    数量
0   围巾  12.0
1  运动服   7.0
2   T恤  24.0
先取前 3 行、再取两列(例 8-17):
  商品名称    数量
0   围巾  12.0
1  运动服   7.0
2   T恤  24.0
df["商品名称"] 的类型: Series
df[["商品名称", "数量"]] 的类型: DataFrame

当行列都要“精确定位”时,用 loc(按标签/条件)和 iloc(按位置)更清楚。课件 8.1.3 已经讲过这两个方法,这里放到查询场景里再复习一遍:df.loc[行, 列] 两个维度都能用单个标签、标签列表、切片或布尔条件;df.iloc[行号, 列号] 两个维度都只认位置。

loc 看名字、iloc 看座号:同一个格子两种查法
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('loc[3, 商品名称]:', df.loc[3, '商品名称'])
print('loc 取多行多列:')
print(df.loc[[2, 5], ['商品名称', '金额']])
print('iloc[2, 3]:', df.iloc[2, 3])
print('iloc[0:2, 0:3]:')
print(df.iloc[0:2, 0:3])
运行结果(实测)
loc[3, 商品名称]: 运动服
loc 取多行多列:
  商品名称       金额
2   T恤  1342.32
5   卫衣  1897.50
iloc[2, 3]: T恤
iloc[0:2, 0:3]:
     订单编号       订单日期    用户ID
0  302001 2021-02-01  137401
1  302002 2021-02-01  177562
口诀:loc 看名字,iloc 看座号。df.loc[3, '商品名称'] 里的 3 是行标签(本表默认索引正好也是 3);df.iloc[2, 3] 里的 2 和 3 是位置(第 3 行、第 4 列)。两种写法都能取到值,但一旦行索引被改成订单编号,loc[3] 就找不到标签 3 了,而 iloc[2] 照样取第 3 行。写代码时想清楚:我要的是“标签叫这个的”还是“第几个”。
✅ 本节小结:df[a:b] 按位置切行、df[['列']] 选列、df[:3][['列']] 先取行再取列;要精确到“行标签 + 列标签”用 loc,要按“第几行第几列”用 iloc。方括号里给切片 = 选行,给列名 = 选列。

6.2 条件查询:比较运算 + 布尔索引

行切片只能按“第几行”取,真正的查询是按条件取——“金额大于 4000 的订单”“日期是 2 月 28 日的订单”。做法分两步:先让比较运算生成一列 True / False(叫布尔掩码),再把这列掩码塞进方括号里挑行。课件例 8-19 到 8-21 都是这个套路。

比较运算符就是 Python 那六个:==(等于)、!=(不等于)、>、>=、<、<=。注意判断相等是 ==,不是 =;字符串和日期都能直接比较,日期还可以直接写 '2021-02-28' 这样的字符串,Pandas 会自动转换。

数值比较、字符串比较、筛选后再 tail(例 8-18、8-19)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('金额 >= 4000 的订单:')
print(df[df['金额'] >= 4000][['订单编号', '商品名称', '金额']])
print('数量 >= 25 的订单数:', int((df['数量'] >= 25).sum()))
print('商品名称 != 围巾 的订单数:', int((df['商品名称'] != '围巾').sum()))
print('运动服订单的最后 2 条(例 8-18 先筛后 tail):')
print(df[df['商品名称'] == '运动服'].tail(2)[['订单编号', '商品名称', '金额']])
运行结果(实测)
金额 >= 4000 的订单:
     订单编号 商品名称      金额
3  302004  运动服  4284.0
9  302010  休闲鞋  4860.0
数量 >= 25 的订单数: 2
商品名称 != 围巾 的订单数: 10
运动服订单的最后 2 条(例 8-18 先筛后 tail):
      订单编号 商品名称      金额
3   302004  运动服  4284.0
10  302011  运动服     0.0

日期也是同样的比较法。Pandas 的日期列 dtype 是 datetime64,和字符串比较时会自动把字符串转成日期,所以 == '2021-02-28'、> '2021-02-20' 都能直接写:

日期条件查询:等于某一天、大于某一天,字符串自动转日期(例 8-23 的日期条件)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('2 月 28 日的订单:')
print(df[df['订单日期'] == '2021-02-28'][['订单编号', '订单日期', '商品名称']])
print('2 月 20 日之后的订单:')
print(df[df['订单日期'] > '2021-02-20'][['订单编号', '订单日期', '金额']])
运行结果(实测)
2 月 28 日的订单:
      订单编号       订单日期 商品名称
11  302012 2021-02-28   围巾
2 月 20 日之后的订单:
      订单编号       订单日期     金额
10  302011 2021-02-25    0.0
11  302012 2021-02-28  540.0
查询漏斗:每加一个条件,都是在上一轮结果上再筛一遍 ① 全表 df 12 行 × 7 列 12 行 金额 >= 1000 ② 第一轮筛选 剩下 6 行 6 行 302002 · 302003 · 302004 · 302006×2 · 302010 并且 金额 >= 2000 ③ 第二轮筛选 剩下 2 行 2 行 302004 · 302010 并且 数量 >= 25 ④ 命中结果 剩下 1 行 1 行 302010(休闲鞋,30 件,4860 元) 代码里就是在一个方括号里用 & 把条件连起来:df[(df['金额'] >= 2000) & (df['数量'] >= 25)] 把“最严格、能筛掉最多行”的条件放前面,思路会更清楚;每个条件都要用小括号包住。
图 8-14 查询漏斗:全表 12 行 → 金额 ≥ 1000 剩 6 行 → 金额 ≥ 2000 剩 2 行 → 数量 ≥ 25 只剩 1 行;条件越多越精确,表格越小
阈值要按数据的实际范围定:课件例 8-19 用 df.金额 >= 5000,是因为 310 行的完整数据里金额最大 5355,5000 以上确实有记录;本页 12 行精简数据最大才 4860,照抄 5000 会筛出空表。所以这里用 4000。拿到一份新数据,先 describe() 看最大最小值,再决定阈值——这是比记住某个数字更重要的习惯。
✅ 本节小结:条件查询两步走——比较运算先生成 True/False 掩码,再把掩码塞进 df[掩码] 挑行;六个比较运算符照常写,字符串和日期都能直接比较。阈值按数据范围定,别照抄课件里的数字。

6.3 多条件:& | ~ 与小括号

一个条件不够用时,就把多个条件连起来:& 表示“并且”(两个都要满足),| 表示“或者”(满足一个就行),~ 表示“取反”(满足条件的不要)。注意不能写 and / or / not——那是 Python 判断单个真假用的,对一列布尔值会直接报错。

课件例 8-22 查“订购数量超过 25 的卫衣”,例 8-23 查“金额超过 4500、或者是 2 月 28 日的订单”,都是多条件:

两个条件用 & 连起来:单价 > 150 并且数量 >= 10
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

mask = (df['单价'] > 150) & (df['数量'] >= 10)
print('单价 > 150 且数量 >= 10:')
print(df[mask][['订单编号', '商品名称', '单价', '数量']])
print('命中行数:', int(mask.sum()))
print('换成“卫衣且数量 >= 25”(例 8-22):',
      int(((df['数量'] >= 25) & (df['商品名称'] == '卫衣')).sum()), '行')
print('—— 完整 310 行数据里能查到,这份 12 行精简数据里恰好没有')
运行结果(实测)
单价 > 150 且数量 >= 10:
     订单编号 商品名称     单价    数量
3  302004  运动服  178.5  24.0
9  302010  休闲鞋  162.0  30.0
命中行数: 2
换成“卫衣且数量 >= 25”(例 8-22): 0 行
—— 完整 310 行数据里能查到,这份 12 行精简数据里恰好没有
两个条件用 | 连起来:金额 > 4500 或者日期是 2 月 28 日(例 8-23)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

mask = (df['金额'] > 4500) | (df['订单日期'] == '2021-02-28')
print('金额 > 4500 或者日期是 2 月 28 日:')
print(df[mask][['订单编号', '订单日期', '金额']])
print('命中行数:', int(mask.sum()))
print('分别看两个条件各命中几行:',
      int((df['金额'] > 4500).sum()), '和', int((df['订单日期'] == '2021-02-28').sum()))
运行结果(实测)
金额 > 4500 或者日期是 2 月 28 日:
      订单编号       订单日期      金额
9   302010 2021-02-20  4860.0
11  302012 2021-02-28   540.0
命中行数: 2
分别看两个条件各命中几行: 1 和 1
~ 取反:把“等于围巾”翻成“不等于围巾”,也等价于 !=
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

mask = ~(df['商品名称'] == '围巾')
print('不是围巾的订单:', int(mask.sum()), '行')
print(df[mask][['订单编号', '商品名称', '金额']].head(3))
print('和 != 等价吗?', mask.equals(df['商品名称'] != '围巾'))
print('~ 也能翻区间:金额不在 1000—5000 之间的行数:',
      int((~df['金额'].between(1000, 5000)).sum()))
运行结果(实测)
不是围巾的订单: 10 行
     订单编号 商品名称       金额
1  302002  运动服  1470.00
2  302003   T恤  1342.32
3  302004  运动服  4284.00
和 != 等价吗? True
~ 也能翻区间:金额不在 1000—5000 之间的行数: 6

下面这段代码是故意写错的:漏掉了每个条件外面的一对小括号。结果“或”运算先跟数字 4500 和日期列去算,Pandas 直接抛 TypeError。看报错、理解为什么,比背“要加括号”更管用:

故意不加括号:& | ~ 的优先级比比较运算符高,直接 TypeError
import sys
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

sys.tracebacklimit = 0        # 只看错误本身
# 故意漏掉每个条件的小括号
print(df[(df['金额'] > 4500) | df['订单日期'] == '2021-02-28'])
运行结果(实测,故意报错)
TypeError: ufunc 'bitwise_or' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
多条件查询的唯一铁律:每个条件都套一对小括号。写成 (df['金额'] > 4500) & (df['数量'] > 20),小括号里的东西各自算成 True/False,再拿 & / | 合起来。为什么?因为 Python 里位运算符 &、|、~ 的优先级比比较运算符高,不加括号就会先算 4500 | df['订单日期'] 这种“数字和日期按位或”的怪东西——结果不是报错,就是算出完全错误的表。宁可多打十对括号,也不要少打一对。
两个掩码的三种组合:& 逐行“与”、| 逐行“或”、~ 逐行“取反” 商品名称 金额 A:金额 > 2000 B:商品 = 运动服 A & B A | B ~A 围巾 259.2 False False False False True 运动服 1470.0 False True False True True 运动服 4284.0 True True True True False 休闲鞋 4860.0 True False False True False 三种写法的命中结果(都是同一张表上筛出来的行): A & B(两个都 True)→ 302004(运动服、4284 元) A | B(有一个 True 就行)→ 302002、302004、302010、302011(共 4 行) ~A(把 True/False 翻过来)→ 302001、302002、302003、302005、302006、302006、302008、302009、302011、302012(共 10 行) 口诀:& 两个都要、| 一个就够、~ 全部翻转——但每个条件都必须先用小括号括起来。
图 8-15 两个条件掩码的 &、|、~ 合并:& 逐行“两个都 True 才留”,| “有一个 True 就留”,~ 把整列 True/False 翻过来
🎬 动态演示:多条件查询的 & | ~
条件多了就拆成变量:三个以上条件挤在一行里,括号套括号,谁看都头疼。拆开写既清楚又好调试:mask1 = df['金额'] > 2000、mask2 = df['商品名称'] == '运动服',再写 df[mask1 & mask2];还可以先 print(mask1.sum(), mask2.sum()) 看看每个条件各筛掉多少行,哪一步筛空了立刻能发现。
✅ 本节小结:多条件用 &(且)、|(或)、~(非),不能用 and / or / not;每个条件必须加小括号,否则 & | ~ 会先算,直接 TypeError;条件多就拆成中间变量,先看每步命中几行。

6.4 区间与集合:between / isin

“在某个区间内”和“属于某几个值”这两个需求太常见了,Pandas 各给了一个方法,比写两个条件再 & 起来更短:

between(25, 30) 两端都含;想不含两端用 inclusive='neither'(例 8-20)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('数量在 25—30(含两端):')
print(df[df['数量'].between(25, 30)][['订单编号', '商品名称', '数量', '金额']])
left = (df['数量'] >= 25) & (df['数量'] <= 30)
print('与 >= 25 且 <= 30 等价吗?', df['数量'].between(25, 30).equals(left))
print('不含两端(25 和 30 都不算):',
      int(df['数量'].between(25, 30, inclusive='neither').sum()), '行')
运行结果(实测)
数量在 25—30(含两端):
      订单编号 商品名称    数量      金额
9   302010  休闲鞋  30.0  4860.0
11  302012   围巾  25.0   540.0
与 >= 25 且 <= 30 等价吗? True
不含两端(25 和 30 都不算): 0 行
isin(['围巾', '运动服']) 一次匹配多个值(例 8-21)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('围巾和运动服的订单:')
print(df[df['商品名称'].isin(['围巾', '运动服'])][['订单编号', '商品名称', '金额']])
print('命中行数:', int(df['商品名称'].isin(['围巾', '运动服']).sum()))
print('只要围巾:', int(df['商品名称'].isin(['围巾']).sum()), '行')
print('等价写法(两个等于用 | 连):', int(((df['商品名称'] == '围巾') | (df['商品名称'] == '运动服')).sum()), '行')
运行结果(实测)
围巾和运动服的订单:
      订单编号 商品名称      金额
0   302001   围巾   259.2
1   302002  运动服  1470.0
3   302004  运动服  4284.0
10  302011  运动服     0.0
11  302012   围巾   540.0
命中行数: 5
只要围巾: 2 行
等价写法(两个等于用 | 连): 5 行
between 和 isin 都只是“少写几个条件”的糖:between(25, 30) 等价于 (x >= 25) & (x <= 30),isin(['围巾', '运动服']) 等价于 (x == '围巾') | (x == '运动服'),它们返回的都是一列布尔掩码,用法完全一样。区间开闭用 inclusive 调('both' 默认 / 'left' / 'right' / 'neither');isin 的参数必须是列表或集合,写成 isin('围巾') 会报错。
✅ 本节小结:区间用 between(下限, 上限)(默认两端都含,inclusive 可调),集合用 isin([…])(参数必须是列表);两者都只是布尔掩码的简便写法,最终还是要塞进 df[掩码] 里挑行。

6.5 top N 与排序组合

“金额最大的 10 条”“按数量从小到大排”——查询经常和排序绑在一起用。课件给了三个例子:例 8-24 用 nlargest(10, '金额') 取最大 10 条;例 8-25、8-26 用 sort_values 排序;例 8-27 先筛后排。

nlargest(n, 列) 是“取前 n 大”的专用方法,比排序再取头 n 行更直接,也快得多:

nlargest(3, '金额') 取金额最大的 3 条(例 8-24 是 10 条)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('金额最大的 3 条:')
print(df.nlargest(3, '金额')[['订单编号', '商品名称', '金额']])
print('和 sort_values 再 head(3) 结果一样吗?',
      df.nlargest(3, '金额')['订单编号'].tolist() ==
      df.sort_values('金额', ascending=False)['订单编号'].head(3).tolist())
运行结果(实测)
金额最大的 3 条:
     订单编号 商品名称      金额
9  302010  休闲鞋  4860.0
3  302004  运动服  4284.0
5  302006   卫衣  1897.5
和 sort_values 再 head(3) 结果一样吗? True

sort_values 是通用排序:by 指定按哪列(可以给列表)、ascending 指定升序还是降序(可以给列表,实现多列不同方向)、na_position 指定空值放开头还是结尾。例 8-26 就是“金额降序、金额相同时日期升序”:

多列排序:金额降序、金额相同再按订单日期升序(例 8-26)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

sorted_df = df.sort_values(by=['金额', '订单日期'], ascending=[False, True])
print('金额降序、金额相同按日期升序,前 5 条:')
print(sorted_df[['订单编号', '订单日期', '金额']].head(5))
print('空值排最后(na_position 默认 last):',
      df.sort_values('数量')['数量'].tail(2).tolist())
运行结果(实测)
金额降序、金额相同按日期升序,前 5 条:
     订单编号       订单日期      金额
9  302010 2021-02-20  4860.0
3  302004 2021-02-05  4284.0
5  302006 2021-02-08  1897.5
6  302006 2021-02-08  1897.5
1  302002 2021-02-01  1470.0
空值排最后(na_position 默认 last): [30.0, nan]

实际查询最常用的是“先筛后排”:先用条件把范围缩小,再对结果排序——例 8-27 就是“金额至少 2000,再按金额降序”。数据量大的时候,先筛再排也更省时间:

先筛后排:金额 >= 2000 的记录按金额降序(例 8-27)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

result = df[df['金额'] >= 2000].sort_values(by='金额', ascending=False)
print('金额 >= 2000 的订单,按金额降序:')
print(result[['订单编号', '订单日期', '商品名称', '金额']])
print('行数:', result.shape[0], ' 金额合计:', round(result['金额'].sum(), 2))
运行结果(实测)
金额 >= 2000 的订单,按金额降序:
     订单编号       订单日期 商品名称      金额
9  302010 2021-02-20  休闲鞋  4860.0
3  302004 2021-02-05  运动服  4284.0
行数: 2  金额合计: 9144.0
nlargest 和 sort_values + head 怎么选:只想要“最大/最小的 n 条”,用 nlargest(n, 列) / nsmallest(n, 列),它们是专门优化过的,数据量大时快很多;要“整张表按某列排好序”、或者要按多列不同方向排,用 sort_values。另外排序默认不改原表,要保留结果就赋值给新变量:sorted_df = df.sort_values(...)。
✅ 本节小结:取前 n 大用 nlargest(n, 列);排序用 sort_values(by=[…], ascending=[…]) 实现多列多方向;查询的常见组合是先筛选、再排序,结果赋值给新变量,原表不动。

6.6 查询写法对照与链式赋值陷阱

同一个查询,往往有好几种写法。课件里出现的写法,加上推荐的写法,对照着记最清楚:

需求写法说明
取整行、整列df[df['金额'] > 4000]返回 DataFrame,只含命中的行
取命中行的某几列df.loc[df['金额'] > 4000, ['订单编号', '金额']]推荐:一步到位,不会产生中间副本
取命中行的某一列df.loc[df['金额'] > 4000, '金额']返回 Series;也可写 df[df['金额'] > 4000]['金额']
给命中行新增/修改一列df.loc[条件, '新列'] = 值唯一正确写法,见下面的陷阱
字符串条件查询df.query('金额 >= 4000')写起来像 SQL,列名不用加引号,适合复杂条件

现在说这节课最重要的一个坑:链式赋值。有些同学想“给金额超过 4000 的订单加一个标记列”,会写成 df[df['金额'] >= 4000]['标记'] = '大单'。这行代码不会报错,但也不会生效——原表里根本不会出现“标记”列。原因是第一个方括号返回的已经是原表的一个副本,你对副本加列,原表当然不知道。

链式赋值不改原表(pandas 3 写时复制),loc 一步赋值才生效
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0
"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

df[df['金额'] >= 4000]['标记'] = '大单'
print('链式赋值后,原表有“标记”列吗?', '标记' in df.columns)
df.loc[df['金额'] >= 4000, '标记'] = '大单'
print('用 loc 一次定位,才真的写进原表:')
print(df[df['金额'] >= 4000][['订单编号', '金额', '标记']])
print('其余行标记为 NaN:', df['标记'].isnull().sum(), '行')
运行结果(实测)
链式赋值后,原表有“标记”列吗? False
用 loc 一次定位,才真的写进原表:
     订单编号      金额  标记
3  302004  4284.0  大单
9  302010  4860.0  大单
其余行标记为 NaN: 10 行
pandas 3 的写时复制(Copy-on-Write)让链式赋值彻底失效:df[条件]['列'] = 值 这种写法,在 pandas 3 里一定会收到 ChainedAssignmentError 的提示(旧版是 SettingWithCopyWarning),而且真的不会改到原表。正确写法只有一种:把定位和赋值写进同一个 loc——df.loc[条件, '列'] = 值。同理,修改单个格子写 df.loc[行标签, '列'] = 值,不要 df['列'][行] = 值。
df.列名 和 df['列名'] 的区别:df['商品名称'] 永远有效;df.商品名称 只是语法糖,遇到列名带空格、以数字开头、或者和 DataFrame 自带方法同名(比如列名叫 count、sum、mean)就会失效或取到方法本身。统一写方括号,少踩一类坑。另外 df.query() 适合把条件写成字符串,列名里有中文时直接用反引号包住即可,例如 df.query('`金额` >= 4000')。
✅ 本节小结:查询优先用 df.loc[行条件, 列] 一步到位;链式赋值 df[条件]['列'] = 值 在 pandas 3 的 CoW 下一定不生效,改数据只认 df.loc[条件, '列'] = 值;列名统一用方括号访问,属性访问只在列名合法时才是语法糖。
七

统计聚合与数据透视表 本章重点

描述统计 · 频数统计 · groupby 分组聚合 · 结果整形 · pd.cut 分区统计 · resample 重采样 · pivot_table 数据透视表

前面几节一直在做同一件事:把数据“挑”出来——挑行、挑列、按条件挑。从这一节开始换方向:不再挑,而是把数据“压”下去,把很多行压成一个数。这就是“统计聚合”:先算总账(描述统计),再按类算账(分组统计),再按区间算账(分区统计),最后把行、列、值三个维度同时摆开算账(数据透视表)。

一句话概括这一节的四个层次:整列压成 1 个数 → 每类压成 1 个数 → 每档压成 1 个数 → 行×列交叉处各压成 1 个数。压的方式(求和、平均、计数)可以换,压的维度可以换,但“压”这个动作始终不变。这一节继续用 4.x 节那份 12 行精简订单数据(订单编号、订单日期、用户ID、商品名称、单价、数量、金额 共 7 列),它刻意留着缺失值、重复值和异常值——正好用来看清“分组、透视之前为什么必须先清洗”。

本模块主线:描述统计(一列压成一个数)→ 频数统计(数一数谁最多)→ groupby(拆组 → 算 → 拼回)→ 结果整形(索引怎么变回列)→ pd.cut(连续值切档)→ resample(按时间周期切档)→ pivot_table(行 × 列 × 值 三个维度一起汇总)。

7.1 描述统计

描述统计是最快的一次“数据体检”:不看明细,只看几个能代表整列的数——总量(sum)、条数(count)、平均(mean)、最值(max / min)、离散程度(std)。这些方法都挂在 DataFrame 或 Series 上,一行代码一个指标,返回的是标量(单个数字)或一个短的 Series(多列时每列一个数)。

方法算的是什么返回什么订单数据上的写法
sum()求和单个数值df['金额'].sum()
count()非空值的个数单个整数df['订单编号'].count()
mean()算术平均单个数值df['金额'].mean()
max() / min()最大 / 最小单列→标量;多列→Seriesdf[['数量','金额']].max()
std()标准差(越大越分散)单个数值df['金额'].std()
describe()一次给出 count / mean / std / min / 四分位 / max8 行的 Series(多列时是表)df[['单价','数量','金额']].describe()

先看【例 8-28】中最基本的几句。注意一个细节:这些函数默认跳过缺失值(skipna=True),所以 count() 数的是“非空个数”,比行数少。这份订单数据 12 行,商品名称 只有 11 个非空——少了的那一行是第 9 条记录(订单 302009,商品名称、单价、数量都为空,但金额 540.0 还在)。

例 8-28(上):整列求和 / 计数 / 最值 / 平均 / 标准差
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('订购总金额:', round(df['金额'].sum(), 2))
print('订单记录数(非空):', df['订单编号'].count())
print('最大的数量与金额:')
print(df[['数量', '金额']].max())
print('平均金额:', round(df['金额'].mean(), 2))
print('金额标准差:', round(df['金额'].std(), 2))
运行结果(实测)
订购总金额: 18340.72
订单记录数(非空): 12
最大的数量与金额:
数量      30.0
金额    4860.0
dtype: float64
平均金额: 1528.39
金额标准差: 1558.3

max() 用在多列上时返回的是一个短 Series:数量 那一列最大 30,金额 那一列最大 4860。这两个最大值不一定来自同一条记录——这是初学者最容易误会的地方:整列求最大值是“各列各自比”,不是“挑出金额最大的那一整行”。要挑整行,得用 6.5 节的 nlargest() 或布尔索引。

描述统计真正的威力在条件子集上:先按条件把行筛出来,再统计,就得到“某一类商品 / 某个金额段”的专门指标。这一段把【例 8-28】剩下的几句和 describe() 放在一起看。

例 8-28(下):条件子集统计 + describe() 一次看 8 个指标
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('休闲鞋的订购总数量:', df[df.商品名称 == '休闲鞋']['数量'].sum())
print('金额达到 3000 的订单数:', df[df.金额 >= 3000]['订单编号'].count())
print('金额达到 3000 的金额合计:', df[df.金额 >= 3000]['金额'].sum())
print('运动服的平均单价:', round(df[df.商品名称 == '运动服']['单价'].mean(), 2))
print('三个金额列的 describe:')
print(df[['单价', '数量', '金额']].describe().round(2))
运行结果(实测)
休闲鞋的订购总数量: 30.0
金额达到 3000 的订单数: 2
金额达到 3000 的金额合计: 9144.0
运动服的平均单价: 189.0
三个金额列的 describe:
           单价     数量       金额
count   11.00  11.00    12.00
mean   110.25  15.55  1528.39
std     67.15   9.40  1558.30
min     21.60   0.00     0.00
25%     60.86   9.50   487.25
50%    126.50  15.00  1131.76
75%    170.25  24.00  1897.50
max    210.00  30.00  4860.00

describe() 一次给出 8 个数,读法有讲究:count 是非空个数,单价、数量 都是 11 而不是 12,说明各缺 1 个;mean 是全列平均,数量 的平均是 15.55 件;50% 是中位数,金额 的中位数 1131.76 明显小于均值 1528.39,说明金额分布被几笔大单拉高了——这正是后面要学的“偏态”。金额 的 min 是 0(订单 302011 数量为 0、金额为 0),这是异常值,8.4 节要处理它。

pandas 3 实测提示:本页所有输出都是 pandas 3.0.5 的真实运行结果。旧教材里的 describe() 只对数值列生效,这一点没变;但 df.info() 的输出格式变了(首行是 <class 'pandas.DataFrame'>、字符串 dtype 显示为 str、日期显示为 datetime64[us]),和课件截图不完全一样,对比时不要慌。另外 value_counts() 结果的 Series 名字是 count,而不是旧版的 “商品名称”。
✅ 本节小结:描述统计把一列压成一个数——sum / count / mean / max / min / std 各管一个指标,describe() 一次给 8 个。单列返回标量、多列返回短 Series;默认跳过缺失值,所以 count() 数的是非空个数。真正有用的是条件子集再统计:df[条件]['列'].sum()。

7.2 频数统计

描述统计回答“多少、多大”,频数统计回答另一个问题:“哪一类最多、一共几类、每类占多少”。它面对的是离散的类别(商品名称、产地、用户 ID),而不是连续的金额。三个方法分工明确:

value_counts()

  • 数每个取值各出现几次
  • 结果按次数降序排好
  • normalize=True 把次数换成占比
  • 默认不统计缺失值

mode()

  • 只返回出现次数最多的取值(众数)
  • 平局时返回多个,不是只挑一个
  • 结果仍是 Series,不是单个字符串

nunique()

  • 数有几个不同的值
  • 只要种类数,不关心各出现几次
  • dropna=False 把 NaN 也算一类
value_counts 与 mode:各商品有多少条记录、谁最多
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('各商品的订单记录数:')
print(df['商品名称'].value_counts())
print('各商品的记录占比:')
print(df['商品名称'].value_counts(normalize=True).round(2))
print('出现次数最多的商品(可能并列):')
print(df['商品名称'].mode())
运行结果(实测)
各商品的订单记录数:
商品名称
运动服    3
T恤     3
围巾     2
卫衣     2
休闲鞋    1
Name: count, dtype: int64
各商品的记录占比:
商品名称
运动服    0.27
T恤     0.27
围巾     0.18
卫衣     0.18
休闲鞋    0.09
Name: proportion, dtype: float64
出现次数最多的商品(可能并列):
0     T恤
1    运动服
Name: 商品名称, dtype: str

输出里有两处值得停下来看。第一,value_counts 没有把缺失值算进去:5 种商品加起来 3+3+2+2+1 = 11,而不是 12 行,少的那 1 行就是商品名称为 NaN 的订单 302009。第二,mode() 返回了两行——T恤 和 运动服 都是 3 条记录,并列第一;所以 mode() 的结果要按 Series 用,取 [0] 只是“并列中的第一个”,不代表它是唯一的。还有一点容易误读:卫衣 显示 2 条,其实业务上只有 1 张订单——第 6、7 行是完全重复的两条记录(订单 302006),频数统计会如实把它们数成 2。

nunique:数“有几个不同的值”,dropna 决定 NaN 算不算一类
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

print('商品种类数:', df['商品名称'].nunique())
print('商品种类数(含 NaN 一类):', df['商品名称'].nunique(dropna=False))
print('下单用户数:', df['用户ID'].nunique())
print('有订单的日期数:', df['订单日期'].nunique())
print('订单编号去重后有几个:', df['订单编号'].nunique())
运行结果(实测)
商品种类数: 5
商品种类数(含 NaN 一类): 6
下单用户数: 9
有订单的日期数: 8
订单编号去重后有几个: 11

nunique 的结果比行数更能说明“数据有多少信息量”:12 行记录里只有 11 个不同订单号(302006 重复了)、9 个用户、8 个日期。这三个数字是后面分组、透视的基础——分组的组数 = 分组键的 nunique;而 8 个日期做透视默认只得到 7 行:2021-02-15 那天只有一条商品名称为空的订单,整行被 dropna=True 丢弃(写 dropna=False 才会保留 8 行)。

✅ 本节小结:value_counts() 数每个取值出现几次、默认降序、不统计 NaN,normalize=True 变占比;mode() 只给出现最多的取值,并列时返回多行;nunique() 数有几个不同值,是“分组会有多少组”的预告。

7.3 分组统计:groupby + agg

7.1 把整列压成一个数,但业务问题几乎都是“某一类有多少”:每种商品卖了多少、每周卖了多少、每个人买了多少。做法叫分组聚合,pandas 把它拆成两个动作:

步骤方法作用结果
① 分组df.groupby(by)按 by 指定的列(或列列表)把行拆成若干组一个 GroupBy 对象(不是表,看不见内容)
② 聚合.agg({'列': '函数'})对每组的指定列套用统计函数一张以分组键为索引的汇总表

参数方面,groupby(by, axis, as_index, sort):by 是分组依据(字段、字段列表、函数、字典、Series 都行);axis 默认 0;as_index 决定分组键要不要变成结果的索引,默认 True;sort 决定结果按不按分组键排序,默认 True。agg() 的参数是字典,键是列名、值是函数名,一次能给不同列配不同函数。

下面这张图把 groupby 的内部动作画出来:拆(split)→ 算(apply)→ 拼(combine)。理解这三步,后面所有分组、透视的写法都是它的变体。

groupby 的三步:拆(split)→ 算(apply)→ 拼(combine) ① 原表(12 行 · 只画 6 行) 商品名称 金额 围巾 259.20 运动服 1470.00 T恤 1342.32 运动服 4284.00 卫衣 1897.50 围巾 540.00 … 同名的行要归到一组, 行序被打乱也没关系 ② 拆:按商品名称分组 围巾 259.20 540.00 =2 行 运动服 1470.00 4284.00 =2 行 T恤 1342.32 (实际 3 行,合计 2592.52) 卫衣 1897.50 (另有休闲鞋一组) 组数 = 分组键的 nunique = 5 组 商品名称是 NaN 的那 1 行会被丢弃 ③ 合:每组 sum 一次 商品名称 金额 围巾 799.20 运动服 5754.00 T恤 2592.52 卫衣 3795.00 休闲鞋 4860.00 5 行 = 5 组,索引是商品名称 df.groupby('商品名称', as_index=False).agg({'金额': 'sum'}) 就是把上面三步写成一行 拆 看分组键 · 算 看 agg 里的函数 · 拼 看 as_index(默认 True:分组键当索引;False:分组键留作普通列)
图 8-16 groupby 的拆分—应用—合并:按分组键把行拆成组,每组把多行压成一个数,再拼成“一组一行”的汇总表

先写【例 8-29】的“统计每种商品的订购总金额,再按金额降序”。这里的 as_index=False 很关键:它让 商品名称 留作一列,而不是变成索引,这样后面 sort_values('金额') 才能直接按列排。

例 8-29:每种商品的订购总金额,按金额降序排
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

df1 = df.groupby(by='商品名称', as_index=False).agg({'金额': 'sum'})
print('分组结果(as_index=False,商品名称还是普通列):')
print(df1)
print('按金额降序:')
print(df1.sort_values('金额', ascending=False))
运行结果(实测)
分组结果(as_index=False,商品名称还是普通列):
  商品名称       金额
0   T恤  2592.52
1  休闲鞋  4860.00
2   卫衣  3795.00
3   围巾   799.20
4  运动服  5754.00
按金额降序:
  商品名称       金额
4  运动服  5754.00
1  休闲鞋  4860.00
2   卫衣  3795.00
0   T恤  2592.52
3   围巾   799.20
注意那 540 元去哪了:5 组金额加起来是 799.20 + 5754.00 + 2592.52 + 3795.00 + 4860.00 = 17800.72,而 7.1 里整列 df['金额'].sum() 是 18340.72,正好差 540.00。差的这一笔就是订单 302009:它的商品名称是 NaN,而 groupby 默认把分组键为缺失值的行整个丢掉。这就是“先清洗再分析”的最直接理由——不清洗,汇总数就会悄悄少一块,而且不报错。

【例 8-30】到【例 8-34】是同一台机器的不同用法,关键在 agg 里放什么:一个字典可以让不同的列用不同的函数,也可以让同一列同时给多个函数(值写列表)。先看按周次的组合统计——周次用 dt.isocalendar().week 从日期里抽出来(8.4.4 节讲过)。

例 8-32:每周金额的最小值 / 最大值 + 数量合计(agg 传字典和列表)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
df['周次'] = df['订单日期'].dt.isocalendar().week.astype(int)

print('每周金额 min / max,数量 sum(不同列不同函数):')
print(df.groupby('周次').agg({'金额': ['min', 'max'], '数量': 'sum'}))
print('每周订单条数与金额合计(同一列也给两个函数):')
print(df.groupby('周次').agg({'订单编号': 'count', '金额': 'sum'}))
运行结果(实测)
每周金额 min / max,数量 sum(不同列不同函数):
       金额            数量
      min     max   sum
周次                     
5   259.2  4284.0  81.0
6   329.0  1897.5  35.0
7   540.0  4860.0  30.0
8     0.0   540.0  25.0
每周订单条数与金额合计(同一列也给两个函数):
    订单编号       金额
周次               
5      5  8276.72
6      3  4124.00
7      2  5400.00
8      2   540.00

输出里出现了两层列名(第一层是列名、第二层是函数名):当 agg 的值是列表时,结果的列会自动变成 MultiIndex。想把它压回单层,可以用 7.4 节的reset_index() 配合有名聚合(agg(新列名=('原列','函数'))),或者干脆分两次算再 concat。初学阶段最实用的还是有名聚合写法:df.groupby('周次').agg(最低金额=('金额','min'), 最高金额=('金额','max')),出来的列名一眼就懂。

【例 8-31】和【例 8-34】要按两个字段分组(周次 + 商品名称),by 传列表即可,结果的行索引是两层。as_index=False 能把两个分组键都变回普通列,配合多列排序更好读。

例 8-31 / 8-34:每周各商品的订购总数量与总金额(按两列分组)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
df['周次'] = df['订单日期'].dt.isocalendar().week.astype(int)

g = df.groupby(['周次', '商品名称'], as_index=False).agg({'数量': 'sum', '金额': 'sum'})
print('每周各商品:')
print(g.sort_values(['周次', '金额'], ascending=[True, False]))
运行结果(实测)
每周各商品:
   周次 商品名称    数量       金额
2   5  运动服  31.0  5754.00
0   5   T恤  38.0  2263.52
1   5   围巾  12.0   259.20
4   6   卫衣  30.0  3795.00
3   6   T恤   5.0   329.00
5   7  休闲鞋  30.0  4860.00
6   8   围巾  25.0   540.00
7   8  运动服   0.0     0.00

这张表就是“一周 × 一件商品 = 一行”的长表,共 8 行——不是因为每周都有 5 件商品,而是只把有订单的组合列出来(第 5 周没卖卫衣,就没有“5 周 / 卫衣”这一行)。这正是下一节透视表的起点:透视表要做的,就是把这些“缺的格子”补齐成规整的矩阵。

顺带说【例 8-33】:那道题要的是“每天的订单数量和总金额”,只需要把分组键从周次换成订单日期,用两个不同的函数分别数条数和求和:df.groupby('订单日期').agg({'订单编号': 'count', '金额': 'sum'})。后面 7.5 节算每日总金额做分箱时,用的就是它的简化版。

🎬 动态演示:groupby —— 先拆组,再聚合
✅ 本节小结:groupby(by, as_index, sort) 只负责拆组,.agg({'列': '函数'}) 负责算,结果默认以分组键为索引;by 可以传一个字段也可以传列表(多字段分组 = 行索引两层);agg 的值是字典时不同列可配不同函数,是列表时该列同时算多个函数(列变两层);分组键为 NaN 的行会被丢掉。

7.4 分组结果整形

分组结果有个别扭的地方:分组键默认变成了行索引,不在列里。这带来两个连锁麻烦——① 想按分组键排序时,它不在 columns 里;② 想给结果改个中文列名时,索引那一层不好改。所以真实分析里,分组之后几乎总要“整形”一下。两种写法:

写法 A:groupby 时直接 as_index=False
g = df.groupby('商品名称',
        as_index=False).agg({'金额': 'sum'})
# 商品名称 一开始就是普通列
# 后面直接 sort_values('金额')
写法 B:先 groupby,再 reset_index()
g = df.groupby('商品名称').agg({'金额': 'sum'})
g = g.reset_index()
# reset_index() 把索引变成第 0 列
# 效果和写法 A 一样

两种写法结果一致,区别只在什么时候动手:一开始就知道要排序、要导出的,用 A(少一次调用);先算完再决定怎么用的,用 B。reset_index() 还能指定新列名和 drop 掉旧索引:reset_index(drop=True) 只重建 0~n-1 的整数索引、不把旧索引变列——7.4 后面和 c8 的 concat 都会用到它。

整形的三件事,一段代码看完:索引变回列 → 列名改成中文 → 按结果排序。注意改列名前先 reset_index(),否则列数和 columns 长度对不上会报错。

整形三步:reset_index → 改列名 → sort_values,以及有名聚合的写法
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

g = df.groupby('商品名称').agg({'数量': 'sum', '金额': 'sum'})
print('① 默认:商品名称 变成了索引')
print(g)
g2 = g.reset_index()
g2.columns = ['商品名称', '订购总数量', '订购总金额']
print('② 索引变回列、列名改成中文、按金额降序:')
print(g2.sort_values('订购总金额', ascending=False))
g3 = df.groupby('商品名称', as_index=False).agg(
    订购总数量=('数量', 'sum'), 订购总金额=('金额', 'sum'))
print('③ 有名聚合,一步到位:')
print(g3.head(3))
运行结果(实测)
① 默认:商品名称 变成了索引
        数量       金额
商品名称               
T恤    43.0  2592.52
休闲鞋   30.0  4860.00
卫衣    30.0  3795.00
围巾    37.0   799.20
运动服   31.0  5754.00
② 索引变回列、列名改成中文、按金额降序:
  商品名称  订购总数量    订购总金额
4  运动服   31.0  5754.00
1  休闲鞋   30.0  4860.00
2   卫衣   30.0  3795.00
0   T恤   43.0  2592.52
3   围巾   37.0   799.20
③ 有名聚合,一步到位:
  商品名称  订购总数量    订购总金额
0   T恤   43.0  2592.52
1  休闲鞋   30.0  4860.00
2   卫衣   30.0  3795.00

第 ③ 段的有名聚合值得记住:agg(新列名=('原列', '函数')) 直接在聚合时就把列名定好,既不用 reset_index 也不用改 columns,是 pandas 里最干净的写法。注意它的结果是一层列名,而不是 7.3 那种两层。

groupby + value_counts 不是一回事:df.groupby('商品名称')['订单编号'].count() 数的是“每组有多少条记录”(含重复的记录),而 df['商品名称'].value_counts() 数的是“每个取值出现几次”——两者在没有缺失值、没有重复值时结果相同,一旦有 NaN 或重复行就会对不上(本例 groupby 那边合计 11 条、会丢掉 NaN 行;value_counts 合计也是 11,但统计口径不同时不要混用)。另外 .count() 数非空、.size() 数行数,含缺失值时两者也不同。
✅ 本节小结:分组键默认变成索引,用 as_index=False 或 reset_index() 把它变回普通列;reset_index(drop=True) 只重建整数索引、不保留旧索引;改列名用 df.columns = [...](长度必须与列数一致);最干净的写法是有名聚合 agg(新列名=('原列','函数'))。

7.5 分区统计:pd.cut

分组统计的分组键是现成的类别列(商品名称、周次)。可现实里很多关键指标是连续值:金额、年龄、分数、时长。连续值没法直接分组——每个值都可能不一样。要分组,得先把它切成几档,这一步叫分区(也叫分箱、离散化),工具是 pd.cut()。

分箱的思路很朴素:给一串区间边界,pandas 判断每个数落在哪个区间,然后给一个标签。这样“金额”就变成了“金额等级”,可以像类别列一样 value_counts() 数分布。【例 8-35】就是:先按日期汇总每日总金额,再按指定间距划分等级,最后统计各等级天数。

参数含义本页取值
x要分区的数据(一列数值)daily['总金额']
bins分区数目,或表示分区间隔的序列[0, 400, 1000, 3200, 6000](4 档)或 bins=4(自动等宽)
right区间右边是否闭合。默认 True(左开右闭)本页统一 right=False(左闭右开)
labels各区间对应的标签['L1','L2','L3','L4']
为什么本页统一 right=False(左闭右开):区间 [0, 400) 包含 0、不包含 400;下一个是 [400, 1000)。这样每个数只属于一个区间、不会重复也不会漏,而且 0 元这一天能落进第一档。如果按默认的 right=True(左开右闭)写 [0, 400],那么 0 元会被排除在区间外,cut 直接给 NaN——这是分箱最常见的坑。
pd.cut:把连续的每日总金额切成 4 档,再数每档有几天 ① 先按日期汇总出每日总金额 订单日期 每日总金额 等级 02-01 3071.52 L3 02-05 5205.20 L4 02-08 3795.00 L4 02-12 329.00 L1 02-15 540.00 L2 02-20 4860.00 L4 02-25 0.00 L1 02-28 540.00 L2 ② 在数轴上按 4 个区间切(right=False:左闭右开) L1 L2 L3 L4 0 400 1000 3200 6000 0 329 540×2 3071.52 3795 4860 5205.20 L1 = [0, 400)  L2 = [400, 1000)  L3 = [1000, 3200)  L4 = [3200, 6000) L1 = 2 天 L2 = 2 天 L3 = 1 天 L4 = 3 天 right=False → 左闭右开 [左, 右):0 元这一天被算进 L1;若用默认 right=True(左开右闭),0 元会被排除成 NaN 切完档,pd.cut 的结果是一列“类别”,可以直接 value_counts().sort_index() 按档位顺序数出 2 / 2 / 1 / 3
图 8-17 pd.cut 的分箱数轴:8 个每日总金额按 [0,400)、[400,1000)、[1000,3200)、[3200,6000) 四个左闭右开区间落档,数出各档天数

第一段用指定的分区间距(目录里的“指定 bins”),这是业务里最常用的方式——档位边界由业务含义决定(比如“小单 / 中单 / 大单 / 超大单”),不是让 pandas 自己算。切完用 value_counts().sort_index() 统计各档天数,sort_index() 保证按 L1→L4 的顺序输出,而不是按次数多少。

例 8-35(上):按指定间距划分金额等级,统计各等级数量(right=False)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

daily = df.groupby('订单日期').agg({'金额': 'sum'})
daily.columns = ['总金额']
bins = [0, 400, 1000, 3200, 6000]              # 指定分区间距
labels = ['L1', 'L2', 'L3', 'L4']               # 四个等级标签
daily['等级'] = pd.cut(daily['总金额'], bins=bins, labels=labels, right=False)
print(daily)
print('各等级的订单天数:')
print(daily['等级'].value_counts().sort_index())
运行结果(实测)
                总金额  等级
订单日期                   
2021-02-01  3071.52  L3
2021-02-05  5205.20  L4
2021-02-08  3795.00  L4
2021-02-12   329.00  L1
2021-02-15   540.00  L2
2021-02-20  4860.00  L4
2021-02-25     0.00  L1
2021-02-28   540.00  L2
各等级的订单天数:
等级
L1    2
L2    2
L3    1
L4    3
Name: count, dtype: int64

第二段把 bins 从“一串边界”换成一个整数:pandas 自动把最小值到最大值按等宽切成 4 段。这就是“自动分级”。自动分级的优点是省事,缺点是边界不好看(会是 2602.6、3903.9 这种数),而且极端值会把区间拉得很开——所以正式报告里通常还是人工指定 bins。还有一个副作用看得见:这份精简数据在 540 元和 3071 元之间没有值,等宽切出来的 中 这一档是 0 天——空档不是错,它只是在告诉你“这段区间真的没人”。

例 8-35(下):bins 传整数 = 自动等宽分级,labels 自己命名
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

daily = df.groupby('订单日期').agg({'金额': 'sum'})
daily.columns = ['总金额']
daily['等级'] = pd.cut(daily['总金额'], bins=4, right=False,
                      labels=['低', '中', '中高', '高'])
print('自动分级的边界:', daily['等级'].cat.categories.tolist())
print(daily[['总金额', '等级']])
print('各等级天数:')
print(daily['等级'].value_counts().sort_index())
运行结果(实测)
自动分级的边界: ['低', '中', '中高', '高']
                总金额  等级
订单日期                   
2021-02-01  3071.52  中高
2021-02-05  5205.20   高
2021-02-08  3795.00  中高
2021-02-12   329.00   低
2021-02-15   540.00   低
2021-02-20  4860.00   高
2021-02-25     0.00   低
2021-02-28   540.00   低
各等级天数:
等级
低     4
中     0
中高    2
高     2
Name: count, dtype: int64
两个坑:① 区间没盖住的值会变成 NaN——如果上界只写 5000,而某天总金额是 5205.20,这一天就会落到所有区间之外,cut 给 NaN,统计时被 value_counts() 悄悄丢掉;② 不要用默认的 right=True 还从 0 开始切——[0, 400] 是左开右闭,0 元不在区间里,也会变 NaN。最稳的写法是像本页这样:bins 的首尾把 min 和 max 都包住,并且统一 right=False。
🎬 动态演示:pd.cut 分箱 —— 连续金额落进 3 个区间
✅ 本节小结:pd.cut(x, bins, right, labels) 把连续值切成离散档——bins 传序列是指定间距(推荐),传整数是自动等宽;本页统一 right=False(左闭右开),保证每个值只落一档、0 也能入档;切完用 value_counts().sort_index() 按档位顺序数分布;bins 没包住的值会变 NaN。

7.6 重采样:resample(选学)

分组是“按某个字段的值分组”,重采样是它的时间特化版:按时间周期把行重新分到一个个时间段里,再对每段聚合。它和 groupby 的关系可以这么理解——resample ≈ 按时间区间 groupby。区别在于:groupby 按日期分组只能得到“有订单的那 8 天”,resample 能按固定周期(每 7 天、每月)切,哪怕某段没数据也会给你一行。

语法是 resample(rule, axis, closed, label, on):rule 是周期('7D' 表示每 7 天、'ME' 表示每月末);on 指定用哪一列当时间轴(这列必须是 datetime 类型,本例是 订单日期);closed 和 label 控制区间闭合端和结果索引取区间左端还是右端。写法和 groupby 几乎一样:先 resample 再 .agg()。

例 8-36:按 7 天一个周期重采样,统计每个周期的总数量与总金额
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

week = df.resample('7D', on='订单日期').agg({'数量': 'sum', '金额': 'sum'})
print('每 7 天一个周期:')
print(week)
print('周期起始日(就是结果的索引):', week.index.tolist())
运行结果(实测)
每 7 天一个周期:
              数量       金额
订单日期                     
2021-02-01  81.0  8276.72
2021-02-08  35.0  4124.00
2021-02-15  30.0  5400.00
2021-02-22  25.0   540.00
周期起始日(就是结果的索引): [Timestamp('2021-02-01 00:00:00'), Timestamp('2021-02-08 00:00:00'), Timestamp('2021-02-15 00:00:00'), Timestamp('2021-02-22 00:00:00')]

结果只有 4 行,是因为 2021-02-01 到 2021-02-28 这 28 天正好切成 4 个 7 天周期:02-01~02-07、02-08~02-14、02-15~02-21、02-22~02-28。索引是每个周期的起始日(label 默认取左端)。这里还能看出重采样和 pd.cut、groupby 周次的差别:groupby 周次用的是“自然周(ISO 周)”,resample('7D') 用的是“从第一天起每 7 天”,两者重合纯属这份数据凑巧。

pandas 3 的坑:freq='M' 已经删除了。旧教材和课件里常见的 resample('M')、pd.date_range(freq='M') 在 pandas 3 里会直接抛 ValueError: Invalid frequency: M ... Please use 'ME' instead。月末改成 'ME'、月初用 'MS',其他的 'D'(天)、'W'(周)、'h'(小时)、'7D'(7 天)都不变。下面这段故意不写对,让你看看报错长什么样——考试和作业里遇到 freq='M' 的旧代码,先把它改成 'ME'。
resample('M') 在 pandas 3 里报错:捕获信息看提示,再改成 'ME'
import pandas as pd

s = pd.Series([1, 2, 3],
              index=pd.date_range('2021-02-01', periods=3, freq='D'))
try:
    s.resample('M').sum()                 # 旧教材写法,pandas 3 已删除
except ValueError as e:
    print('旧写法报错:')
    print(e)
print('改成 ME(月末)之后:')
print(s.resample('ME').sum())
运行结果(实测)
旧写法报错:
Invalid frequency: M. Failed to parse with error message: ValueError("'M' is no longer supported for offsets. Please use 'ME' instead.")
改成 ME(月末)之后:
2021-02-28    6
Freq: ME, dtype: int64

把这个坑记住,比记住语法更重要:报错信息本身已经给了答案——它明说 “Please use 'ME' instead”。pandas 3 把时间频率的别名统一了一遍,'M'(月末)和 'MS'(月初)、'Q'→'QE'、'Y'→'YE' 都改了名。写代码时遇到,按提示改就对了。

✅ 本节小结:resample(rule, on, closed, label) 是按时间周期分组,写法和 groupby 一样(先 resample 再 agg);'7D' 表示每 7 天、索引默认取周期起始日;pandas 3 删除了 freq='M',月末必须写 'ME'、月初写 'MS'。

7.7 数据透视表:pivot_table

前面所有统计都只能“压一个维度”:要么按商品压(一个维度),要么按周压(另一个维度)。但真实报表经常要两个维度交叉看——“第 5 周、运动服、卖了多少钱”这样的格子。pivot_table() 就是干这个的:把长表按行、列、值三个角色重新摆开,每个格子是“行条件 + 列条件”筛出来的那一小组数据的聚合值。

参数在表里扮演什么角色例 8-37 的取值
index行标签(每一行代表它的一组取值的组合)'周次' → 行是 5、6、7、8
columns列标签(每一列代表它的一组取值的组合)'商品名称' → 列是 5 种商品
values格子里的数来自哪一列'金额'
aggfunc同一格有多条记录时,怎么压成一个数。默认 'mean''sum'
fill_value没有数据(NaN)的格子填什么例 8-38 用 0
margins / margins_name是否加汇总行和汇总列 / 汇总行列的标签(默认 'All')True / '总计'

用之前有一个硬要求:数据框必须是长表——每一列都是不同属性的数据项,一行是一条记录。我们的订单表正好是长表:周次 是属性、商品名称 是属性、金额 是度量。如果把金额按商品拆成好几列(宽表),反而没法透视,得先 melt 回长表。

pivot_table:长表 → 行 × 列 × 值 的矩阵(例 8-37 原样) ① 长表(值要按两个字段交叉汇总) 周次 商品名称 金额 5 T恤 2263.52 5 围巾 259.20 5 运动服 5754.00 6 T恤 329.00 6 卫衣 3795.00 7 休闲鞋 4860.00 8 围巾 540.00 8 运动服 0.00 一行一个(周, 商品)组合,共 8 行(例 8-37 原样) ② 三个角色各就各位 index='周次' 摆成行标签(4 行) columns='商品名称' 摆成列标签(5 列) values='金额' 格子里的数取自这一列 aggfunc='sum' 不写默认 'mean'(求平均) margins=True → 自动补 All 行 / All 列 ③ 透视结果(金额 sum) 周次 T恤 休闲鞋 卫衣 围巾 运动服 5 2263.52 NaN NaN 259.20 5754.00 6 329.00 NaN 3795.00 NaN NaN 7 NaN 4860.00 NaN NaN NaN 8 NaN NaN NaN 540.00 0.00 All 2592.52 4860.00 3795.00 799.20 5754.00 All 行 = 各商品一周合计 All 列 = 各周合计(图中未画全) 行放谁(index)、列放谁(columns)、格子里的数怎么算(values + aggfunc)—— 三件事说清,表就出来了 行数 = index 的 nunique,列数 = columns 的 nunique;缺格子显示 NaN,可以用 fill_value=0 补 margins=True 会在最后补一列 All 和一列 All 行:All 列 = 这一行跨所有商品的和,All 行 = 这一列跨所有周的和 margins_name 可以改名,例 8-38 用了 margins_name='总计'
图 8-18 数据透视表的三要素:index 决定行、columns 决定列、values + aggfunc 决定格子里的数,margins 补 All 汇总行列

【例 8-37】是标准的透视:行放周次、列放商品、值放金额、聚合用 sum,再加 margins=True 看总计。注意结果里出现不少 NaN——那不是缺失值,而是“这一周这个商品根本没卖出”,也就是长表里缺的(周, 商品)组合,透视表把它们补成了矩阵。

例 8-37:每周各商品的订购总金额,加 margins 汇总行列
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
df['周次'] = df['订单日期'].dt.isocalendar().week.astype(int)

print('df 的金额合计:', df['金额'].sum())
pv = df.pivot_table(values='金额', index='周次', columns='商品名称',
                    aggfunc='sum', margins=True)
print(pv)
运行结果(实测)
df 的金额合计: 18340.72
商品名称       T恤     休闲鞋      卫衣     围巾     运动服       All
周次                                                    
5     2263.52     NaN     NaN  259.2  5754.0   8276.72
6      329.00     NaN  3795.0    NaN     NaN   4124.00
7         NaN  4860.0     NaN    NaN     NaN   4860.00
8         NaN     NaN     NaN  540.0     0.0    540.00
All   2592.52  4860.0  3795.0  799.2  5754.0  17800.72

第二段是【例 8-38】:把 values 换成 数量、index 换成 订单日期(每天 × 每种商品),并且 fill_value=0 把空格子填 0、margins_name='总计' 给汇总行列改名。fill_value 在实际报表里几乎是必选项——空格子显示 0 比显示 NaN 更适合直接给人看。

例 8-38:每天各商品的订购数量,fill_value=0,汇总行列名改为“总计”
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

pv2 = df.pivot_table(values='数量', index='订单日期', columns='商品名称',
                     aggfunc='sum', fill_value=0,
                     margins=True, margins_name='总计')
print(pv2)
运行结果(实测)
商品名称                   T恤   休闲鞋    卫衣    围巾   运动服     总计
订单日期                                                    
2021-02-01 00:00:00  24.0   0.0   0.0  12.0   7.0   43.0
2021-02-05 00:00:00  14.0   0.0   0.0   0.0  24.0   38.0
2021-02-08 00:00:00   0.0   0.0  30.0   0.0   0.0   30.0
2021-02-12 00:00:00   5.0   0.0   0.0   0.0   0.0    5.0
2021-02-20 00:00:00   0.0  30.0   0.0   0.0   0.0   30.0
2021-02-25 00:00:00   0.0   0.0   0.0   0.0   0.0    0.0
2021-02-28 00:00:00   0.0   0.0   0.0  25.0   0.0   25.0
总计                   43.0  30.0  30.0  37.0  31.0  171.0
阅读这两张透视表时的三个细节:① 例 8-37 的 All 列合计是 17800.72,比 df['金额'].sum() 的 18340.72 少 540——透视表把 商品名称 为 NaN 的那条记录丢掉了,和 7.3 节 groupby 少的是同一笔;② 不写 aggfunc 时默认是 'mean'(求平均),很多人以为默认是 sum,结果算出一堆小数自己都不知道错在哪;③ 例 8-38 里 2021-02-25 这一行全是 0,因为那天只有一条“数量为 0”的异常订单(订单 302011)——透视表如实反映了它,这不代表那天没卖东西,而是数据本身有问题,这正是 8.4 节要清洗异常值的理由。
🎬 动态演示:数据透视表 —— 行 × 列 × 值 怎么摆
✅ 本节小结:pivot_table(values, index, columns, aggfunc, fill_value, margins, margins_name) 把长表摆成行 × 列 × 值的矩阵:index 决定行、columns 决定列、values + aggfunc 决定格子里的数,aggfunc 默认 'mean';margins=True 自动补 All 汇总行列、margins_name 改名、fill_value=0 补空格;透视表要求数据是长表,分组键为 NaN 的行会被丢弃。
八

合并连接、综合案例与 AI 渗透 本章重点

concat 合并(axis=0 / axis=1)· merge 连接与四种 how · 连接校验 · 订单数据综合分析流水线 · Pandas 在 AI 数据管线中的位置 · 本章知识地图

这是本章的最后一块拼图。前面七节所有的分析都建立在“一张表”上:读进来、洗干净、查出来、分组算、透视看。可真实项目里数据常常分散在多个文件、多张表里——一月的订单在一个文件、二月的在另一个;订单表里只有商品名称,进价、产地、库存在另一张商品表里。先拼起来,才能分析下去,这个动作就是“合并与连接”。

这一节先用 concat 和 merge 把“拼表”的两类动作讲清,再讲一个很多人忽略的环节——连接校验(拼完行数对不对?),然后把 8.1—8.8 全部串成一条综合分析流水线,最后抬头看 pandas 在整个 AI 数据管线里站在哪个位置,给出一张本章知识地图。

本模块主线:合并(concat:竖向摞行 / 横向拼列)→ 连接(merge:按公共键匹配,四种 how 决定保留谁)→ 校验(行数、重复键、indicator)→ 综合案例(导入 → 清洗 → 查询 → 分组 → 透视 → 导出)→ AI 渗透(DataFrame → 特征矩阵 → Tensor)→ 知识地图。

8.1 合并:concat

合并(concatenate,简称 concat)是“把两张表的形状拼在一起”,它不需要两张表有公共的键,只要求尺寸对得上。方向由 axis 决定,两个方向对应两种完全不同的业务场景:

axis=0:竖向摞行(默认)

  • 上面一张、下面一张,记录变多
  • 列名必须一致(不一致的列会补 NaN)
  • 典型场景:把 1 月、2 月的订单文件合在一起
  • 索引会重复:两份表都从 0 开始,摞起来就有两个 0

axis=1:横向拼列

  • 左边一张、右边一张,字段变多
  • 按行索引对齐,行数不变
  • 典型场景:把“金额信息”和“商品明细”拼成一张宽表
  • 索引对不上的地方会补 NaN——拼之前先 reset_index 最稳

语法是 pd.concat(objs, axis, ignore_index):objs 是一个列表(要拼的表放进去,不是一个个当参数传);axis 默认 0;ignore_index 默认 False,设为 True 会丢掉原来的索引、重排成 0~n-1。这个参数【例 8-39】就用了:把两份订单文件(160 行 + 172 行)摞成 332 行,索引重排后再导出 Excel。

例 8-39:竖向摞行 axis=0,ignore_index 决定索引重不重排
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

df_1 = df.iloc[:6].reset_index(drop=True)    # 模拟第一份文件:6 行,索引从 0 开始
df_2 = df.iloc[6:].reset_index(drop=True)    # 模拟第二份文件:6 行,索引也从 0 开始
print('df_1:', df_1.shape, '  df_2:', df_2.shape)
both = pd.concat([df_1, df_2])
print('直接 concat:', both.shape, ' 索引:', both.index.tolist())
both2 = pd.concat([df_1, df_2], ignore_index=True)
print('ignore_index=True:', both2.shape, ' 索引:', both2.index.tolist())
运行结果(实测)
df_1: (6, 7)   df_2: (6, 7)
直接 concat: (12, 7)  索引: [0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
ignore_index=True: (12, 7)  索引: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

直接 concat 的结果索引是 [0,1,2,3,4,5, 0,1,2,3,4,5]——两份表各自从 0 开始,摞起来就有两个 0,这叫重复索引。重复索引不影响“有多少行”(shape 仍是 12 行),但会影响按索引取值(df.loc[0] 会一次拿到两行),导出 Excel 时也会看到索引列跳来跳去。所以合并完的数据几乎总要 ignore_index=True,让索引重新变成连续的 0~11。

横向拼列(axis=1)的用途是用“加字段”代替“加记录”:订单表里已经有编号和金额,另一份表里有商品名和数量,两张表的行数是同一批订单,按索引对齐拼成一宽一窄的四列。注意它的对齐依据是行索引,不是行号顺序——如果两份表索引不同,pandas 会按标签对齐、对不上的补 NaN,这时候先 reset_index(drop=True) 再拼最稳。

axis=1 横向拼列:4 行 2 列 + 4 行 2 列 → 4 行 4 列
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

part_a = df[['订单编号', '金额']].head(4).reset_index(drop=True)
part_b = df[['商品名称', '数量']].head(4).reset_index(drop=True)
print('part_a:', part_a.shape, '  part_b:', part_b.shape)
wide = pd.concat([part_a, part_b], axis=1)
print('axis=1 之后:', wide.shape)
print(wide)
print('axis=0 竖向摞(同样的两张表):', pd.concat([part_a, part_a]).shape)
运行结果(实测)
part_a: (4, 2)   part_b: (4, 2)
axis=1 之后: (4, 4)
     订单编号       金额 商品名称    数量
0  302001   259.20   围巾  12.0
1  302002  1470.00  运动服   7.0
2  302003  1342.32   T恤  24.0
3  302004  4284.00  运动服  24.0
axis=0 竖向摞(同样的两张表): (8, 2)
concat 的两个方向:axis=0 摞行(记录变多),axis=1 拼列(字段变多) ① axis=0:竖向摞行 —— 列名必须一致,行数相加 df_1 6 行 × 7 列 索引 0~5 df_2 6 行 × 7 列 索引 0~5 concat pd.concat([df_1, df_2]) 12 行 × 7 列 索引 0~5, 0~5(重复) 列名一致才能摞; 不一致的列补 NaN 行序按列表里表的顺序 + 参数 ignore_index=True 12 行 × 7 列 索引 0~11 连续 原索引被丢掉、重新编号 导出 Excel / 后续 loc 更干净 例 8-39 用的就是这个 ② axis=1:横向拼列 —— 按行索引对齐,行数不变 df_a 4 行 × 2 列 订单编号 / 金额 索引 0~3 + df_b 4 行 × 2 列 商品名称 / 数量 索引 0~3 = pd.concat([df_a, df_b], axis=1) 4 行 × 4 列 行数不变,字段从 2 个变 4 个 订单编号 金额 商品名称 数量 拼之前先 reset_index(drop=True) 否则索引对不上会错行、 对不上的位置补 NaN concat 只负责“堆”,不检查记录是否重复 —— 摞进去的重复行还是重复行,要用 drop_duplicates() 另外去重 objs 是“列表”:pd.concat([df_1, df_2]),不是 pd.concat(df_1, df_2)
图 8-19 concat 的两个方向:axis=0 把两份表上下摞起来(记录变多、索引会重复,用 ignore_index 重排),axis=1 把两张表左右拼成宽表(行数不变、按行索引对齐)
🎬 动态演示:concat 纵向与横向
✅ 本节小结:pd.concat(objs, axis, ignore_index) 把多张表拼在一起,不需要公共键:axis=0(默认)竖向摞行、记录变多、索引会重复(用 ignore_index=True 重排);axis=1 横向拼列、字段变多、按行索引对齐(先 reset_index(drop=True) 更稳)。objs 是列表,写成 pd.concat([df_1, df_2])。

8.2 连接:merge 与四种 how

合并是“形状对齐”,连接(merge)是“内容对上”:两张表各有一列公共键(本例是 商品名称),pandas 按这个键的值把两边的行匹配起来,拼成一行。它相当于 Excel 的 VLOOKUP,但比 VLOOKUP 强在四种匹配策略和多对多处理上。

参数含义本例取值
left / right要连接的两个数据框df_sum(订单汇总)、goods(商品表)
on连接字段;不写则自动找同名字段,没有同名字段会报错'商品名称'
how保留哪些记录:inner / left / right / outer,默认 'inner'见下
left_on / right_on两边字段名不同但含义相同时,分别指定本例两边都叫商品名称,用 on 就够
suffixes两边有同名的非键字段时,给它们加的后缀默认 ('_x', '_y')

四种 how 是全节最该记牢的东西,它决定“哪边的键一定保留”:

merge 的四种 how:谁的行一定留下来? 订单汇总 5 个商品 T恤 / 休闲鞋 / 卫衣 围巾 / 运动服 5 两边都有 商品表 goods 7 个商品 运动鞋 · 太阳帽 (订单里没有) 左表 5 个键 ∩ 右表 7 个键 how 决定保留哪个区域 how='inner'(默认)→ 5 行 只保留两边都有的键:交集(中间那块) 运动鞋、太阳帽被丢掉;订单里 5 种商品全部匹配上,所以 5 行 how='left' → 5 行 左表的键全留,右表没有的补 NaN 本例左表的 5 个键右表都有,所以也是 5 行、没有 NaN how='right' → 7 行 右表的键全留,左表没有的补 NaN 运动鞋、太阳帽留下,订购总数量是 NaN how='outer' → 7 行 两边的键全留:并集(两个圆加起来) 本例右表多出 2 种商品,所以 5 + 2 = 7 行;left ∪ right 行数口诀: inner 交集 · outer 并集 left 保左 · right 保右
图 8-20 merge 四种 how 的键集合:inner 只留两边都有的键(5 行),left 保左表、right 保右表(7 行),outer 取并集(7 行)

【例 8-40】的场景很典型:订单表里只有商品名称,想知道每种商品的订购数量和它的进价、产地、库存,就必须连商品表。第一步先用 7.3 节的分组统计出“每种商品的订购总数量”,第二步再 merge。注意 reset_index() 那一步不能省——groupby 之后商品名称是索引,不是列,没法当连接键。

例 8-40:订单汇总 ⟕ 商品表,一次看到订购信息和商品详情
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
goods = pd.read_csv(StringIO("""商品名称,进价,产地,库存,销售价
围巾,15,江苏,50,21.6
运动服,130,北京,20,210.0
T恤,38,上海,125,65.8
卫衣,90,广东,62,126.5
休闲鞋,110,广东,210,162.0
运动鞋,152,福建,48,237.0
太阳帽,11,浙江,10,22.0
"""))
df_sum = df.groupby('商品名称', as_index=False).agg({'数量': 'sum'})
df_sum.columns = ['商品名称', '订购总数量']
df_sum['订购总数量'] = df_sum['订购总数量'].astype(int)
print('订单汇总 df_sum:')
print(df_sum)
print('连接商品表(默认 how=inner):')
print(pd.merge(df_sum, goods, on='商品名称'))
运行结果(实测)
订单汇总 df_sum:
  商品名称  订购总数量
0   T恤     43
1  休闲鞋     30
2   卫衣     30
3   围巾     37
4  运动服     31
连接商品表(默认 how=inner):
  商品名称  订购总数量   进价  产地   库存    销售价
0   T恤     43   38  上海  125   65.8
1  休闲鞋     30  110  广东  210  162.0
2   卫衣     30   90  广东   62  126.5
3   围巾     37   15  江苏   50   21.6
4  运动服     31  130  北京   20  210.0

两句关于 dtype 的话:订购总数量 先 astype(int) 再打印,是因为原表 数量 列含缺失值(float),求和结果也是 float,会显示成 43.0;转成 int 更符合“件数”的业务含义。另外商品表有 7 种商品,而 merge 结果只有 5 行——因为默认 how='inner' 只保留两边都有的键,运动鞋 和 太阳帽 在订单里没出现过,被 inner 丢掉了。

想看四种 how 的差别,最直接的写法是循环一遍、每种种都打印行数。本例的结论很好记:inner 5 行、left 5 行、right 7 行、outer 7 行。

四种 how 的行数对比:inner 5 / left 5 / right 7 / outer 7
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
goods = pd.read_csv(StringIO("""商品名称,进价,产地,库存,销售价
围巾,15,江苏,50,21.6
运动服,130,北京,20,210.0
T恤,38,上海,125,65.8
卫衣,90,广东,62,126.5
休闲鞋,110,广东,210,162.0
运动鞋,152,福建,48,237.0
太阳帽,11,浙江,10,22.0
"""))
df_sum = df.groupby('商品名称', as_index=False).agg({'数量': 'sum'})
df_sum.columns = ['商品名称', '订购总数量']

for how in ['inner', 'left', 'right', 'outer']:
    m = pd.merge(df_sum, goods, on='商品名称', how=how)
    print(f'how={how:<6} 行数 {m.shape[0]}  列数 {m.shape[1]}')
print('outer 的结果(右表多出的两种商品,订购总数量是 NaN):')
print(pd.merge(df_sum, goods, on='商品名称', how='outer'))
运行结果(实测)
how=inner  行数 5  列数 6
how=left   行数 5  列数 6
how=right  行数 7  列数 6
how=outer  行数 7  列数 6
outer 的结果(右表多出的两种商品,订购总数量是 NaN):
  商品名称  订购总数量   进价  产地   库存    销售价
0   T恤   43.0   38  上海  125   65.8
1  休闲鞋   30.0  110  广东  210  162.0
2   卫衣   30.0   90  广东   62  126.5
3   围巾   37.0   15  江苏   50   21.6
4  太阳帽    NaN   11  浙江   10   22.0
5  运动服   31.0  130  北京   20  210.0
6  运动鞋    NaN  152  福建   48  237.0

如果两边有同名的非键字段(比如两张表都叫 库存,但一张是本月、一张是上月),merge 不会报错,而是自动给它们加后缀 _x / _y——这种名字根本看不出含义。用 suffixes=('_本月', '_上月') 自己起名,可读性高得多。下面用两张小表演示。

suffixes:两边同名字段时,用后缀区分(默认是 _x / _y)
import pandas as pd

this_month = pd.DataFrame({'商品名称': ['围巾', 'T恤'],
                           '库存': [50, 125]})
last_month = pd.DataFrame({'商品名称': ['围巾', 'T恤'],
                           '库存': [48, 120]})
print('默认后缀 _x / _y:')
print(pd.merge(this_month, last_month, on='商品名称'))
print('自定义后缀:')
print(pd.merge(this_month, last_month, on='商品名称',
               suffixes=('_本月', '_上月')))
运行结果(实测)
默认后缀 _x / _y:
  商品名称  库存_x  库存_y
0   围巾    50    48
1   T恤   125   120
自定义后缀:
  商品名称  库存_本月  库存_上月
0   围巾     50     48
1   T恤    125    120
🎬 动态演示:merge 的四种 how
✅ 本节小结:pd.merge(left, right, how, on, left_on, right_on, suffixes) 按公共键把两张表连接起来:how='inner'(默认)只留两边都有的键、'left' 保左表、'right' 保右表、'outer' 取并集;同名字段用 suffixes 加后缀区分(默认 _x / _y);groupby 之后的表要 reset_index() 才能当连接键。

8.3 连接校验

merge 是本章最容易悄悄出错的一步:它不报错,但行数可能已经不是你以为的那个数。原因只有一个——键的重复。连接前先想清楚两边是“一对一”还是“一对多”:

关系例子连接后行数风险
一对一(1:1)订单汇总(每种商品 1 行)⟕ 商品表(每种商品 1 行)= 左表行数 = 右表行数安全,例 8-40 就是这种
一对多(1:N)一张订单 ⟕ 它的多条明细= 每个键的右表行数累加行数变多,属正常“展开”
多对多(N:N)两边同一个键都有多行= 左行数 × 右行数(笛卡尔积)最容易误伤:3 行 × 2 行 = 6 行
indicator=True:给每一行标上来源(both / left_only / right_only)
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])
goods = pd.read_csv(StringIO("""商品名称,进价,产地,库存,销售价
围巾,15,江苏,50,21.6
运动服,130,北京,20,210.0
T恤,38,上海,125,65.8
卫衣,90,广东,62,126.5
休闲鞋,110,广东,210,162.0
运动鞋,152,福建,48,237.0
太阳帽,11,浙江,10,22.0
"""))
df_sum = df.groupby('商品名称', as_index=False).agg({'数量': 'sum'})
df_sum.columns = ['商品名称', '订购总数量']
print('连接前:左表', df_sum.shape, ' 右表', goods.shape)
m = pd.merge(df_sum, goods, on='商品名称', how='outer', indicator=True)
print(m[['商品名称', '订购总数量', '库存', '_merge']])
print('_merge 计数:')
print(m['_merge'].value_counts())
运行结果(实测)
连接前:左表 (5, 2)  右表 (7, 5)
  商品名称  订购总数量   库存      _merge
0   T恤   43.0  125        both
1  休闲鞋   30.0  210        both
2   卫衣   30.0   62        both
3   围巾   37.0   50        both
4  太阳帽    NaN   10  right_only
5  运动服   31.0   20        both
6  运动鞋    NaN   48  right_only
_merge 计数:
_merge
both          5
right_only    2
left_only     0
Name: count, dtype: int64

indicator=True 会多出一列 _merge:both 表示两边都匹配上、left_only 只在左表、right_only 只在右表。做数据核对时这一列特别有用——“连接后行数对不对”不如“每一个键都去哪了”说得清楚。本例 both 5 个、right_only 2 个,说明订单里的商品全部在商品表中找到,而商品表有两种商品没卖过。

第二种校验手段是 validate 参数:告诉 pandas“我期望这是一对一”,如果实际不是,它就直接抛 MergeError。四种取值 'one_to_one' / 'one_to_many' / 'many_to_one' / 'many_to_many'。下面先看一个“多对多把行数撑大”的例子——左表 3 行、右表 3 行,连接后却是 4 行,多出来的那一行就是这么来的。

重复键让行数膨胀:3 行 + 3 行 → 4 行;validate 直接拦下
import pandas as pd

left = pd.DataFrame({'商品名称': ['围巾', 'T恤', '卫衣'],
                     '数量': [12, 24, 15]})
right = pd.DataFrame({'商品名称': ['围巾', '围巾', 'T恤'],
                      '产地': ['江苏', '浙江', '上海']})
m = pd.merge(left, right, on='商品名称', how='left')
print('左表 3 行、右表 3 行,连接后:', m.shape)
print('多出来的行,是右表里“围巾”有两条造成的:')
print(m)
try:
    pd.merge(left, right, on='商品名称', validate='one_to_one')
except ValueError as e:
    print('validate=one_to_one 直接把问题拦下:')
    print(type(e).__name__, ':', e)
运行结果(实测)
左表 3 行、右表 3 行,连接后: (4, 3)
多出来的行,是右表里“围巾”有两条造成的:
  商品名称  数量   产地
0   围巾  12   江苏
1   围巾  12   浙江
2   T恤  24   上海
3   卫衣  15  NaN
validate=one_to_one 直接把问题拦下:
MergeError : Merge keys are not unique in right dataset; not a one-to-one merge
Duplicates in right:
 商品名称
  围巾 ...
连接后的三个必查项:① 行数——inner/left 连接后的行数不该大于左表行数(除非右表键重复);② 键的重复——连接前用 df.duplicated(subset=['键']) 或 df['键'].is_unique 查一下;③ NaN 的来源——outer/left/right 连接补出来的 NaN 是“没匹配上”,不是“原数据缺失”,别混为一谈。养成习惯:连接前记下行数,连接后对一次。
✅ 本节小结:merge 不报错不代表没出错,重复键会让行数膨胀(多对多时是笛卡尔积);用 indicator=True 看每行来源(both / left_only / right_only),用 validate='one_to_one' 让 pandas 帮你断言关系;连接前后核对行数、检查键是否唯一,是数据核对的基本功。

8.4 综合案例:订单数据全流程

到这里,本章的积木已经全部给齐了。最后这一步是把它们按真实项目的顺序串起来——不是学新 API,而是练“一条流水线走到底”。课件最后一页的“Pandas 数据处理流程”就是这个顺序:

① 导入
→
② 清洗
→
③ 查询
→
④ 分组
→
⑤ 透视
→
⑥ 导出

顺序不能乱,原因很实在:查询、分组、透视都在数行,如果前面没清洗,后面算出来的每个数都带着“缺失值那一行被丢掉”“重复订单被算两次”“异常订单把均值拉高”的暗伤,而且不会报错。流水线的每一站都要打印一次 shape——这是数据处理的“安全带”:行数对不上,立刻回头找。

综合案例的流水线:六步走完,每步都打印 shape ① 导入 read_csv( parse_dates=…) (12, 7) 12 条原始记录 ② 清洗 dropna drop_duplicates 条件删异常 (8, 7) -1 缺失 -1 重复 -2 异常 ③ 查询 金额 >= 1500 布尔索引 2 行 4284 / 1897.5 两笔大单 ④ 分组 groupby agg 有名聚合 4 行 清洗后只剩 4 种商品 ⑤ 透视 pivot_table fill_value=0 (4, 5) 3 周 + 合计行 ⑥ 导出 to_excel( sheet_name=…) 回读 (4, 5) 导出后再读回来核对 清洗让 12 行变 8 行:去缺失 12→11、去重复 11→10、去异常(单价>150 且 数量>25)10→9、去无意义(数量<=0)9→8 每一步都打印 shape,行数对不上就立刻回头找 —— 这是流水线里最省钱的习惯 全流程用的都是本章学过的东西:read_csv → dropna / drop_duplicates / 布尔索引 → groupby().agg() → pivot_table() → to_excel() 没有一行是新 API —— 综合案例考的不是“会不会写”,而是“知不知道该按什么顺序写”
图 8-21 订单数据综合分析流水线:导入 (12,7) → 清洗 (8,7) → 查询 2 行 → 分组 4 行 → 透视 (4,5) → 导出 xlsx 并回读核对

第一段:导入 → 清洗 → 导出清洗结果

这一段用 tempfile.TemporaryDirectory() 造一个临时目录:先把 CSV 文本写进去,再“从文件导入”——这样既演示了真实的“导入”动作,又不会在仓库里留下文件。清洗按 8.4 节的四个动作依次做:去缺失 → 去重复 → 删异常 → 删无意义,每一步都打印 shape 看行数怎么变。

综合案例(1/3):导入 12 行 → 四步清洗到 8 行 → 导出 csv 并回读
import os, tempfile
import pandas as pd

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
with tempfile.TemporaryDirectory() as td:
    src = os.path.join(td, '订单_原始.csv')
    with open(src, 'w', encoding='utf-8', newline='') as f:
        f.write(csv)                                   # 先落盘,模拟“从文件导入”
    df = pd.read_csv(src, parse_dates=['订单日期'])
    print('① 导入:', df.shape)
    df = df.dropna(subset=['商品名称', '单价', '数量'])
    print('② 去缺失:', df.shape)
    df = df.drop_duplicates()
    print('③ 去重复:', df.shape)
    df = df[~((df['单价'] > 150) & (df['数量'] > 25))]
    print('④ 去异常:', df.shape)
    df = df[df['数量'] > 0]
    print('⑤ 去无意义:', df.shape)
    dst = os.path.join(td, '订单_清洗.csv')
    df.to_csv(dst, index=False)
    back = pd.read_csv(dst, parse_dates=['订单日期'])
    print('⑥ 导出并回读:', back.shape, list(back.columns))
运行结果(实测)
① 导入: (12, 7)
② 去缺失: (11, 7)
③ 去重复: (10, 7)
④ 去异常: (9, 7)
⑤ 去无意义: (8, 7)
⑥ 导出并回读: (8, 7) ['订单编号', '订单日期', '用户ID', '商品名称', '单价', '数量', '金额']

六行输出对应六次 shape,一眼就能看出每一步去掉了什么:12→11 去掉缺失值那一条、11→10 去掉完全重复的那一条、10→9 去掉异常(单价 162 且数量 30)、9→8 去掉数量为 0 的那一条。最后导出的 CSV 再读回来是 8 行 7 列,列名一个不少——导出不是终点,读回来核对通过才算完。

第二段:在清洗后的数据上查询与分组

清洗完的数据才值得分析。这一段先按“金额 ≥ 1500 的大单”查询,再按商品分组算订购总数量和总金额。注意分组用的是有名聚合(agg(新列名=('原列','函数'))),一步出来就是能直接看的表,不用再 reset_index 改列名。

综合案例(2/3):清洗后查询大单,再按商品分组聚合
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

clean = df.dropna(subset=['商品名称', '单价', '数量']).drop_duplicates()
clean = clean[~((clean['单价'] > 150) & (clean['数量'] > 25))]
clean = clean[clean['数量'] > 0]
print('清洗后:', clean.shape)
print('查询:金额 >= 1500 的订单')
print(clean[clean['金额'] >= 1500][['订单编号', '商品名称', '金额']])
g = clean.groupby('商品名称', as_index=False).agg(
    订购总数量=('数量', 'sum'), 订购总金额=('金额', 'sum'))
print('分组:每种商品的订购总数量与总金额')
print(g.sort_values('订购总金额', ascending=False))
运行结果(实测)
清洗后: (8, 7)
查询:金额 >= 1500 的订单
     订单编号 商品名称      金额
3  302004  运动服  4284.0
5  302006   卫衣  1897.5
分组:每种商品的订购总数量与总金额
  商品名称  订购总数量    订购总金额
3  运动服   31.0  5754.00
0   T恤   43.0  2592.52
1   卫衣   15.0  1897.50
2   围巾   37.0   799.20

这两步的结果要和 8.5、8.6 节的“没清洗版本”对照着看才有意思:没清洗时分组能分出 5 种商品,清洗后只剩 4 种——因为唯一一条 休闲鞋 订单正是那个“单价 162 且数量 30”的异常记录,被删掉了。同一份数据,清洗前后给出的业务结论可能完全不同:不洗的话你会以为休闲鞋卖了 4860 元,洗完才知道它根本不该算进来。

第三段:透视 → 导出 Excel → 回读核对

最后一段产出“能给老师/老板看的表”:行是周次、列是商品、值是金额合计,空格子填 0,最后加一行一列合计;然后 to_excel 写进临时目录的 xlsx,再读回来核对 shape 和合计行。这一步是真实工作里最容易漏的——导出顺利不代表内容对,读回来比一比才放心。

综合案例(3/3):pivot_table 周报 → to_excel 导出 → read_excel 回读核对
import os, tempfile
import pandas as pd
from io import StringIO

csv = """订单编号,订单日期,用户ID,商品名称,单价,数量,金额
302001,2021-02-01,137401,围巾,21.6,12,259.2
302002,2021-02-01,177562,运动服,210.0,7,1470.0
302003,2021-02-01,133422,T恤,55.93,24,1342.32
302004,2021-02-05,138462,运动服,178.5,24,4284.0
302005,2021-02-05,158949,T恤,65.8,14,921.2
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302006,2021-02-08,120957,卫衣,126.5,15,1897.5
302008,2021-02-12,186059,T恤,65.8,5,329.0
302009,2021-02-15,199357,,,,540.0
302010,2021-02-20,149590,休闲鞋,162.0,30,4860.0
302011,2021-02-25,149590,运动服,178.5,0,0.0
302012,2021-02-28,137401,围巾,21.6,25,540.0"""
df = pd.read_csv(StringIO(csv), parse_dates=['订单日期'])

clean = df.dropna(subset=['商品名称', '单价', '数量']).drop_duplicates()
clean = clean[~((clean['单价'] > 150) & (clean['数量'] > 25))]
clean = clean[clean['数量'] > 0]
clean['周次'] = clean['订单日期'].dt.isocalendar().week.astype(int)
pv = clean.pivot_table(values='金额', index='周次', columns='商品名称',
                       aggfunc='sum', fill_value=0,
                       margins=True, margins_name='合计')
print(pv)
with tempfile.TemporaryDirectory() as td:
    out = os.path.join(td, '订单周报.xlsx')
    pv.to_excel(out, sheet_name='周报')
    back = pd.read_excel(out, sheet_name='周报', index_col=0)
    print('导出 xlsx 再读回:', back.shape)
    print('合计行:', back.loc['合计'].to_dict())
运行结果(实测)
商品名称       T恤      卫衣     围巾     运动服        合计
周次                                            
5     2263.52     0.0  259.2  5754.0   8276.72
6      329.00  1897.5    0.0     0.0   2226.50
8        0.00     0.0  540.0     0.0    540.00
合计    2592.52  1897.5  799.2  5754.0  11043.22
导出 xlsx 再读回: (4, 5)
合计行: {'T恤': 2592.52, '卫衣': 1897.5, '围巾': 799.2, '运动服': 5754.0, '合计': 11043.22}
为什么这段要用 tempfile:课程网页里的代码会在临时目录里跑,如果写死 to_excel('订单周报.xlsx'),文件会落在执行目录里、还可能因为权限或重名失败。tempfile.TemporaryDirectory() 帮你造一个用完即删的目录(离开 with 块自动清理),os.path.join(td, '文件名') 拼出完整路径,既真实又不留垃圾。写代码时不要 print 这个路径——它对别人没有意义,还会泄露本机目录结构。
✅ 本节小结:综合案例的六步是导入 → 清洗 → 查询 → 分组 → 透视 → 导出,每一步都打印 shape 核对行数;清洗四项(缺失 / 重复 / 异常 / 无意义)去掉 4 行后,分组结果从 5 种商品变 4 种——清洗前后结论可能完全不同;导出用 to_excel 写进 tempfile 目录、再用 read_excel 读回来核对,才算真正完成。

8.5 AI 渗透:Pandas 在 AI 数据管线中的位置

学完这一章,很多同学会问:这些数据处理跟 AI 有什么关系?答案是“数据分析是 AI 的前置工序”——模型再强,喂进去的数据也是脏的。工业界流传一句话:“数据和特征决定了机器学习的上限,模型只是逼近这个上限”。而“数据 + 特征”这一段,主力工具就是 pandas。

1
原始数据:CSV / Excel / 数据库 / 日志 / 爬虫结果pd.read_csv() · pd.read_excel() · read_sql()
2
DataFrame:带列名的二维表,是“训练数据”最自然的容器df.shape · df.columns · df.dtypes
3
清洗与特征工程:缺失值填充、异常值处理、类别转 0/1、数值标准化、构造新特征列fillna() · pd.cut() · pd.get_dummies() · (x-x.mean())/x.std()
4
ndarray / Tensor:把特征列转成“样本 × 特征”的数值矩阵,进入模型df.to_numpy() → torch.from_numpy(X)
5
训练 / 推理:模型开始算——这一段的代码只有几行,前面的数据准备往往是几十行model.fit(X, y) · model.predict(X)

三个工具的衔接关系可以用一张表说清:pandas 管“人看得懂的表”,NumPy 管“模型看得懂的矩阵”,PyTorch 管“能上 GPU 算的张量”。它们之间转换几乎零成本——df.to_numpy() 一行进 NumPy,torch.from_numpy(X) 一行进 PyTorch(还共享内存)。

要做的事pandas(DataFrame)NumPy(ndarray)PyTorch(Tensor)
看形状df.shape(行, 列)X.shapet.shape
看每列类型df.dtypes(每列可不同)X.dtype(全部相同)t.dtype
按列名取df['单价']只能按位置 X[:, 0]t[:, 0]
转成矩阵df.to_numpy()——torch.from_numpy(X)
标准化(df - df.mean()) / df.std()(X - X.mean(0)) / X.std(0)同 NumPy,写在张量上
类别转 0/1pd.get_dummies(df, dtype=int)手写编码F.one_hot
算在哪CPU(内存)CPU(内存)t.device:cpu / cuda

第一段演示“DataFrame → 特征矩阵”的标准动作。先造一张 4 行的小表:两个数值特征(单价、数量)加一个类别列(会员等级)——真实项目里这张表有几十万行,道理一样。把数值特征转成 ndarray 后按列标准化:每个特征减去自己的均值、再除以自己的标准差。标准化是几乎所有模型的默认要求——不做的后果是“数量级大的特征把梯度带着跑”,模型只学会看那个大数。

DataFrame → ndarray → 按列标准化:特征矩阵进模型前的标准动作
import pandas as pd

# 一行一个样本、一列一个特征 —— 这就是训练数据的标准形状
df = pd.DataFrame({'单价': [21.6, 210.0, 55.93, 126.5],
                   '数量': [12.0, 7.0, 24.0, 15.0],
                   '会员等级': ['金卡', '普通', '金卡', '普通']})
X = df[['单价', '数量']].to_numpy(dtype='float64')   # 数值特征 → ndarray
print('X.shape =', X.shape, '  X.dtype =', X.dtype)
Z = (X - X.mean(axis=0)) / X.std(axis=0)              # 按列标准化
print('标准化后每列均值:', Z.mean(axis=0).round(6).tolist())
print('标准化后每列标准差:', Z.std(axis=0).round(6).tolist())
print('第一个样本:', Z[0].round(3).tolist())
print('类别列模型读不懂,用 get_dummies 转 0/1:')
print(pd.get_dummies(df[['会员等级']], dtype=int))
运行结果(实测)
X.shape = (4, 2)   X.dtype = float64
标准化后每列均值: [0.0, 0.0]
标准化后每列标准差: [1.0, 1.0]
第一个样本: [-1.135, -0.404]
类别列模型读不懂,用 get_dummies 转 0/1:
   会员等级_普通  会员等级_金卡
0        0        1
1        1        0
2        0        1
3        1        0

输出里“每列均值 0、标准差 1”不是巧合,是标准化定义的直接结果;X.mean(axis=0) 是“按列压”,和 7.3 节 groupby 压行是同一个“归约”思想。get_dummies 把“是否会员”这种类别列拆成 0/1 列——真实数据和这个一模一样,只是列有几万种取值时,会改用“目标编码 / 嵌入向量”等更省空间的方法。

第二段单独看类别特征编码,这是表格类数据进模型前绕不开的一步。机器学习模型只吃数字,商品名称 这种文本列必须转成数字特征:最常用、最不容易错的方法就是 one-hot(get_dummies),一件商品一列,是它就是 1、不是就是 0。

类别列 → 0/1 特征矩阵:one-hot 编码就是 get_dummies
import pandas as pd

df = pd.DataFrame({'商品名称': ['围巾', '运动服', 'T恤', '卫衣', '围巾'],
                   '数量': [12, 7, 24, 15, 25]})
print('原始表(文本列模型读不懂):')
print(df)
dummies = pd.get_dummies(df, columns=['商品名称'], dtype=int)
print('one-hot 之后:一件商品一列,是它填 1、不是填 0')
print(dummies)
print('特征矩阵形状:', dummies.to_numpy().shape)
print('列名(特征名):', dummies.columns.tolist())
运行结果(实测)
原始表(文本列模型读不懂):
  商品名称  数量
0   围巾  12
1  运动服   7
2   T恤  24
3   卫衣  15
4   围巾  25
one-hot 之后:一件商品一列,是它填 1、不是填 0
   数量  商品名称_T恤  商品名称_卫衣  商品名称_围巾  商品名称_运动服
0  12        0        0        1         0
1   7        0        0        0         1
2  24        1        0        0         0
3  15        0        1        0         0
4  25        0        0        1         0
特征矩阵形状: (5, 5)
列名(特征名): ['数量', '商品名称_T恤', '商品名称_卫衣', '商品名称_围巾', '商品名称_运动服']

两步合起来,就是一条完整的“进模型前”路径:pandas 清洗 + 造特征 → to_numpy 变矩阵 → 标准化 → 转 Tensor。这一章学的每一个方法,在 AI 项目里都能对上:dropna 对应“缺失值处理”、pd.cut 对应“连续特征离散化”、groupby 对应“按用户聚合历史行为”、pivot_table 对应“宽表特征”、merge 对应“多源数据对齐”。所谓“AI 数据管线”,拆开看就是这一章的操作串起来的一条流水线。

回头看 pandas 与 AI 的关系:DataFrame 是训练数据的标准容器——一行一个样本、一列一个特征,这个约定几乎所有机器学习库都默认。数据从磁盘进来,在 pandas 里清洗、拼接、构造特征,再 to_numpy() 变成模型能吃的矩阵,最后 torch.from_numpy(X) 零拷贝上 Tensor、.to('cuda') 进显卡。模型训练那几行代码是“最后一公里”,前面几十行都是 pandas 在干活;把这一章练熟,就是在练 AI 工程师每天真正花时间的那部分。
✅ 本节小结:pandas 站在 AI 数据管线的中段——磁盘 → DataFrame(清洗 / 特征)→ ndarray(矩阵)→ Tensor(GPU)→ 模型;df.to_numpy() 转矩阵、get_dummies 做 one-hot、按列标准化是进模型前的标准三步;数据分析是 AI 的前置工序,这一章的方法在 AI 项目里一个都不会浪费。

8.6 本章知识地图与小结

八节内容、一百多个方法,看起来很多,其实只有三条主线。先把知识地图铺开,再收成三句话。

8.1
Pandas 基本数据结构
Series = 带标签一维;DataFrame = 带标签二维。index / columns / values 三部分。见 c1、c2。
8.2
数据分析概述
问题定义 → 数据准备 → 预处理 → 分析 → 展示报告,五步流程。见 c4。
8.3
数据的导入与导出
read_excel / read_csv / read_table 与 to_excel / to_csv,参数 header、names、usecols、index。见 c4。
8.4
数据预处理
缺失值(isnull / dropna / fillna)、重复值(duplicated / drop_duplicates)、异常值、加工提取周次。见 c5。
8.5
数据查询
loc / iloc、布尔索引、多条件 & | ~、between / isin、nlargest、排序。见 c3、c6。
8.6
数据聚合与统计分析
描述统计、value_counts / mode / nunique、groupby + agg、pd.cut 分区、resample 重采样。见 c7。
8.7
建立数据透视表
pivot_table 的 index / columns / values / aggfunc / margins / fill_value,行 × 列 × 值。见 c7。
8.8
数据框的合并与连接
concat(axis=0 / 1)、merge 四种 how、indicator / validate 校验、综合案例流水线。见 c8。

主线一:数据结构

  • Series:index + values
  • DataFrame:行索引 + 列索引 + 值矩阵
  • 建表、查看、访问全靠这三块
  • 口诀:loc 看名字,iloc 看座号

主线二:预处理与查询

  • 先看 shape / info / describe 体检
  • 再删缺失、重复、异常
  • 然后筛行、选列、排序
  • 口诀:先洗干净,再挑出来

主线三:分析与整合

  • 分组:groupby + agg
  • 透视:pivot_table 行×列×值
  • 拼表:concat / merge
  • 口诀:想清维度,再选工具
上机与考试最容易踩的 8 个坑(按出错率排):① inplace=True 之后又去接返回值(得到 None);② groupby 之后忘了 reset_index() / as_index=False,分组键变成索引后没法当列用;③ pivot_table 不写 aggfunc,默认是 'mean' 不是 sum;④ 多条件查询不加小括号,& 的优先级高于比较运算符;⑤ pd.cut 的 bins 没把最大值包住,出现 NaN;⑥ merge 前不查重复键,连接后行数莫名变多;⑦ 以为 df['列'] 总能改值(pandas 3 的 CoW 下要写 df.loc[条件, '列'] = 值);⑧ 还在写 freq='M'——pandas 3 已删除,要写 'ME'。
把这一章压缩成一句话:Pandas 就是把“带标签的表格”一路加工成“结论”的工具箱——读进来(导入)→ 洗干净(预处理)→ 挑出来(查询)→ 压下去(聚合 / 分组 / 透视)→ 拼起来(合并 / 连接)→ 交出去(导出 / 可视化)。每个方法都只是这句话里某个动词的实现,考试考的是“知道什么时候用哪个动词”,而不是背 API。
✅ 本节小结:本章三条主线——数据结构(Series / DataFrame 的三部分)、预处理与查询(清洗脏数据后再筛行选列)、分析与整合(groupby 分组、pivot_table 透视、concat / merge 拼表);八个高频坑集中在 inplace、索引、aggfunc 默认值、括号、bins 边界、重复键和 pandas 3 的 'ME' 上。数据分析是 AI 的前置工序,这一章练的就是那道工序。
配套视频黑马程序员 · 第 126 集 数据分析案例步骤3-可视化开发B站 · 课程配套案例的可视化收尾,本课综合案例的下一步就是它:把透视出来的结果画成图,写进报告
九

交互演示区

8 个面板,改参数点按钮立刻看结果 · 浏览器内 JS 按 pandas 3.0.5 的规则重算,输出已与本机 Python 实测逐字对齐

演示一:Series 创建与访问

对应 1.2—1.4 节。选一种创建方式、填数据,点按钮同时看到三件事:Series 的 index → value 结构、s[标签] 与 s[位置] 的区别、布尔筛选 s[s >= 80] 的结果。方式一用列表(默认 0..n-1 索引,此时“标签 1”和“第 2 个位置”恰好重合);方式二用字典(键直接变成索引);方式三自己指定标签——一旦自定义 index,s[1] 就会被当成“标签 1”去找,找不到就报 KeyError,要按位置取必须写 s.iloc[1]。这正是 1.4 节反复强调的坑。

点上面的按钮试试

演示二:DataFrame 构造器

对应 2.1—2.5 节,两种最常用的建表方式。嵌套列表:每一行一组数,行内用逗号或空格分隔,行与行之间换行(也可以用分号);列名默认是 0、1、2…,可以在“列名”里自己填,行标签同理。字典:每个键变成一列,每行写成「列名: 值1, 值2, …」,每个键下的值个数必须一样。点按钮看生成的表格,以及 shape / index / columns / dtypes 四件套。注意 pandas 3 里整列都是整数时 dtype 是 int64,一旦混入小数或缺值,那一列就变成 float64。

点上面的按钮试试

演示三:loc / iloc / at / iat / df[] 五种写法对照

对应 3.1—3.3 节。成绩表固定:行标签是 语文 / 数学 / 英语 / Python,列名是 zhao / wang。输入“行标签, 列名”(例如 数学, wang),面板会自动算出这一格的行位置 row 和列位置 col,再把同一个格子的五种写法并排列出来:loc 看名字、iloc 看座号、at / iat 只取单个值、df[列][行] 先选列再选行。换个目标再点一次,对照关系不变,只是数字跟着变。

点上面的按钮试试

演示四:多条件筛选器(& / |)

对应 6.2—6.3 节。12 行订单表固定(含 1 条记录缺 3 格、1 组重复)。每一行写一个条件,格式是「列名 运算符 值」,运算符支持 >= <= > < == !=;再选 & 全部满足 或 | 满足任一。点按钮看每一行的布尔掩码、命中行数和筛选后的结果表。在代码里写多条件时,每个条件都要用小括号括起来再和 & / | 组合(df[(df.金额 > 2000) & (df.商品名称 == '运动服')]);面板里一行写一个条件,不用自己加括号。比较时遇到 NaN 一律判 False,只有 != 是例外:NaN != 值 在 pandas 里是 True。字符串直接写(商品名称 = 运动服),日期写 2021-02-15 这种格式。

点上面的按钮试试

演示五:缺失值处理器(dropna / fillna)

对应 5.2—5.4 节。订单表里有 3 个 NaN,都在 302009 这一行(商品名称、单价、数量为空,金额 540 还在)。选一种处理方式,看处理后 shape 怎么变、哪几行被删、缺口被填成什么。dropna 默认 how='any'(任意一项为空就删这一行),how='all' 要整行全空才删;fillna 均值按 pandas 的规则只对数值列算均值(保留 2 位小数,示例 15.55),字符串列没有均值;ffill 用上一行的值往下填——注意 pandas 3 已经移除 fillna(method=…),要写 df.ffill(),直接写旧参数会报 TypeError。

点上面的按钮试试

演示六:分组聚合器(groupby + agg)

对应 7.3 节。选分组列(商品名称 / 周次)、要聚合的列(金额 / 数量)和聚合函数(sum / mean / max / count),看 groupby 到底算了什么。三个默认行为要记住:结果按分组键升序排列(中文按 Unicode 码位排,不是拼音);分组键是 NaN 的行默认被丢掉(302009 的商品名称为空,按商品名分组时它的金额 540 不计入任何一组,但按周次分组时它属于第 7 周,不会丢);count 只数非空值(数量列少了一个空,计数就可能比金额列小)。

点上面的按钮试试

演示七:透视表构造器(pivot_table)

对应 7.7 节。选行(index)、列(columns)、值(values)、聚合函数(aggfunc)以及是否加合计行列(margins),看透视表怎么把长表“摊”成矩阵。三个要点:aggfunc 默认是 'mean'(不写就是求平均,不是求和,最容易踩的坑);没有数据的格子显示 NaN;默认 dropna=True,整行都是空的行会被整行丢掉(按订单日期做行时,2021-02-15 只有一条商品名称为空的订单,这一天会消失)。加 margins=True 会在最右和最后多出 All 行/列,mean 的合计是对该行/列所有原始值求平均,不是几个格子的平均数再平均。

点上面的按钮试试

演示八:merge 连接模拟器

对应 8.2—8.3 节。左表是 12 行订单按商品名称 groupby 汇总出来的 5 行,右表是 7 行商品表。选 how,看连接结果和行数怎么变:inner 只留两边都有的键、left 保留左表全部键、right 保留右表全部键、outer 保留两边所有键。重点是行数:订单里出现的 5 个商品在商品表里都有,所以 inner = left = 5 行;商品表多出的“运动鞋”“太阳帽”没有订单,right / outer 是 7 行,这两个商品的金额、数量填 NaN。连接前后一定要看行数,重复键会让行数膨胀(这份数据里没有,但 8.3 节的检查要养成习惯)。

点上面的按钮试试
这 8 个面板都是照抄 pandas 3.0.5 的规则用原生 JS 重写的:NaN 显示为 NaN、groupby 默认丢弃 NaN 分组并按分组键升序、pivot_table 默认 aggfunc='mean' 且 margins 的 All 行列按同一 aggfunc 汇总、dropna 的 how='any'/'all'、fillna 均值保留 2 位小数、merge 四种 how 的行数与行顺序——标准答案先用本机 py + pandas 3.0.5 跑出来,再一条一条搬进 JS。把面板里同样的参数搬到上面的示例代码里跑一遍,数字和形状都是一样的。
十

配套代码与数据下载

课件完整数据 + 本页全部示例代码 + 课后作业参考答案,都能下载到本机跑

本页所有示例代码都已经整理成可直接运行的 .py 文件,课件里的完整订单数据(310 行)也一并放出来了。建议把数据文件和代码文件下载到同一个文件夹,在命令行执行 python 文件名.py 就能跑;页面上的代码也可以直接点「复制代码」拷到自己的编辑器。

使用提示:① 运行环境 pip install pandas openpyxl numpy(本页实测 Python 3.14 + pandas 3.0.5);② 商品.csv、订单_part.csv 是GBK 编码(与课件一致),读取时写 encoding="gbk";③ pandas 3 里 freq="M" 已改为 "ME",旧教材代码要相应修改;④ 数据文件找不到时,请确认代码与数据在同一文件夹。

一、数据文件(课件完整数据 + 页面示例数据)

文件名(点击下载)内容大小
订单.xlsx 原始订单数据(310 行 × 7 列),含缺失值、异常值(含金额为 0 的订单;数量为 0 的情形用 12 行精简数据演示);完整数据里没有完全重复的行,重复值问题用 12 行精简数据演示。课件例 8-4—8-11 都用它。 90.0 KB
订单_new.xlsx 清洗后的订单数据(305 行 × 9 列):删除缺失值 + 地区编码 + 周次,例 8-13 / 8-14 的结果。 18.3 KB
订单_clean.xlsx 删除缺失值后的订单数据(305 行 × 7 列),例 8-8 的结果。 16.5 KB
订单_fill.xlsx 填充缺失值后的订单数据(310 行 × 7 列),fillna 练习结果。 16.7 KB
订单_J1.xlsx 1 月上半月订单(160 行),concat 合并练习(例 8-39)。 15.3 KB
订单_J2.xlsx 1 月下半月订单(172 行),concat 合并练习(例 8-39)。 18.0 KB
订单_Jan.xlsx 合并后的 1 月订单(332 行),例 8-39 的结果。 17.6 KB
商品.csv 商品信息表(7 种商品:进价 / 产地 / 库存 / 销售价),merge 连接练习(例 8-40)。注意:GBK 编码,读取要写 encoding='gbk'。 194 B
订单_part.csv 订单日期 / 商品名称 / 数量 三列(例 8-6 的导出结果)。注意:GBK 编码。 6.6 KB
精简订单数据.csv 页面示例统一使用的 12 行精简订单数据(UTF-8),含缺失值 / 重复值 / 异常值三类问题,便于跟着页面敲代码。 624 B
学生成绩.csv 第 1—3 章示例用的学生成绩小表(4 门课 × 2 名同学),UTF-8。 68 B
月度销售_2025.csv 课后作业 1 使用的 2025 年 12 个月销售数据(随机种子 42,与参考答案一致),UTF-8。 283 B

二、示例代码(按模块整理,可直接运行)

文件名(点击下载)内容大小
示例代码_模块1_Series.py 模块 1「Pandas 与 Series」的全部示例代码(11 段):Pandas 入门 · Series 结构 · 创建 / 访问 / 统计 · date_range 时间索引。 5.6 KB
示例代码_模块2_DataFrame创建与查看.py 模块 2「DataFrame 创建与查看」的全部示例代码(12 段):嵌套列表 / 字典建表 · index 与 columns · shape / dtypes · head / info / describe。 5.2 KB
示例代码_模块3_访问修改与排序.py 模块 3「访问、修改与排序」的全部示例代码(12 段):loc / iloc / at / iat · df[ ] 三种用法 · 布尔索引 · 增删改与转置 · sort_index / sort_values。 5.9 KB
示例代码_模块4_数据导入与导出.py 模块 4「数据导入与导出」的全部示例代码(11 段):数据分析流程 · read_excel / read_csv / read_table · 导入参数 · to_excel / to_csv。 9.3 KB
示例代码_模块5_数据预处理.py 模块 5「数据预处理」的全部示例代码(15 段):缺失值 isna / dropna / fillna · 异常值查找与处理 · 重复值 · astype / str / dt。 17.0 KB
示例代码_模块6_数据查询.py 模块 6「数据查询」的全部示例代码(14 段):行列查询 · 比较条件 · & | ~ 多条件 · between / isin · nlargest · 查询 + 排序。 17.1 KB
示例代码_模块7_聚合与透视表.py 模块 7「聚合统计与数据透视表」的全部示例代码(14 段):描述统计 · value_counts · groupby + agg · 结果整形 · pd.cut 分箱 · resample · pivot_table。 16.2 KB
示例代码_模块8_合并连接与综合.py 模块 8「合并连接与综合案例」的全部示例代码(12 段):concat · merge 四种 how · 连接校验 · 订单全流程 · AI 数据管线。 15.1 KB

三、课后作业参考答案

文件名(点击下载)内容大小
第8章_课后练习_参考答案.py 课后作业参考答案:① 2025 年销售表 9 个任务;② 订单_new.xlsx 统计;③ 订单数据全流程(清洗→查询→分组→透视→导出)。直接运行即可。 6.7 KB

四、一次打包下载

第8章_代码与数据_资料包.zip202.3 KB · 全部文件

把上面的数据、示例代码、作业答案和说明文档打成一个 zip,解压后直接可用。

⬇ 下载 第8章_代码与数据_资料包.zip(202.3 KB)

解压后建议先看 README_使用说明.md;运行示例前确认已安装 pandas / openpyxl。
说明:页面为便于阅读,示例统一使用 12 行的精简订单数据(也提供 精简订单数据.csv);课件完整数据 310 行为 订单.xlsx,课后作业与综合练习请用完整数据。若发现文件缺失或代码跑不通,欢迎反馈。
结

知识点总结卡 · 易错清单 · 作业

复习用:下面每一条都能自己讲出来,这一章就算过关

一、知识点总结卡

Pandas 与 Series

  • Pandas 基于 NumPy,专为带标签的结构化数据设计
  • 两大对象:Series(带标签一维)、DataFrame(带标签二维)
  • Series = index(标签)+ values(值)
  • 默认索引 0..n-1;可用列表 / 字典指定标签
  • 访问:s[标签]、s.iloc[位置]、切片、s[[标签1,标签2]]、s[s>=80]
  • 时间索引:pd.date_range(start, end, periods, freq),三选二;freq='ME' 月末

DataFrame 创建与查看

  • 三部分:index(行标签)、columns(列标签)、values(值矩阵)
  • 嵌套列表建表 → 行列默认 0..n-1;字典建表 → 键就是列名
  • index= / columns= 可在创建时指定,也可事后赋值
  • shape 形状、dtypes 各列类型、values 是 ndarray
  • head(n) / tail(n) 看前 / 后 n 行
  • info() 看行数 / 非空计数 / dtype;describe() 看数值统计

访问、修改与排序

  • loc[行标签, 列标签]、iloc[行位置, 列位置]:loc 看名字、iloc 看座号
  • at / iat 只取一个值
  • df[0:2] 选行、df['列'] 选列、df[['列1','列2']] 选多列
  • df[df.wang >= 80] 布尔索引挑行
  • 改值 / 加列 / T 转置 / drop(columns/index, inplace)
  • sort_index(axis, ascending) 按标签、sort_values(by, ascending) 按值

导入与导出

  • read_excel(io, sheet_name, header, names, index_col, usecols),依赖 openpyxl
  • read_csv(filepath, sep, header, names, index_col, usecols, encoding),默认逗号
  • read_table(...) 默认 Tab 分隔(.txt)
  • to_excel(excel_writer, sheet_name, columns, header, index)
  • to_csv(path, sep, columns, header, index)
  • 导出不带行号:index=False;中文乱码先查编码

数据预处理

  • 查找缺失:isnull() / isna() / notna(),.any() 看哪些列
  • 删除缺失:dropna(axis, how, thresh, subset, inplace),默认 how='any'
  • 填充缺失:fillna(value, axis, inplace, limit);均值 / 前向 df.ffill()(pandas 3 已删 fillna(method=…))
  • 异常值:条件 + & 查找,drop(index=…) 删除,clip / loc 替换
  • 重复值:duplicated(subset, keep)、drop_duplicates(subset, keep, inplace)
  • 其它:astype 转类型、str[0:2] 抽字段、dt.isocalendar().week 提周次

数据查询

  • 行切片 df[100:105]、列选择 df[['商品名称','数量']]
  • 比较条件:== != > >= < <= → 布尔索引
  • 多条件:& | ~,每个条件都要加括号
  • 区间 / 集合:between(a, b)、isin([…])
  • Top N:nlargest(n, '列');组合排序 sort_values(by=[…], ascending=[…])
  • 赋值用 df.loc[条件, '列'] = 值,不要链式赋值

聚合统计与透视表

  • 描述统计:sum / count / mean / max / min / std / mode / value_counts
  • 分组:df.groupby(by, as_index, sort) + .agg({'列':'函数'})
  • 结果整形:as_index=False 或 reset_index(),再改列名 / 排序
  • 分箱:pd.cut(x, bins, right, labels),再 value_counts().sort_index()
  • 重采样:df.resample('7D', on='日期').agg(...)(选学)
  • 透视表:pivot_table(values, index, columns, aggfunc, fill_value, margins);默认 aggfunc='mean'

合并、连接与综合

  • 合并 pd.concat([df1, df2], axis=0, ignore_index=True):axis=0 摞行、axis=1 拼列
  • 连接 pd.merge(left, right, how, on, left_on, right_on, suffixes)
  • how:inner(默认,交集)、left、right、outer
  • 连接前查连接键是否唯一;连接后核对行数
  • 全流程:导入 → 查看 → 清洗 → 查询 → 分组 / 透视 → 合并 → 导出
  • DataFrame 是 AI 数据管线里“清洗与特征”的标准容器

二、易错清单(都在这台机器上真实踩过)

现象 / 报错原因正确做法
ValueError: Invalid frequency: M pandas 3 起 'M' 被删除,月末改叫 'ME' 月末用 freq='ME'、月初用 'MS';旧教材的 'M' 要改
df[(a > 1) & (b < 2)] 报 TypeError 运算符优先级:& 比 > 先算,或条件没加括号 每个条件都加小括号:df[(df.a > 1) & (df.b < 2)]
df = df.dropna(inplace=True) 之后 df 变成 None inplace=True 原地修改,返回值是 None 只用一种:df.dropna(inplace=True) 或 df = df.dropna()
df[df.x > 1]['y'] = 0 改了但没生效 链式赋值,pandas 3 的写时复制(CoW)下不会写回原表 用 df.loc[df.x > 1, 'y'] = 0 一步定位
pivot_table 出来的数比手算的小很多 默认 aggfunc='mean',不是求和 求和要写 aggfunc='sum'
merge 之后行数比原来多 右表连接键有重复值,一对多会膨胀 连接前 right['键'].duplicated().any();连接后核对 len(df)
df.loc[0] 报 KeyError: 0 行索引不是 0..n-1(可能是字符串标签或重排过) 按位置用 df.iloc[0];先 df.index 看一眼
df[0] 报 KeyError: 0 df[整数] 被当成“列标签”查找 选行用切片 df[0:1] 或 df.iloc[0];选列用列名
结果里多了一列 Unnamed: 0 读文件时把行索引当成了数据列 read_csv(..., index_col=0);或导出时 index=False
UnicodeDecodeError: 'utf-8' codec can't decode CSV 是 GBK 编码(Excel 另存常见) read_csv(..., encoding='gbk');或 encoding='utf-8-sig'
读 Excel 报 ImportError: Missing optional dependency 'openpyxl' 没装 Excel 引擎 pip install openpyxl(本机已装)
FutureWarning / dtype 和教材截图不一样 pandas 3 变了默认行为(字符串 dtype 显示 str、日期 datetime64[us]) 以本页实测输出为准;旧版教材截图里的 object、ns 是 pandas 2 及更早

三、课后作业(用 Pandas 完成,不许用 for 循环逐行处理)

本章作业

  1. 销售表基本功(课件课后练习 1):模拟某商场 2025 年 12 个月的服装、化妆品、日用品销量表,建立名为 sales 的数据框对象。要求:① 销量用随机数生成(每种商品都不超过 50,固定随机种子);② 用 pd.date_range 生成 2025 年 1—12 月的时间序列作为行索引;③ 查询 6 月份“化妆品”销售量;④ 查询 5 月和 10 月的销售记录;⑤ 查询“服装”销量 20~35 的记录;⑥ 查询“服装”和“化妆品”销量都超过 30(含)的记录;⑦ 按“日用品”销量降序排序;⑧ 统计 2025 年各商品销售总量;⑨ 统计每个月销售总量。
  2. 订单统计分析(课件课后练习 2,用完整 data\订单.xlsx 或 订单_new.xlsx):① 每天的订单记录数量;② 每周的订购总数量和总金额,并保存成 CSV;③ 每周各商品的订单记录数量(pivot_table + aggfunc='count' + margins);④ 第 5 周的订购总数量;⑤ 自选两个分析目标并说明结论。
  3. 综合实战:自己造一份不少于 20 行、带缺失值 / 重复值 / 异常值的“脏”订单数据(字段:订单编号、日期、用户ID、商品、单价、数量、金额),完成:导入 → info 检查 → 删缺失 / 去重 / 删异常 → 按商品分组统计 → 建透视表 → 导出 Excel(不带索引)。每一步输出处理前后的 shape,并在报告里解释为什么行数这样变化。

提交要求:每题给出代码 + 运行结果;第 3 题的输出文件一并提交;变量名要能读懂,关键步骤写注释。

四、下讲预告

第 9 次课 · 第 9 章 Python 数据可视化(即将上线)
Matplotlib 绘图 · Pandas 绘图 · 折线 / 柱状 / 散点 / 箱线图 —— 把这一章汇总出来的数字画成图,一眼看出趋势与异常
回到课程主页查看课次 →
本章自测(不查资料,先自己在纸上写)
  1. Series 和 DataFrame 分别对应几维数据?它们各由哪几部分组成?
  2. df.loc['语文', 'zhao'] 和 df.iloc[0, 0] 什么时候结果相同、什么时候不同?
  3. pd.date_range(start='2025-01-01', periods=12, freq='ME') 生成几个时间点?第一个和最后一个分别是哪天?
  4. read_csv 的 index_col=0、header=None、usecols 各解决什么问题?
  5. dropna(how='any') 和 dropna(how='all') 的区别?inplace=True 的坑是什么?
  6. df[df.金额 > 3000] 里那个布尔表达式返回什么?为什么能用来“挑行”?
  7. groupby('商品名称').agg({'金额': 'sum'}) 和 pivot_table(values='金额', index='商品名称', aggfunc='sum') 结果有什么关系?
  8. merge 的 how='inner' 与 how='outer' 保留哪些记录?为什么连接后要核对行数?