① index(行索引)
- 竖着排在表格最左边,标识“这是第几条记录”
- 可以是 0、1、2…,也可以是科目名、日期、订单号
- 默认是从 0 开始的编号
带标签的数据结构(Series / DataFrame)· 数据导入与导出 · 数据预处理(缺失 / 重复 / 异常)· 数据查询与排序 · 分组聚合与分箱 · 数据透视表 · 合并与连接 · 订单数据全流程 · AI 渗透(8 个知识模块 + 110 段实测代码 + 22 张插图 + 17 个动态演示图 + 8 个交互面板 + 可下载的代码与数据)
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。页面按“数据结构 → 导入导出 → 预处理 → 查询 → 聚合 → 透视 → 合并”的主线展开,最后用订单数据把全流程串一遍。示例和演示比前几章都多:每段代码都在本机真实运行、结果自动回填;每个抽象概念都配手绘插图、可单步播放的动画和可动手改参数的交互面板。
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 合并连接两张表,并能独立完成订单数据的全流程分析。
点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。
data\订单.xlsx),页面为便于阅读统一使用 12 行精简订单数据(保留了缺失值、重复值、异常值三类问题),课后练习请用完整数据。页面每段代码都在本机真实运行后回填(Python 3.14 / pandas 3.0.5),运行结果默认隐藏,点“运行”才显示。Series 是带标签的一列,DataFrame 是带标签的表(index 行标签 + columns 列标签);② 取数据先想清楚“按标签还是按位置”——loc 看名字、iloc 看座号,条件筛选用布尔索引;③ 分析四板斧:筛选 → 分组(groupby)→ 汇总(agg)→ 透视(pivot_table);④ 数据不干净、分析全白搭:缺失 / 重复 / 异常值先处理,导出时记得 index=False。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 的 index 与 values · 五种创建方式 · 访问与修改 · 运算统计 · 时间索引与 date_range
第 7 章我们学会了用 NumPy 数组装一大批数字,整块加减乘除,速度很快。但数组有一个天生的短板:它只有位置,没有名字。数组里的第 1 个元素是 89,可这个 89 是数学成绩、语文成绩,还是某个订单的金额?数组自己不知道,只能靠你在旁边再记一个列表。真实的数据分析几乎全是“带标签的表格”:每一列有列名(姓名、单价、金额),每一行有行标识(订单号、日期、学号)。
Pandas 就是为“带标签的表格”而生的库。它提供两个核心对象:Series(带标签的一维数据,可以想成“一列”)和 DataFrame(带标签的二维表格)。本模块先把 Pandas 是什么、为什么用它讲清楚,然后集中讲 Series——它既是 DataFrame 的“零件”(每一列就是一个 Series),本身也是处理单列数据的主力。下一模块再讲 DataFrame。
先用一组最小的例子把痛点摆出来:四门课的成绩,分别是 93、89、80、92 分,科目依次是语文、数学、英语、Python。如果只用 Python 自带的列表,想取“数学”的成绩,就得先记住“数学排第 2 个”,再用下标 1 去取。
scores = [93, 89, 80, 92] subjects = ['语文', '数学', '英语', 'Python'] scores[1] # 89 # 可 89 是哪门课?要靠 subjects[1] 反查 # 两个列表一旦有一处错位,全盘皆错
import pandas as pd s = pd.Series(scores, index=subjects) s['数学'] # 89 # 名字写在 index 里,取数不用再数位置 # 顺序变了也不会取错
字典能解决“按名字取值”的问题,但一张表往往有好几列:姓名一列、成绩一列、班级一列。用字典就得维护好几个字典,而且一旦要加一行(加一个学生),每个字典都得同步加一项,非常容易漏。NumPy 数组能做整块运算,可它要求所有元素类型一致,姓名和成绩不能混在同一个数组里,`arr[1]` 也依旧是要数位置。“带标签”和“能整块运算”这两件事,列表、字典、NumPy 各占一半,Pandas 把它们合到了一起。
| 容器 | 能按名字取吗 | 能整块运算吗 | 能混类型吗 | 适合装什么 |
|---|---|---|---|---|
列表 list | ❌ 只能按下标 | ❌ 要手写循环 | ✅ 随便混 | 少量、顺序固定的数据 |
字典 dict | ✅ 键就是名字 | ❌ 要手写循环 | ✅ 随便混 | 一条记录的多个字段 |
| NumPy 数组 | ❌ 只有位置 | ✅ 向量化运算 | ❌ 类型必须统一 | 大批同类型数值 |
| Series | ✅ 标签即下标 | ✅ 向量化运算 | ✅ 每列各一个类型 | 一列数据(一维表) |
| DataFrame | ✅ 行标签 + 列名 | ✅ 按列向量化 | ✅ 每列各自类型 | 二维表(真正的数据表) |
用一段代码把“按名字取”和“按位置取”放在一起跑一遍。注意看最后: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
shape、dtype、向量化运算,在这里全都能用上。import pandas as pd 是全世界通用的惯例,pd 这两个字母几乎出现在每一份数据分析代码里。import pandas as pd 是固定写法。把一个 Series 打印出来,屏幕上永远是这样两列:左边一列是标签,叫 index(索引);右边一列是真正的数据,叫 values(值)。大括号外面没有花哨的东西,就这两部分。上面那段代码打出来的:
语文 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 是值那一半(负责整块运算)。两半都存在于同一个对象里,所以既不会错位,也不用手动同步。下图把这个结构拆开画了一遍。
用一段代码把这两个属性和默认索引都打出来看一眼。注意 values 的类型是 numpy.ndarray——它其实就是第 7 章那个数组,只是外面套了一层“标签”。
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 节的访问规则会顺很多。
index(标签,像字典的键)和 values(值,底层是 ndarray)。不写 index 时,Pandas 自动补 0、1、2… 的默认索引。s.index 是 Index 对象、s.values 是 ndarray;不写 index= 时自动使用 0..n-1 的默认索引,写了之后标签就类似字典的键。实际写代码时,Series 的数据来源五花八门:有时候是一串数(列表),有时候是现成的字典,有时候是 range 生成的一串编号。Pandas 的 pd.Series() 都能接住,常用的写法有五种,下图把它们的结果并排放在一起对比。
index= 指定下面这段代码把五种方式各跑一遍。为了输出短一点,取值时用了 .tolist(),它把 Series 里的值转成普通列表;字典那种用 .to_dict(),能看清“键变成了 index”。
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。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。
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()。
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() 返回新对象、不改原对象。Series 的运算和 NumPy 数组一样是“逐元素”的:s + 5 是每个分数加 5,s * 1.1 是每个分数乘 1.1,循环不用写。统计更省事,求和、平均、最大、最小、计数各有一个方法,直接点在 Series 后面就行。注意 mean() 有时会算出 81.66666666666667 这样的长尾巴(比如 245 ÷ 3),展示时用 round(x, 1) 收一下;本页的成绩表均值正好是 88.5,不用收。
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,缺失值)。这听起来有点绕,但它恰恰是现实中最常见的场景——两个月的销售数据,月份不一定完全对得上。
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
a + b 的结果索引顺序可能和你写的不一样——那是合并后的标签顺序,不影响结果对不对。先对齐、再计算这个思路,到了 DataFrame 的列运算、数据合并(第 8.8 节)还会反复出现。sum/mean/max/min/count 一行出统计,长小数用 round() 收;两个 Series 运算会按标签自动对齐,只有一边有的标签结果补 NaN。真实数据里最常见的索引是日期:每天、每周、每月都有一个数。逐天手写日期太累,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…(按小时递增) |
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']
freq,打点的疏密完全不同最典型的应用是给销售额配上月份索引(课件例 8-1 的简化版)。有了日期索引之后,取“3 月的数据”可以直接写 sales['2022-03'],取“一季度”可以写 sales['2022-01':'2022-03'],不用记行号。
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 上各是一行。
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'”。
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.")
'ME'、月初用 'MS',不要再写 'M'。报错信息 Invalid frequency: M … Please use 'ME' instead 已经把答案写在里面了,照着改即可。其他常用别名还有 'D'(日)、'W'(周)、'h'(小时)、'YE'(年末)。把时间索引的用法先记到这里,本章第七模块讲分组统计时会看到:有了 datetime 类型的列,就能用 .dt.year、.dt.month 拆出年、月、周,再按它们分组汇总——那才是时间索引真正发力的地方。
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'] 查询,还能筛选、求和、求均值。三部分解剖 · 嵌套列表建表 · 字典建表(最常用)· 改 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)。造表有两种常用方式:嵌套列表适合“手上已经有一堆数”,字典适合“知道每一列叫什么”。看清一个表只需要五个属性加四个方法,记住之后任何陌生数据拿到手都不慌。
一个 DataFrame 也是由“两列标签 + 一块值”组成的,只不过这里的两列标签变成了行索引(index)和列索引(columns):
shape还有一条非常重要的对应关系:DataFrame 的每一列,单独拿出来就是一个 Series,而且这些 Series 共享同一套行索引。所以第 1 模块学的所有 Series 操作(按标签取、布尔筛选、统计)都能直接用在列上。反过来说,DataFrame 就是“若干个共享行标签的 Series 并排拼在一起”。
index 管行、columns 管列、values 是中间那块值矩阵,三者合起来才是一张表先跑一段代码,把这三个部分分别打印出来,再单独取一列看看它是不是 Series。这段代码也是后面所有 demo 的“标准成绩表”。
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
df['zhao'] 返回的是一个 Series,它的 index 就是 df.index,values 就是那一列的数值。所以 df['zhao'].mean()、df['zhao'][df['zhao'] > 85] 这些写法全是合法的——你等于把表拆成一列一列地处理。反过来说,任何“按列算”的需求,第一步几乎都是先把列取出来。index(行标签)、columns(列标签)、values(值矩阵)三部分组成;一行是一条记录、一列是一个字段;每一列单独取出来就是一个 Series,所有 Series 操作都能用在列上。如果数据本来就是一格一格的(比如从某个系统里导出的二维数组),最直接的建表方式是把“每一行包成一个列表,再把所有行放进一个大列表”,这叫嵌套列表。它长这样:[[93, 90], [89, 80], ...]——外层方括号代表整张表,每个内层方括号代表一行。
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 个列名。
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 就去数列名。
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
sys.tracebacklimit = 0,它让 Python 只打印错误本身、不打印库内部那一长串调用栈(那里全是安装路径,对学习没帮助)。另外 pandas 有些错误会“先抛一次、再包装成原因抛一次”,所以屏幕上可能出现两行同样的错误——看最后一行就够了。NaN、把整列变成 float64——数据反而更脏,所以建表前先检查;② columns= 的个数必须等于每行的元素个数;③ index= 的个数必须等于行数。嵌套列表最大的缺点是没有字段名,所以真实项目里更常用下面这种“字典建表”。pd.DataFrame(嵌套列表) 里外层列表是整张表、内层列表是一行;行列名默认 0..n-1;用 index= / columns= 指定名字,个数必须与行数、列数一致,否则抛 ValueError。真实项目里用得最多的是字典建表:字典的键变成列名,值列表变成那一列的数据。这样写代码时列名和列数据挨在一起,不容易错位,可读性也最好——想加一列就加一个键值对,想删一列就删一个键。
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 成绩,那一格就空着,而不是整行作废。
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
下面这个动画把两种建法的过程逐步放一遍,重点看“列名是从哪里冒出来的”。
columns=)。不管哪种,行数、列数、标签个数三者必须对得上。ValueError;如果值是 Series,Pandas 会按标签自动对齐、缺的补 NaN;行标签仍可用 index= 指定。表建好之后,行列名往往还要调整:比如默认的 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() 默认返回一张新表,原表不动。
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={旧: 新}) 只改指定名字,返回新表、不修改原表。拿到一个陌生的表,第一件事不是算,而是看清它:多少行多少列?列名是什么?值的类型是什么?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…… |
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 做转换)。
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。表一大,打印出来就会刷屏,还看不全。Pandas 给了四个“看表”的方法:head(n) 看前 n 行、tail(n) 看后 n 行、info() 看结构(行数、非空个数、类型)、describe() 看数值列的统计摘要。
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)。
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'。
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() 的四块信息:行数、每列非空计数、每列 dtype、日期列的 datetime64[us];pandas 3 的首行与 dtype 写法都和旧教材不同<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[] 三种用法,然后用布尔索引实现“满足条件的行”,接着学改数据,最后学排序。学完这一模块,一张表你想取哪块就能取哪块。
DataFrame 有两个下标:行和列。loc 和 iloc 就是用来同时指定这两个下标的,写法是 df.loc[行, 列],中间的逗号前面管行、后面管列。区别只有一条,但必须记死:
df.loc['数学', 'wang'] # 行名是 数学,列名是 wang # 方括号里写的是标签(名字) df.loc['语文':'英语', 'wang'] # 切片也按标签,含终点 英语
df.iloc[1, 1] # 第 1 行(从 0 数),第 1 列 # 方括号里写的是位置(整数) df.iloc[0:2, 1] # 切片按位置,不含终点 2
口诀:loc 看名字,iloc 看座号。名字是建表时你起的,座号是数据排队的顺序,两者在默认情况下恰好重合(0、1、2…),所以新手容易混。下图把同一张表的“名字坐标”和“座位坐标”叠在一起画了一遍,同一个 80 分,两种坐标写法不同。
loc 认标签、iloc 认位置:同一个 80 分,左边用“数学 + wang”取,右边用“1 + 1”取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
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 只认标签的好处是:查找不存在的标签它会立刻报错,而不是悄悄返回一个错位的结果。下面这段代码故意写一个表里没有的科目,看看报什么错。
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。
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 找不到标签抛 KeyError,iloc 位置越界抛 IndexError;③ 行索引是自定义标签时,df.loc[0] 会 KeyError,取第几行要用 df.iloc[0];④ df[0] 也不是“第 0 行”,而是“列名叫 0 的那一列”,同样会 KeyError。df.loc[行标签, 列标签] 按名字取、df.iloc[行位置, 列位置] 按位置取;: 表示全选,列表表示多选;loc 切片含终点、iloc 切片不含终点;loc 看名字,iloc 看座号。如果只需要一个格子的值,loc / iloc 也能取(写成 df.loc['数学', 'wang']),但 Pandas 还提供了两个更专门的写法:at 按标签取单值、iat 按位置取单值。它们不支持切片、不支持列表,只能一取一个,换来的是更快的访问速度。
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 比 loc / iloc 更省时间。但如果是整列整块的计算,仍然是向量化最快——能用一行算式解决的,就不要写循环。df.at[行标签, 列标签] 和 df.iat[行位置, 列位置] 都只取单个值,不支持切片和列表;语义与 loc / iloc 一致,只是更快、限制更多。最常用的取数写法其实是直接给 DataFrame 加方括号 df[...]。它在三种情况下有三种含义,靠“方括号里放什么”来区分:放切片是选行,放一个列名是选一列(返回 Series),放一个列名列表是选多列(返回 DataFrame)。
| 写法 | 方括号里是什么 | 取到的是 | 返回类型 |
|---|---|---|---|
df[0:2] | 一个切片(位置 0、1) | 前两行,所有列 | DataFrame |
df['zhao'] | 一个列名(字符串) | zhao 这一列 | Series |
df[['wang', 'zhao']] | 一个列名列表 | 指定的几列 | 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'] 等价。“把 wang 成绩大于等于 80 的行挑出来”是数据分析里出现频率最高的需求,写法叫布尔索引。它分两步,必须分开理解:
df['wang'] >= 80 得到一个和表一样高的 Series,值只有 True / False。True 表示“这一行符合条件”。df[掩码] 只保留 True 对应的行;False 对应的行整行丢弃。行数一定变少。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)) 这种荒唐的式子,直接报错。
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
df[掩码] 再把 False 的行整行丢掉& 的优先级会先把两个整数“与”起来;② 连接符是 & / | / ~,不能用 and / or / not(它们要求整个表达式只有一个 True/False,而这里是一整列,会抛“truth value is ambiguous”);③ 掩码的行数必须和表一样高,所以它只能来自这张表自己的列。df['列'] >= 值 造出一排 True/False,再 df[掩码] 挑出 True 的行;区间用 between(下限, 上限);多条件用 & | ~ 且每个条件都要加括号;df.loc[掩码, 列] 可以只保留指定列。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 的写法,可以拿上面的数据进行逐条验证。取数之外,另一类高频操作是改数。改单个值用 loc 定位后赋值;加一列直接给一个不存在的列名赋值;想整体换个方向看用转置 .T;想删列删行用 drop()。
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
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)
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=[...]) 删行,默认返回新表。排序有两个入口:按行标签排用 sort_index(),按某一列的值排用 sort_values()。两者的共同参数是 ascending(True 升序、False 降序)和 axis(默认 0 按行,1 按列)。
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 也要传一个同样长度的列表分别说明每列是升还是降。
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) 按“赵敏”这一行的值给各列排序。这个用法在“把每个学生的科目按分数排一排”时很好用。
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
print(df.sort_values(...)) 或重新赋值(它们也有 inplace 参数,但本课统一用重新赋值);② 缺失值默认排在最后(升序时),可用 na_position='first' 挪到最前;③ 多列排序时 ascending 传列表,长度要和 by 的列数一致;④ 值相同的行,排序后默认保持它们原来的相对顺序(稳定排序),所以“值相等但顺序看起来没变”是正常的。sort_index() 按行列标签排、sort_values(by=...) 按某一列的值排;ascending 控制升降,多列排序传列表;axis=1 时按列排;缺失值位置用 na_position 控制,排序默认返回新表。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 行,字段相同、问题类型相同,只是行数少、输出看得清)。这份数据里刻意“埋”了缺失值、重复值和异常值——第五节的数据预处理正好拿它开刀。
课件 8.2 把一次完整的数据分析拆成五步。记住这五步,比记住任何一个函数都重要:它决定了你遇到问题时该往哪一步找答案。
read_excel() / read_csv() 读进 DataFrame,也就是 8.3 节。这五步是有先后、也要能回头的。课件特别强调第 3 步:“如果数据本身存在异常或者不符合分析的要求,那么即使采用最先进的数据分析方法,所得到的结果也是错误的。”这就是数据分析里的“垃圾进,垃圾出”(Garbage In, Garbage Out)。下图把五步和本课的小节对应关系一次画清楚:
下面这段代码把五步在 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 元
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、再分别读回来:
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
真实文件常常“第一行是标题、第二行才是列名”“第一列是编号、不该当数据列”。这些都能在读取时用参数一次解决,不用读完再改:
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 管表头。能读的时候顺便解决的,就别留到读完再改。CSV(Comma-Separated Values,逗号分隔值)是最“轻”的数据格式:纯文本,一行一条记录,字段之间用逗号隔开。它的优点是任何软件都能打开、体积极小;缺点是没有任何类型信息——数字、日期读进来都是字符串,要靠 Pandas 去猜。
read_csv() 和 read_table() 是一对孪生兄弟,参数几乎一样,只有一个关键区别:read_csv 默认分隔符是逗号 ',',read_table 默认分隔符是 Tab 键 '\t'。读 .csv 用前者,读制表符分隔的 .txt 用后者;如果分隔符既不是逗号也不是 Tab,就给它一个 sep=。
先拿标准商品表(4.3 节那张 7 行商品表)走一个“写出去 → 读回来”的来回。注意导出时写了 index=False,读回来才有 5 列而不是 6 列:
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',结果完全一样:
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
read_csv() 读进来的每一列都要靠 Pandas 推断——整数列推断成 int64,带小数点的推断成 float64,日期推断不出来,默认还是字符串(本页统一用 parse_dates=['订单日期'] 直接指定,或者读完用 pd.to_datetime() 转换)。这也解释了为什么 12 行数据里 数量 列有一个空值,整列就变成 float64:整数列里一旦混进 NaN,Pandas 只能改用浮点数装它。read_csv() 默认逗号、read_table() 默认 Tab,其他分隔符用 sep=;读进来的都是 DataFrame。CSV 是“纯文本”,类型靠推断,日期列要自己指定。实际拿到的数据文件,很少长得像教科书那样规整:有的没有表头、有的表头跟数据粘在一起、有的只要其中几列、有的一个文件里塞了三张表。这一节把导入时最常用的五个参数排一遍,记住它们的一句话用途就够了:
| 参数 | 解决什么问题 | 读进来会怎样 |
|---|---|---|
header=None | 文件第一行就是数据,没有列名 | 列名自动变成 0、1、2…… |
names=[…] | 要给列起中文名,或替换掉原来的列名 | 按顺序用你给的列表当列名 |
index_col=0 | 第一列是编号,想拿它当行索引 | 该列变成行标签,不再是普通数据列 |
usecols=[…] | 只要其中几列,别全读进来 | 只保留指定的列,内存更省、表更清爽 |
encoding='gbk' | 中文文件是按 GBK 存的,直接读会报编码错 | 按指定编码解码,中文正常显示 |
例 8-4 里课件用 index_col=0 把第一列(订单编号)指定成行索引,就是这个参数的用法。下面用一段没有表头的迷你数据,演示 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,而是订单编号:
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() 三件套确认“读对了没有”:行数对不对、列名有没有串位、每列的类型是什么、哪些列有缺失值。
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
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。分析做完了,结果得交出去:交给同事继续加工、交给领导看、或者存成下一次分析的输入。Pandas 的导出和导入是一一对应的:to_excel() 写 Excel,to_csv() 写 CSV。语法是:
to_excel(excel_writer, sheet_name,
columns, header, index)
to_csv(path_or_buf, sep, columns,
header, index)
两个方法共有的关键参数是 index。它的默认是 True,意思是“把行索引也写进去”——于是文件里会凭空多出一列 0 1 2 3(或者没名字的 Unnamed: 0),别人打开会以为那是数据。课件例 8-6 写得很清楚:导出时加 index=False。下面的例子读入 12 行订单、取 3 列、写成一个不带索引的 CSV,再把文件内容原样读出来检查:
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 去掉表头:
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。导入导出这一块,90% 的报错都能归到五类原因。遇到报错先别慌,按下面的顺序排查,一般三步之内就能定位:
FileNotFoundError 是路径问题,UnicodeDecodeError 是编码问题,ParserError 多半是分隔符或表头错位,ModuleNotFoundError: openpyxl 是缺引擎。FileNotFoundError: [Errno 2] No such file or directory: '订单.xlsx'UnicodeDecodeError。加 encoding='gbk' 通常能解决;反过来,别人给你的 UTF-8 文件用 gbk 读,会变成一堆乱码。header=N 把列名行指对,或用 header=None + names 自己起名。index=False)、列名被当成数据(header=False)、工作表名写错(sheet_name)——导出后读回来对一遍 shape,最省心。先看路径错误的典型样子。下面这段代码故意读一个不存在的文件,报错信息会直接把文件名告诉你——这正是排查的起点:
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 去解,第一个中文字就“解不动”了:
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' 写上,中文立刻正常:
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() 造一个临时目录,先写后读、用完即删——这是课程页面最干净的写法:既真实演示了文件读写,又不会在你电脑上留下垃圾文件,更不会因为路径不同而挂掉。
encoding='gbk' 读,会读出“锟斤拷”之类的乱码但不报错;GBK 文件用默认 UTF-8 读,通常直接抛 UnicodeDecodeError。所以报错比乱码好排查——看到乱码,反而不容易发现读错了编码。经验法:Windows 上 Excel 另存的 CSV 大概率是 GBK,程序生成的文件默认 UTF-8。数据清洗四件事:缺失值、重复值、异常值、无意义数据 · 先体检再动手 · dropna / fillna / drop_duplicates 三把手术刀 · 数据加工:astype、str 抽取、dt 提时间
数据读进来了,下一步不是马上算答案,而是先看这份数据能不能用。课件 8.4 说得很直白:数据预处理包括数据清洗和数据加工两部分——数据清洗是发现并处理原始数据里存在的缺失值、重复值、异常值、无意义的数据;数据加工是对原始数据做变换,通过计算、转换、分类、重组,发现更有价值的数据特征。
为什么这一步这么重要?因为“垃圾进,垃圾出”:数据本身有异常,再先进的分析方法算出来的结论也是错的,不但没有参考价值,还会误导决策。这一模块拿订单数据开刀,先认识它身上的“三宗罪”,再一条条处理掉。本模块也是本章考试的重点,例 8-7 到例 8-14 都出自这里。
把 12 行订单数据摊开看,它并不是一张“干净”的表。课件完整数据 310 行里,字段和问题类型与这张精简表相近(以缺失值、异常值为主;完整数据里没有完全重复的行,重复值用这张精简表来演示):
| 订单编号 | 订单日期 | 用户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 |
| 2 | 302003 | 2021-02-01 | 133422 | T恤 | 55.93 | 24.0 | 1342.32 |
| 3 | 302004 | 2021-02-05 | 138462 | 运动服 | 178.5 | 24.0 | 4284.0 |
| 4 | 302005 | 2021-02-05 | 158949 | T恤 | 65.8 | 14.0 | 921.2 |
| 5 | 302006 | 2021-02-08 | 120957 | 卫衣 | 126.5 | 15.0 | 1897.5 |
| 6 | 302006 | 2021-02-08 | 120957 | 卫衣 | 126.5 | 15.0 | 1897.5 |
| 7 | 302008 | 2021-02-12 | 186059 | T恤 | 65.8 | 5.0 | 329.0 |
| 8 | 302009 | 2021-02-15 | 199357 | NaN | NaN | NaN | 540.0 |
| 9 | 302010 | 2021-02-20 | 149590 | 休闲鞋 | 162.0 | 30.0 | 4860.0 |
| 10 | 302011 | 2021-02-25 | 149590 | 运动服 | 178.5 | 0.0 | 0.0 |
| 11 | 302012 | 2021-02-28 | 137401 | 围巾 | 21.6 | 25.0 | 540.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() 看重复、用业务条件数一数异常值——知道自己删掉的是什么、删了多少,才敢删。这一步在真实项目里往往比写代码本身更重要。缺失值就是空值(Null),在 Pandas 里统一显示成 NaN(Not a Number)。课件例 8-7 要查两件事:哪些列有缺失、具体是哪几行。对应的两个方法:
| 方法 | 作用 | 返回 |
|---|---|---|
df.isnull() / df.isna() | 逐格判断是不是缺失值,两个名字完全同义 | 同形状的布尔表(True = 空) |
df.notna() | 反过来判断“不是缺失值” | 同形状的布尔表(True = 不空) |
df.isnull().any() | 每一列里有没有空值 | 按列的一串 True/False |
df.isnull().sum() | 每一列各有几个空值 | 按列的一串整数 |
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 个”还不够,还要把那一行揪出来看看。用布尔索引:先造一个“商品名称是空”的掩码,再拿它去挑行:
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
== None 或 == np.nan 判断空值:NaN 在浮点数里是“非数”,它连自己都不等于自己(np.nan == np.nan 的结果是 False)。所以 df['商品名称'] == None 得到的是一片 False,根本挑不出空行。判断缺失值只认 isnull() / notna() 这两个方法。isnull()(同义 isna())和 notna();.any() 看“有没有”、.sum() 数“有几个”;具体行用 df[df['列'].isnull()] 挑。NaN 不等于它自己,判断空值只认 isnull。发现缺失值之后有两种处理方式:删掉(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() 会把第 9 行(302009)整行删掉,只剩 11 行;how='all' 因为没有任何一行是整行全空,所以一行都不删:
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 列:
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 被替换了。df.dropna(inplace=True) 后直接导出清洗结果,实际项目里建议先另存一份、核对行数变化再覆盖。dropna() 默认 axis=0、how='any',删掉“有空的记录”;how='all' 删“全空的记录”、subset 只盯指定列、thresh 按非空个数删、axis=1 删列。别写 df = df.dropna(inplace=True)。删数据是“减少样本换质量”,如果缺失的只是一两个格子、而这一行别的信息很有价值(比如 302009 的金额 540 元还在),更合适的做法是把它填上。课件给出的语法是 fillna(value, method, axis, inplace, limit),常用的填充策略有三种:
业务上知道“空”代表什么:商品名称填 '未知商品'、数量填 0、备注填“无”。
df.fillna({'数量': 0})
数值列用整列的均值或中位数“猜”一个合理的数,适合分布比较均匀的数据。
df['数量'].fillna(df['数量'].mean())
用上一行的值补(ffill),适合按时间顺序记录、相邻记录往往相似的数据。
df.ffill()
第一种:按列给固定值。这里给“商品名称”填“未知商品”,给“单价”“数量”填 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=['订单日期'])
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,所以算出来的均值本身不受缺失值影响:
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 会把上一行的值“抄”到空位上:
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
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') 抄过来是跑不通的。isnull().sum() 确认真的填干净了,别让某一列因为类型不匹配没填上。fillna() 三招——固定值(按列传字典)、均值/中位数(数值列常用)、前向填充(df.ffill())。pandas 3 没有 method= 参数了;填什么值要按业务口径定,单价不能填 0。异常值一般指数据采集错误,或超出正常范围、不合逻辑的数据。它最麻烦的地方在于:缺失值和重复值都能用现成方法查,异常值却往往要你自己定义规则——课件 8.4.2 里商家认为“单价大于 150 的商品一次订购数量超过 25 件”是异常,这就是一条业务规则。
订单数据里有两类异常:
查找异常值靠条件查询 + 布尔索引,两个条件用 & 连起来,每个条件都要加小括号(不加括号的报错下一节会专门演示):
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,再一次性删掉:
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) 一次性把整列“裁剪”到区间内:
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]
to_excel 备份),万一删错了还找得回来。(df['单价'] > 150) & (df['数量'] > 25),括号不能少);处理有两种——drop(index=err.index) 删除、loc 赋值或 clip 替换。规则由业务定,删改前先备份。重复值指不同记录在同一个字段上有相同的取值;通常把“所有字段值都相同”的记录视为重复记录。订单数据里第 6、7 行就是一对完全重复的 302006:订单编号、日期、用户、商品、单价、数量、金额全一样。
课件给出两个方法,一个用来查、一个用来删:
返回布尔序列:True = 这条是重复记录。 subset:按哪些列判断,默认全部列。 keep:'first' 默认 / 'last' / False。
按同样的规则删掉重复行。 keep='first':保留第一次出现的; keep='last':保留最后一次出现的; keep=False:所有重复的全部删掉。
keep 的三种取值决定了“留哪一条”,下面这张图把三种结果摆在一起:
先用 duplicated(keep=False) 把“所有重复记录”都标出来(课件例 8-11 的第一步),再对比三种 keep 标记出来的数量:
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 会把两条都删掉:
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
subset=['订单编号'] 判重往往比全字段判重更符合业务;而导出前要去掉重复,则常用全部字段,避免把两笔真实订单误删。duplicated() 查重复、drop_duplicates() 删重复;keep 三种取值——first 留第一条、last 留最后一条、False 全删;subset 指定按哪些列判重。同一个业务问题,判重口径不同,删掉的行数就不同。课件把这一节标为“其它处理(考试不要求)”,但实际做数据分析时非常常用——它属于“数据加工”:把原始字段变成更适合分析的新字段。三件小事:
astype() 把整数列变成字符串列(例 8-12);.str[0:2] 从用户 ID 里抽出前两位当地区编码(例 8-13);dt.year / dt.month / dt.day / dt.isocalendar().week 从日期里取出年、月、日、周次(例 8-14)。用户 ID 是 6 位数字,前两位代表地区。先 astype('str') 转成字符串,再用 .str[0:2] 切片抽取(注意:不转字符串直接切整数列会报错——整数没有 .str 访问器):
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 要统计每种商品每周的销量,第一步就是加一列“周次”:
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[行][列] 两个方括号,第一个管“要哪些行”(切片、条件、索引),第二个管“要哪些列”(列名、列名列表)。理解了这个结构,后面所有写法都是它的变体。
最基础的三种查询方式,课件分别给了三个例子:
| 需求 | 写法 | 对应例子 |
|---|---|---|
| 从某个位置开始取几行 | 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],规则完全一样:
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 上没有“列”的概念了:
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[行号, 列号] 两个维度都只认位置。
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
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。方括号里给切片 = 选行,给列名 = 选列。行切片只能按“第几行”取,真正的查询是按条件取——“金额大于 4000 的订单”“日期是 2 月 28 日的订单”。做法分两步:先让比较运算生成一列 True / False(叫布尔掩码),再把这列掩码塞进方括号里挑行。课件例 8-19 到 8-21 都是这个套路。
比较运算符就是 Python 那六个:==(等于)、!=(不等于)、>、>=、<、<=。注意判断相等是 ==,不是 =;字符串和日期都能直接比较,日期还可以直接写 '2021-02-28' 这样的字符串,Pandas 会自动转换。
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' 都能直接写:
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.金额 >= 5000,是因为 310 行的完整数据里金额最大 5355,5000 以上确实有记录;本页 12 行精简数据最大才 4860,照抄 5000 会筛出空表。所以这里用 4000。拿到一份新数据,先 describe() 看最大最小值,再决定阈值——这是比记住某个数字更重要的习惯。df[掩码] 挑行;六个比较运算符照常写,字符串和日期都能直接比较。阈值按数据范围定,别照抄课件里的数字。一个条件不够用时,就把多个条件连起来:& 表示“并且”(两个都要满足),| 表示“或者”(满足一个就行),~ 表示“取反”(满足条件的不要)。注意不能写 and / or / not——那是 Python 判断单个真假用的,对一列布尔值会直接报错。
课件例 8-22 查“订购数量超过 25 的卫衣”,例 8-23 查“金额超过 4500、或者是 2 月 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=['订单日期'])
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 行精简数据里恰好没有
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。看报错、理解为什么,比背“要加括号”更管用:
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['订单日期'] 这种“数字和日期按位或”的怪东西——结果不是报错,就是算出完全错误的表。宁可多打十对括号,也不要少打一对。mask1 = df['金额'] > 2000、mask2 = df['商品名称'] == '运动服',再写 df[mask1 & mask2];还可以先 print(mask1.sum(), mask2.sum()) 看看每个条件各筛掉多少行,哪一步筛空了立刻能发现。&(且)、|(或)、~(非),不能用 and / or / not;每个条件必须加小括号,否则 & | ~ 会先算,直接 TypeError;条件多就拆成中间变量,先看每步命中几行。“在某个区间内”和“属于某几个值”这两个需求太常见了,Pandas 各给了一个方法,比写两个条件再 & 起来更短:
s.between(下限, 上限):判断数值是否落在区间内,默认两端都包含。课件例 8-20 查“订购数量在 25—30 范围内”,就是 df['数量'].between(25, 30)。s.isin([值1, 值2, …]):判断是否属于给定的集合,参数必须是列表。课件例 8-21 查“围巾和运动服的订单”,就是 df['商品名称'].isin(['围巾', '运动服'])。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 行
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(25, 30) 等价于 (x >= 25) & (x <= 30),isin(['围巾', '运动服']) 等价于 (x == '围巾') | (x == '运动服'),它们返回的都是一列布尔掩码,用法完全一样。区间开闭用 inclusive 调('both' 默认 / 'left' / 'right' / 'neither');isin 的参数必须是列表或集合,写成 isin('围巾') 会报错。between(下限, 上限)(默认两端都含,inclusive 可调),集合用 isin([…])(参数必须是列表);两者都只是布尔掩码的简便写法,最终还是要塞进 df[掩码] 里挑行。“金额最大的 10 条”“按数量从小到大排”——查询经常和排序绑在一起用。课件给了三个例子:例 8-24 用 nlargest(10, '金额') 取最大 10 条;例 8-25、8-26 用 sort_values 排序;例 8-27 先筛后排。
nlargest(n, 列) 是“取前 n 大”的专用方法,比排序再取头 n 行更直接,也快得多:
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 就是“金额降序、金额相同时日期升序”:
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,再按金额降序”。数据量大的时候,先筛再排也更省时间:
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(n, 列) / nsmallest(n, 列),它们是专门优化过的,数据量大时快很多;要“整张表按某列排好序”、或者要按多列不同方向排,用 sort_values。另外排序默认不改原表,要保留结果就赋值给新变量:sorted_df = df.sort_values(...)。nlargest(n, 列);排序用 sort_values(by=[…], ascending=[…]) 实现多列多方向;查询的常见组合是先筛选、再排序,结果赋值给新变量,原表不动。同一个查询,往往有好几种写法。课件里出现的写法,加上推荐的写法,对照着记最清楚:
| 需求 | 写法 | 说明 |
|---|---|---|
| 取整行、整列 | 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]['标记'] = '大单'。这行代码不会报错,但也不会生效——原表里根本不会出现“标记”列。原因是第一个方括号返回的已经是原表的一个副本,你对副本加列,原表当然不知道。
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 行
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 列),它刻意留着缺失值、重复值和异常值——正好用来看清“分组、透视之前为什么必须先清洗”。
描述统计是最快的一次“数据体检”:不看明细,只看几个能代表整列的数——总量(sum)、条数(count)、平均(mean)、最值(max / min)、离散程度(std)。这些方法都挂在 DataFrame 或 Series 上,一行代码一个指标,返回的是标量(单个数字)或一个短的 Series(多列时每列一个数)。
| 方法 | 算的是什么 | 返回什么 | 订单数据上的写法 |
|---|---|---|---|
sum() | 求和 | 单个数值 | df['金额'].sum() |
count() | 非空值的个数 | 单个整数 | df['订单编号'].count() |
mean() | 算术平均 | 单个数值 | df['金额'].mean() |
max() / min() | 最大 / 最小 | 单列→标量;多列→Series | df[['数量','金额']].max() |
std() | 标准差(越大越分散) | 单个数值 | df['金额'].std() |
describe() | 一次给出 count / mean / std / min / 四分位 / max | 8 行的 Series(多列时是表) | df[['单价','数量','金额']].describe() |
先看【例 8-28】中最基本的几句。注意一个细节:这些函数默认跳过缺失值(skipna=True),所以 count() 数的是“非空个数”,比行数少。这份订单数据 12 行,商品名称 只有 11 个非空——少了的那一行是第 9 条记录(订单 302009,商品名称、单价、数量都为空,但金额 540.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('订购总金额:', 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() 放在一起看。
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 节要处理它。
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()。描述统计回答“多少、多大”,频数统计回答另一个问题:“哪一类最多、一共几类、每类占多少”。它面对的是离散的类别(商品名称、产地、用户 ID),而不是连续的金额。三个方法分工明确:
normalize=True 把次数换成占比dropna=False 把 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('各商品的订单记录数:')
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。
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.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)。理解这三步,后面所有分组、透视的写法都是它的变体。
先写【例 8-29】的“统计每种商品的订购总金额,再按金额降序”。这里的 as_index=False 很关键:它让 商品名称 留作一列,而不是变成索引,这样后面 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=['订单日期'])
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
df['金额'].sum() 是 18340.72,正好差 540.00。差的这一笔就是订单 302009:它的商品名称是 NaN,而 groupby 默认把分组键为缺失值的行整个丢掉。这就是“先清洗再分析”的最直接理由——不清洗,汇总数就会悄悄少一块,而且不报错。【例 8-30】到【例 8-34】是同一台机器的不同用法,关键在 agg 里放什么:一个字典可以让不同的列用不同的函数,也可以让同一列同时给多个函数(值写列表)。先看按周次的组合统计——周次用 dt.isocalendar().week 从日期里抽出来(8.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=['订单日期'])
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 能把两个分组键都变回普通列,配合多列排序更好读。
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(by, as_index, sort) 只负责拆组,.agg({'列': '函数'}) 负责算,结果默认以分组键为索引;by 可以传一个字段也可以传列表(多字段分组 = 行索引两层);agg 的值是字典时不同列可配不同函数,是列表时该列同时算多个函数(列变两层);分组键为 NaN 的行会被丢掉。分组结果有个别扭的地方:分组键默认变成了行索引,不在列里。这带来两个连锁麻烦——① 想按分组键排序时,它不在 columns 里;② 想给结果改个中文列名时,索引那一层不好改。所以真实分析里,分组之后几乎总要“整形”一下。两种写法:
g = df.groupby('商品名称',
as_index=False).agg({'金额': 'sum'})
# 商品名称 一开始就是普通列
# 后面直接 sort_values('金额')
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 长度对不上会报错。
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 那种两层。
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(新列名=('原列','函数'))。分组统计的分组键是现成的类别列(商品名称、周次)。可现实里很多关键指标是连续值:金额、年龄、分数、时长。连续值没法直接分组——每个值都可能不一样。要分组,得先把它切成几档,这一步叫分区(也叫分箱、离散化),工具是 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——这是分箱最常见的坑。第一段用指定的分区间距(目录里的“指定 bins”),这是业务里最常用的方式——档位边界由业务含义决定(比如“小单 / 中单 / 大单 / 超大单”),不是让 pandas 自己算。切完用 value_counts().sort_index() 统计各档天数,sort_index() 保证按 L1→L4 的顺序输出,而不是按次数多少。
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 天——空档不是错,它只是在告诉你“这段区间真的没人”。
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
cut 给 NaN,统计时被 value_counts() 悄悄丢掉;② 不要用默认的 right=True 还从 0 开始切——[0, 400] 是左开右闭,0 元不在区间里,也会变 NaN。最稳的写法是像本页这样:bins 的首尾把 min 和 max 都包住,并且统一 right=False。pd.cut(x, bins, right, labels) 把连续值切成离散档——bins 传序列是指定间距(推荐),传整数是自动等宽;本页统一 right=False(左闭右开),保证每个值只落一档、0 也能入档;切完用 value_counts().sort_index() 按档位顺序数分布;bins 没包住的值会变 NaN。分组是“按某个字段的值分组”,重采样是它的时间特化版:按时间周期把行重新分到一个个时间段里,再对每段聚合。它和 groupby 的关系可以这么理解——resample ≈ 按时间区间 groupby。区别在于:groupby 按日期分组只能得到“有订单的那 8 天”,resample 能按固定周期(每 7 天、每月)切,哪怕某段没数据也会给你一行。
语法是 resample(rule, axis, closed, label, on):rule 是周期('7D' 表示每 7 天、'ME' 表示每月末);on 指定用哪一列当时间轴(这列必须是 datetime 类型,本例是 订单日期);closed 和 label 控制区间闭合端和结果索引取区间左端还是右端。写法和 groupby 几乎一样:先 resample 再 .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=['订单日期'])
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 天”,两者重合纯属这份数据凑巧。
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'。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'。前面所有统计都只能“压一个维度”:要么按商品压(一个维度),要么按周压(另一个维度)。但真实报表经常要两个维度交叉看——“第 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 回长表。
【例 8-37】是标准的透视:行放周次、列放商品、值放金额、聚合用 sum,再加 margins=True 看总计。注意结果里出现不少 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=['订单日期'])
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 更适合直接给人看。
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
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 的行会被丢弃。concat 合并(axis=0 / axis=1)· merge 连接与四种 how · 连接校验 · 订单数据综合分析流水线 · Pandas 在 AI 数据管线中的位置 · 本章知识地图
这是本章的最后一块拼图。前面七节所有的分析都建立在“一张表”上:读进来、洗干净、查出来、分组算、透视看。可真实项目里数据常常分散在多个文件、多张表里——一月的订单在一个文件、二月的在另一个;订单表里只有商品名称,进价、产地、库存在另一张商品表里。先拼起来,才能分析下去,这个动作就是“合并与连接”。
这一节先用 concat 和 merge 把“拼表”的两类动作讲清,再讲一个很多人忽略的环节——连接校验(拼完行数对不对?),然后把 8.1—8.8 全部串成一条综合分析流水线,最后抬头看 pandas 在整个 AI 数据管线里站在哪个位置,给出一张本章知识地图。
合并(concatenate,简称 concat)是“把两张表的形状拼在一起”,它不需要两张表有公共的键,只要求尺寸对得上。方向由 axis 决定,两个方向对应两种完全不同的业务场景:
语法是 pd.concat(objs, axis, ignore_index):objs 是一个列表(要拼的表放进去,不是一个个当参数传);axis 默认 0;ignore_index 默认 False,设为 True 会丢掉原来的索引、重排成 0~n-1。这个参数【例 8-39】就用了:把两份订单文件(160 行 + 172 行)摞成 332 行,索引重排后再导出 Excel。
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) 再拼最稳。
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)
pd.concat(objs, axis, ignore_index) 把多张表拼在一起,不需要公共键:axis=0(默认)竖向摞行、记录变多、索引会重复(用 ignore_index=True 重排);axis=1 横向拼列、字段变多、按行索引对齐(先 reset_index(drop=True) 更稳)。objs 是列表,写成 pd.concat([df_1, df_2])。合并是“形状对齐”,连接(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 是全节最该记牢的东西,它决定“哪边的键一定保留”:
【例 8-40】的场景很典型:订单表里只有商品名称,想知道每种商品的订购数量和它的进价、产地、库存,就必须连商品表。第一步先用 7.3 节的分组统计出“每种商品的订购总数量”,第二步再 merge。注意 reset_index() 那一步不能省——groupby 之后商品名称是索引,不是列,没法当连接键。
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 行。
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=('_本月', '_上月') 自己起名,可读性高得多。下面用两张小表演示。
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
pd.merge(left, right, how, on, left_on, right_on, suffixes) 按公共键把两张表连接起来:how='inner'(默认)只留两边都有的键、'left' 保左表、'right' 保右表、'outer' 取并集;同名字段用 suffixes 加后缀区分(默认 _x / _y);groupby 之后的表要 reset_index() 才能当连接键。merge 是本章最容易悄悄出错的一步:它不报错,但行数可能已经不是你以为的那个数。原因只有一个——键的重复。连接前先想清楚两边是“一对一”还是“一对多”:
| 关系 | 例子 | 连接后行数 | 风险 |
|---|---|---|---|
| 一对一(1:1) | 订单汇总(每种商品 1 行)⟕ 商品表(每种商品 1 行) | = 左表行数 = 右表行数 | 安全,例 8-40 就是这种 |
| 一对多(1:N) | 一张订单 ⟕ 它的多条明细 | = 每个键的右表行数累加 | 行数变多,属正常“展开” |
| 多对多(N:N) | 两边同一个键都有多行 | = 左行数 × 右行数(笛卡尔积) | 最容易误伤:3 行 × 2 行 = 6 行 |
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 行,多出来的那一行就是这么来的。
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: 商品名称 围巾 ...
df.duplicated(subset=['键']) 或 df['键'].is_unique 查一下;③ NaN 的来源——outer/left/right 连接补出来的 NaN 是“没匹配上”,不是“原数据缺失”,别混为一谈。养成习惯:连接前记下行数,连接后对一次。indicator=True 看每行来源(both / left_only / right_only),用 validate='one_to_one' 让 pandas 帮你断言关系;连接前后核对行数、检查键是否唯一,是数据核对的基本功。到这里,本章的积木已经全部给齐了。最后这一步是把它们按真实项目的顺序串起来——不是学新 API,而是练“一条流水线走到底”。课件最后一页的“Pandas 数据处理流程”就是这个顺序:
顺序不能乱,原因很实在:查询、分组、透视都在数行,如果前面没清洗,后面算出来的每个数都带着“缺失值那一行被丢掉”“重复订单被算两次”“异常订单把均值拉高”的暗伤,而且不会报错。流水线的每一站都要打印一次 shape——这是数据处理的“安全带”:行数对不上,立刻回头找。
这一段用 tempfile.TemporaryDirectory() 造一个临时目录:先把 CSV 文本写进去,再“从文件导入”——这样既演示了真实的“导入”动作,又不会在仓库里留下文件。清洗按 8.4 节的四个动作依次做:去缺失 → 去重复 → 删异常 → 删无意义,每一步都打印 shape 看行数怎么变。
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 改列名。
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 元,洗完才知道它根本不该算进来。
最后一段产出“能给老师/老板看的表”:行是周次、列是商品、值是金额合计,空格子填 0,最后加一行一列合计;然后 to_excel 写进临时目录的 xlsx,再读回来核对 shape 和合计行。这一步是真实工作里最容易漏的——导出顺利不代表内容对,读回来比一比才放心。
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 读回来核对,才算真正完成。学完这一章,很多同学会问:这些数据处理跟 AI 有什么关系?答案是“数据分析是 AI 的前置工序”——模型再强,喂进去的数据也是脏的。工业界流传一句话:“数据和特征决定了机器学习的上限,模型只是逼近这个上限”。而“数据 + 特征”这一段,主力工具就是 pandas。
三个工具的衔接关系可以用一张表说清:pandas 管“人看得懂的表”,NumPy 管“模型看得懂的矩阵”,PyTorch 管“能上 GPU 算的张量”。它们之间转换几乎零成本——df.to_numpy() 一行进 NumPy,torch.from_numpy(X) 一行进 PyTorch(还共享内存)。
| 要做的事 | pandas(DataFrame) | NumPy(ndarray) | PyTorch(Tensor) |
|---|---|---|---|
| 看形状 | df.shape(行, 列) | X.shape | t.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/1 | pd.get_dummies(df, dtype=int) | 手写编码 | F.one_hot |
| 算在哪 | CPU(内存) | CPU(内存) | t.device:cpu / cuda |
第一段演示“DataFrame → 特征矩阵”的标准动作。先造一张 4 行的小表:两个数值特征(单价、数量)加一个类别列(会员等级)——真实项目里这张表有几十万行,道理一样。把数值特征转成 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。
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 数据管线”,拆开看就是这一章的操作串起来的一条流水线。
DataFrame 是训练数据的标准容器——一行一个样本、一列一个特征,这个约定几乎所有机器学习库都默认。数据从磁盘进来,在 pandas 里清洗、拼接、构造特征,再 to_numpy() 变成模型能吃的矩阵,最后 torch.from_numpy(X) 零拷贝上 Tensor、.to('cuda') 进显卡。模型训练那几行代码是“最后一公里”,前面几十行都是 pandas 在干活;把这一章练熟,就是在练 AI 工程师每天真正花时间的那部分。df.to_numpy() 转矩阵、get_dummies 做 one-hot、按列标准化是进模型前的标准三步;数据分析是 AI 的前置工序,这一章的方法在 AI 项目里一个都不会浪费。八节内容、一百多个方法,看起来很多,其实只有三条主线。先把知识地图铺开,再收成三句话。
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'。'ME' 上。数据分析是 AI 的前置工序,这一章练的就是那道工序。8 个面板,改参数点按钮立刻看结果 · 浏览器内 JS 按 pandas 3.0.5 的规则重算,输出已与本机 Python 实测逐字对齐
对应 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 节反复强调的坑。
点上面的按钮试试
对应 2.1—2.5 节,两种最常用的建表方式。嵌套列表:每一行一组数,行内用逗号或空格分隔,行与行之间换行(也可以用分号);列名默认是 0、1、2…,可以在“列名”里自己填,行标签同理。字典:每个键变成一列,每行写成「列名: 值1, 值2, …」,每个键下的值个数必须一样。点按钮看生成的表格,以及 shape / index / columns / dtypes 四件套。注意 pandas 3 里整列都是整数时 dtype 是 int64,一旦混入小数或缺值,那一列就变成 float64。
点上面的按钮试试
对应 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 这种格式。
点上面的按钮试试
对应 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。
点上面的按钮试试
对应 7.3 节。选分组列(商品名称 / 周次)、要聚合的列(金额 / 数量)和聚合函数(sum / mean / max / count),看 groupby 到底算了什么。三个默认行为要记住:结果按分组键升序排列(中文按 Unicode 码位排,不是拼音);分组键是 NaN 的行默认被丢掉(302009 的商品名称为空,按商品名分组时它的金额 540 不计入任何一组,但按周次分组时它属于第 7 周,不会丢);count 只数非空值(数量列少了一个空,计数就可能比金额列小)。
点上面的按钮试试
对应 7.7 节。选行(index)、列(columns)、值(values)、聚合函数(aggfunc)以及是否加合计行列(margins),看透视表怎么把长表“摊”成矩阵。三个要点:aggfunc 默认是 'mean'(不写就是求平均,不是求和,最容易踩的坑);没有数据的格子显示 NaN;默认 dropna=True,整行都是空的行会被整行丢掉(按订单日期做行时,2021-02-15 只有一条商品名称为空的订单,这一天会消失)。加 margins=True 会在最右和最后多出 All 行/列,mean 的合计是对该行/列所有原始值求平均,不是几个格子的平均数再平均。
点上面的按钮试试
对应 8.2—8.3 节。左表是 12 行订单按商品名称 groupby 汇总出来的 5 行,右表是 7 行商品表。选 how,看连接结果和行数怎么变:inner 只留两边都有的键、left 保留左表全部键、right 保留右表全部键、outer 保留两边所有键。重点是行数:订单里出现的 5 个商品在商品表里都有,所以 inner = left = 5 行;商品表多出的“运动鞋”“太阳帽”没有订单,right / outer 是 7 行,这两个商品的金额、数量填 NaN。连接前后一定要看行数,重复键会让行数膨胀(这份数据里没有,但 8.3 节的检查要养成习惯)。
点上面的按钮试试
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 |
把上面的数据、示例代码、作业答案和说明文档打成一个 zip,解压后直接可用。
精简订单数据.csv);课件完整数据 310 行为 订单.xlsx,课后作业与综合练习请用完整数据。若发现文件缺失或代码跑不通,欢迎反馈。
复习用:下面每一条都能自己讲出来,这一章就算过关
Series(带标签一维)、DataFrame(带标签二维)Series = index(标签)+ values(值)s[标签]、s.iloc[位置]、切片、s[[标签1,标签2]]、s[s>=80]pd.date_range(start, end, periods, freq),三选二;freq='ME' 月末index(行标签)、columns(列标签)、values(值矩阵)index= / columns= 可在创建时指定,也可事后赋值shape 形状、dtypes 各列类型、values 是 ndarrayhead(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),依赖 openpyxlread_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([…])nlargest(n, '列');组合排序 sort_values(by=[…], ascending=[…])df.loc[条件, '列'] = 值,不要链式赋值sum / count / mean / max / min / std / mode / value_countsdf.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)inner(默认,交集)、left、right、outer| 现象 / 报错 | 原因 | 正确做法 |
|---|---|---|
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 及更早 |
sales 的数据框对象。要求:① 销量用随机数生成(每种商品都不超过 50,固定随机种子);② 用 pd.date_range 生成 2025 年 1—12 月的时间序列作为行索引;③ 查询 6 月份“化妆品”销售量;④ 查询 5 月和 10 月的销售记录;⑤ 查询“服装”销量 20~35 的记录;⑥ 查询“服装”和“化妆品”销量都超过 30(含)的记录;⑦ 按“日用品”销量降序排序;⑧ 统计 2025 年各商品销售总量;⑨ 统计每个月销售总量。data\订单.xlsx 或 订单_new.xlsx):① 每天的订单记录数量;② 每周的订购总数量和总金额,并保存成 CSV;③ 每周各商品的订单记录数量(pivot_table + aggfunc='count' + margins);④ 第 5 周的订购总数量;⑤ 自选两个分析目标并说明结论。info 检查 → 删缺失 / 去重 / 删异常 → 按商品分组统计 → 建透视表 → 导出 Excel(不带索引)。每一步输出处理前后的 shape,并在报告里解释为什么行数这样变化。提交要求:每题给出代码 + 运行结果;第 3 题的输出文件一并提交;变量名要能读懂,关键步骤写注释。
df.loc['语文', 'zhao'] 和 df.iloc[0, 0] 什么时候结果相同、什么时候不同?pd.date_range(start='2025-01-01', periods=12, freq='ME') 生成几个时间点?第一个和最后一个分别是哪天?read_csv 的 index_col=0、header=None、usecols 各解决什么问题?dropna(how='any') 和 dropna(how='all') 的区别?inplace=True 的坑是什么?df[df.金额 > 3000] 里那个布尔表达式返回什么?为什么能用来“挑行”?groupby('商品名称').agg({'金额': 'sum'}) 和 pivot_table(values='金额', index='商品名称', aggfunc='sum') 结果有什么关系?merge 的 how='inner' 与 how='outer' 保留哪些记录?为什么连接后要核对行数?