Python-100-Days 深入浅出 pandas(三):数据重塑、数据清洗与预处理实战
Python-100-Days 深入浅出 pandas(三):数据重塑、数据清洗与预处理实战
本文是 Python-100-Days 项目「深入浅出 pandas」系列的第三篇,对应 Day66-80/74.深入浅出pandas-3.md。在完成数据加载之后,数据分析工作流的下一个关键环节就是数据重塑与数据清洗:把分散在多个来源的数据按需拼接、连接,把数据中的缺失值、重复值、异常值处理妥当,并对日期时间、字符串、连续数值等字段做必要的预处理。读完本文,你将掌握
concat/merge两种数据整合方式、dropna/fillna/drop_duplicates/replace等清洗方法、Z-score 与 IQR 两种异常值检测算法,以及日期拆解、正则提取、哑变量编码、分箱离散化等预处理技术,并看到这些操作在本仓库配套 Jupyter Notebook(day04.ipynb)中的真实落地代码。
正态分布与 3σ 法则示意图
一、数据重塑:拼接与连接
在做数据分析时,原始数据往往不止来自一个地方。例如在上一章的例子中,我们从关系型数据库中读取了三张表,得到多个 DataFrame 对象,但实际工作常常需要把它们整合到一起。这类把数据从“分散”变为“聚合”的操作,统称为数据重塑,最核心的两个函数是 concat 与 merge。
1. 用 concat 拼接结构相同的数据
emp_df 和 emp2_df 都是员工数据,且数据结构完全一致,此时可以用 pandas 提供的 concat 函数实现两个或多个 DataFrame 的纵向拼接:
all_emp_df = pd.concat([emp_df, emp2_df])
输出(拼接后的完整员工表):
ename job mgr sal comm dno
eno
1359 胡一刀 销售员 3344.0 1800 200.0 30
2056 乔峰 分析师 7800.0 5000 1500.0 20
3088 李莫愁 设计师 2056.0 3500 800.0 20
3211 张无忌 程序员 2056.0 3200 NaN 20
3233 丘处机 程序员 2056.0 3400 NaN 20
3244 欧阳锋 程序员 3088.0 3200 NaN 20
3251 张翠山 程序员 2056.0 4000 NaN 20
3344 黄蓉 销售主管 7800.0 3000 800.0 30
3577 杨过 会计 5566.0 2200 NaN 10
3588 朱九真 会计 5566.0 2500 NaN 10
4466 苗人凤 销售员 3344.0 2500 NaN 30
5234 郭靖 出纳 5566.0 2000 NaN 10
5566 宋远桥 会计师 7800.0 4000 1000.0 10
7800 张三丰 总裁 NaN 9000 1200.0 20
9500 张三丰 总裁 NaN 50000 8000.0 20
9600 王大锤 程序员 9800.0 8000 600.0 20
9700 张三丰 总裁 NaN 60000 6000.0 20
9800 骆昊 架构师 7800.0 30000 5000.0 20
9900 陈小刀 分析师 9800.0 10000 1200.0 20
concat 的语义类似于 SQL 中的 UNION:它把多个结构相同的 DataFrame 沿 0 轴(行)堆叠起来。在 day04.ipynb 中,这一操作有对应的源码实现与输出验证:
# 拼接两个DataFrame - union
all_emp_df = pd.concat([emp_df1, emp_df2])
all_emp_df.shape
该 Notebook 还给出了一个非常贴近真实业务的实战练习:res/jobs 目录下存放了北京、成都、广州、杭州、南京、上海、深圳、武汉、西安等多个城市的招聘数据 CSV(见 jobs 目录),它们的字段结构完全一致,可以一次性批量读取并拼接成一个总表:
import os
dfs = [pd.read_csv(os.path.join('res/jobs', filename))
for filename in os.listdir('res/jobs')
if filename.endswith('.csv')]
pd.concat(dfs, ignore_index=True).to_csv('res/all_jobs.csv', index=False)
这里 ignore_index=True 会让拼接后的结果重新生成连续的整数索引,避免多个子表行号重叠;to_csv 则把拼接结果落盘为新的 CSV 文件。这也是“从多来源加载结构相同的数据 → 拼接整合”这一典型诉求的标准解法。
2. 用 merge 连接事实表与维度表
拼接解决的是“数据结构相同”的数据,而 merge 解决的是“字段互为外键”的数据——它更接近 SQL 中的表连接,可以用于连接事实表和维度表,为后续“按维度分组再做聚合”打下基础(这一点在 Notebook 的注释中写得很清楚:连表 - 连接事实表和维度表 - 用维度把数据分组然后再做聚合)。
concat 之后,all_emp_df 的行索引还是员工编号 eno。为了把员工表和部门表合并到一张表,先使用 reset_index 方法重置索引,让 eno 不再是索引而变成一个普通列:
all_emp_df.reset_index(inplace=True)
reset_index 的 inplace=True 表示重置索引的操作直接在 all_emp_df 上执行,而不是返回修改后的新对象。接下来通过 merge 函数合并数据(也可以调用 DataFrame 对象的 merge 方法,效果完全相同):
pd.merge(all_emp_df, dept_df, how='inner', on='dno')
输出(员工表与部门表按 dno 内连接的结果):
eno ename job mgr sal comm dno dname dloc
0 1359 胡一刀 销售员 3344.0 1800 200.0 30 销售部 重庆
1 3344 黄蓉 销售主管 7800.0 3000 800.0 30 销售部 重庆
2 4466 苗人凤 销售员 3344.0 2500 NaN 30 销售部 重庆
3 2056 乔峰 分析师 7800.0 5000 1500.0 20 研发部 成都
4 3088 李莫愁 设计师 2056.0 3500 800.0 20 研发部 成都
5 3211 张无忌 程序员 2056.0 3200 NaN 20 研发部 成都
6 3233 丘处机 程序员 2056.0 3400 NaN 20 研发部 成都
7 3244 欧阳锋 程序员 3088.0 3200 NaN 20 研发部 成都
8 3251 张翠山 程序员 2056.0 4000 NaN 20 研发部 成都
9 7800 张三丰 总裁 NaN 9000 1200.0 20 研发部 成都
10 9500 张三丰 总裁 NaN 50000 8000.0 20 研发部 成都
11 9600 王大锤 程序员 9800.0 8000 600.0 20 研发部 成都
12 9700 张三丰 总裁 NaN 60000 6000.0 20 研发部 成都
13 9800 骆昊 架构师 7800.0 30000 5000.0 20 研发部 成都
14 9900 陈小刀 分析师 9800.0 10000 1200.0 20 研发部 成都
15 3577 杨过 会计 5566.0 2200 NaN 10 会计部 北京
16 3588 朱九真 会计 5566.0 2500 NaN 10 会计部 北京
17 5234 郭靖 出纳 5566.0 2000 NaN 10 会计部 北京
18 5566 宋远桥 会计师 7800.0 4000 1000.0 10 会计部 北京
merge 函数的第一个参数代表合并的左表,第二个参数代表合并的右表,有 SQL 编程经验的同学对这两个词会感到非常亲切。和数据库中的表连接一样:
how参数代表合并方式,有left(左外连接)、right(右外连接)、inner(内连接)、outer(全外连接)四个选项,默认值是inner;on参数代表基于哪个列合并,相当于 SQL 中的连接条件;- 如果左右两表对应的连接列列名不同,可以用
left_on和right_on参数取代on参数分别指定。
在 day04.ipynb 中,merge 的用法被精炼地总结为两行注释:
# 连接两个DataFrame(内连接、左外连接、右外连接、全外连接)- join
# how - 连表方式 - inner、left、right、outer
# on - 基于哪个字段连表 - left_on、right_on
all_emp_df = pd.merge(all_emp_df, dept_df, how='inner', on='dno')
3. how 参数与连接方向:一个值得思考的例子
如果对上面的代码稍作修改,把 how 参数改成 'right':
pd.merge(all_emp_df, dept_df, how='right', on='dno')
运行结果会比之前多出下面一行:
19 NaN NaN NaN NaN NaN NaN 40 运维部 深圳
原因是 how='right' 代表右外连接,右表 dept_df 中的全部数据都会被保留;而 all_emp_df 中并没有编号为 40 部门的员工,所以对应的位置都被填入了空值 NaN。读者可以自行推导 how='left' 和 how='outer' 的输出差异,这正是理解连接方向最好的练习。
二、数据清洗
通常我们从 Excel、CSV 或数据库获取到的数据并不完美,可能因系统或人为原因混入重复值或异常值,也可能在某些字段上存在缺失值;此外,DataFrame 中的数据还可能存在格式不统一、量纲不统一等各种问题。因此在开始数据分析之前,对数据进行清洗格外重要。清洗工作主要围绕三类问题展开:缺失值、重复值、异常值。
1. 缺失值的甄别
可以使用 DataFrame 对象的 isnull 或 isna 方法来找出数据表中的缺失值(两者完全等价):
emp_df.isnull()
或者
emp_df.isna()
输出(每个位置是否为缺失值,comm 列与 mgr 列有 True):
ename job mgr sal comm dno
eno
1359 False False False False False False
2056 False False False False False False
3088 False False False False False False
3211 False False False False True False
3233 False False False False True False
3244 False False False False True False
3251 False False False False True False
3344 False False False False False False
3577 False False False False True False
3588 False False False False True False
4466 False False False False True False
5234 False False False False True False
5566 False False False False False False
7800 False False True False False False
相对应的,notnull 和 notna 方法会把非空的值标记为 True。在 day04.ipynb 中,这些方法既可以作用于整个 DataFrame,也可以单独作用于某一列,还常常配合 value_counts() 统计缺失值的分布:
all_emp_df.isna()
all_emp_df['comm'].isnull()
all_emp_df['comm'].notnull()
all_emp_df['comm'].notna().value_counts()
2. 删除缺失值:dropna
如果想删除这些缺失值,可以使用 DataFrame 对象的 dropna 方法。axis 参数可以指定沿 0 轴(删除整行)还是 1 轴(删除整列)删除,默认沿 0 轴:
emp_df.dropna()
输出(只保留所有字段都非空的行):
ename job mgr sal comm dno
eno
1359 胡一刀 销售员 3344.0 1800 200.0 30
2056 乔峰 架构师 7800.0 5000 1500.0 20
3088 李莫愁 设计师 2056.0 3500 800.0 20
3344 黄蓉 销售主管 7800.0 3000 800.0 30
5566 宋远桥 会计师 7800.0 4000 1000.0 10
如果要沿 1 轴删除(即删掉存在空值的列),可以使用:
emp_df.dropna(axis=1)
输出(mgr、comm 两列因为含有空值被整列删除):
ename job sal dno
eno
1359 胡一刀 销售员 1800 30
2056 乔峰 架构师 5000 20
3088 李莫愁 设计师 3500 20
3211 张无忌 程序员 3200 20
3233 丘处机 程序员 3400 20
3244 欧阳锋 程序员 3200 20
3251 张翠山 程序员 4000 20
3344 黄蓉 销售主管 3000 30
3577 杨过 会计 2200 10
3588 朱九真 会计 2500 10
4466 苗人凤 销售员 2500 30
5234 郭靖 出纳 2000 10
5566 宋远桥 会计师 4000 10
7800 张三丰 总裁 9000 20
注意:
DataFrame对象的很多方法都有一个名为inplace的参数,默认值为False,表示操作不会修改原来的DataFrame对象,而是把处理后的结果通过一个新的DataFrame返回;如果设为True,操作就会在原来的对象上直接修改,方法的返回值为None。简单说,上面的dropna()并没有修改emp_df,而是返回了一个新的DataFrame对象。
3. 填充缺失值:fillna
在某些特定场景下,删除行/列会损失大量信息,这时更合适的做法是对空值进行填充,对应的方法是 fillna。填充时可以:
- 使用指定的值(通过
value参数指定); - 使用表格中前一个单元格的值填充(
method='ffill',forward fill); - 使用后一个单元格的值填充(
method='bfill',backward fill)。
例如:
emp_df.fillna(value=0)
输出(所有空值都被替换为 0.0):
ename job mgr sal comm dno
eno
1359 胡一刀 销售员 3344.0 1800 200.0 30
2056 乔峰 分析师 7800.0 5000 1500.0 20
3088 李莫愁 设计师 2056.0 3500 800.0 20
3211 张无忌 程序员 2056.0 3200 0.0 20
3233 丘处机 程序员 2056.0 3400 0.0 20
3244 欧阳锋 程序员 3088.0 3200 0.0 20
3251 张翠山 程序员 2056.0 4000 0.0 20
3344 黄蓉 销售主管 7800.0 3000 800.0 30
3577 杨过 会计 5566.0 2200 0.0 10
3588 朱九真 会计 5566.0 2500 0.0 10
4466 苗人凤 销售员 3344.0 2500 0.0 30
5234 郭靖 出纳 5566.0 2000 0.0 10
5566 宋远桥 会计师 7800.0 4000 1000.0 10
7800 张三丰 总裁 0.0 9000 1200.0 20
注意:填充值如何选择是一个值得探讨的话题。实际工作中,可能会使用某种统计量(如均值、众数等)进行填充,或者使用某种插值法(如随机插值法、拉格朗日插值法等)进行填充,甚至可能通过回归模型、贝叶斯模型等对缺失数据建模填充。在 day04.ipynb 中,还有两个常用的工程化处理手法:一是
fillna(0).astype('i8'),先把空值填 0 再转成整型,避免后续计算出现浮点;二是用一个不可能出现的哨兵值(如-1)填充再转整型,保留“该值原本缺失”的信息:
all_emp_df.comm.fillna(0).astype('i8')
all_emp_df['mgr'] = all_emp_df.mgr.fillna(-1).astype('i8')
4. 重复值的甄别与删除
接下来,先给部门表添加两行数据,让名为“研发部”和“销售部”的部门各出现两次:
dept_df.loc[50] = {'dname': '研发部', 'dloc': '上海'}
dept_df.loc[60] = {'dname': '销售部', 'dloc': '长沙'}
dept_df
输出:
dname dloc
dno
10 会计部 北京
20 研发部 成都
30 销售部 重庆
40 运维部 天津
50 研发部 上海
60 销售部 长沙
现在数据表里有重复数据了,可以通过 duplicated 方法判断是否存在重复值。该方法在不指定参数时默认判断行索引是否重复,也可以指定根据部门名称 dname 判断部门是否重复:
dept_df.duplicated('dname')
输出:
dno
10 False
20 False
30 False
40 False
50 True
60 True
dtype: bool
可以看到,50 和 60 两个部门从部门名称上看是重复的。如果要删除重复值,使用 drop_duplicates 方法,keep 参数可以控制遇到重复值时保留第一项('first')、保留最后一项('last'),或者多个重复项全部删除(False)。
dept_df.drop_duplicates('dname')
输出(默认 keep='first',保留首次出现的行):
dname dloc
dno
10 会计部 北京
20 研发部 成都
30 销售部 重庆
40 运维部 天津
将 keep 参数修改为 'last':
dept_df.drop_duplicates('dname', keep='last')
输出(保留最后出现的行,即上海研发部、长沙销售部):
dname dloc
dno
10 会计部 北京
40 运维部 天津
50 研发部 上海
60 销售部 长沙
duplicated 与 drop_duplicates 同样支持按多个字段联合判重。例如认定“ename 和 job”两个字段完全相同的就是重复员工数据:
all_emp_df.drop_duplicates(['ename', 'job'], inplace=True)
说明:上面的
drop_duplicates添加了inplace=True,不会返回新的DataFrame,而是在原对象上直接删除,大家可以查看all_emp_df确认是否已移除重复的员工数据。
在 day04.ipynb 中,这一套流程有完整对照:
# 甄别重复值
all_emp_df.ename.duplicated()
all_emp_df.duplicated(['ename', 'job'])
# 删除重复值
# keep='first' - 默认值,重复元素保留第一项 - 'last' / False
all_emp_df.drop_duplicates(['ename', 'job'], keep='last', inplace=True)
此外,Notebook 里还演示了在实际爬虫数据中按唯一标识(URI)去重的场景:jobs_df.drop_duplicates('uri', inplace=True),这正是重复值处理最典型的应用——网络采集的数据往往因重复抓取而存在大量重复记录。
5. 异常值的检测与处理
异常值在统计学上的全称是疑似异常值,也称作离群点(outlier),对异常值的分析也称作离群点分析。异常值是指样本中出现的“极端值”,数据值看起来异常大或异常小,分布明显偏离其余的观测值。实际工作中,有些异常值可能是由系统或人为原因造成的,但有些异常值却不是——它们能够重复且稳定地出现,属于正常的极端值,例如很多游戏产品中头部玩家的数据往往都是离群的极端值。所以我们既不能忽视异常值的存在,也不能简单地把异常值从数据分析中剔除。重视异常值的出现、分析其产生的原因,常常成为发现问题进而改进决策的契机。
异常值的检测有 Z-score 方法、IQR 方法、DBSCAN 聚类、孤立森林等,这里重点介绍前两种。
Z-score 方法(3σ 法则)
如果数据服从正态分布,依据 3σ 法则,异常值被定义为与平均值的偏差超过三倍标准差的值。在正态分布下,距离平均值 3σ 之外的值出现的概率为 ,属于小概率事件。如果数据不服从正态分布,那么可以用“远离均值的多少倍标准差”来描述,这里的倍数就是 Z-score。Z-score 以标准差为单位去度量某一原始分数偏离平均值的距离:
通常把 的数据点视为离群点。Z-score 的阈值需要根据经验和实际情况决定,下面的代码给出了如何通过 Z-score 方法检测异常值:
def detect_outliers_zscore(data, threshold=3):
avg_value = np.mean(data)
std_value = np.std(data)
z_score = np.abs((data - avg_value) / std_value)
return data[z_score > threshold]
IQR 方法
IQR(Inter-Quartile Range)代表四分位距离,即上四分位数(Q3)和下四分位数(Q1)的差值。通常情况下,可以认为小于 或大于 的就是异常值,这种检测方法也是箱线图默认使用的方法。下面的代码给出了 IQR 方法的实现:
def detect_outliers_iqr(data, whis=1.5):
q1, q3 = np.quantile(data, [0.25, 0.75])
iqr = q3 - q1
lower, upper = q1 - whis * iqr, q3 + whis * iqr
return data[(data < lower) | (data > upper)]
在 day04.ipynb 中,这两个检测函数都有对应实现,并且演示了更加完整的处理链路,包括调参检测、按行索引删除离群行、用 np.in1d 定位离群位置、以及用 np.place 把离群点替换为中位数:
# 异常值的甄别 - 数值判定法(data < Q1 - 1.5 * IQR 或者 data > Q3 + 1.5 * IQR)
def find_outliers_by_iqr(data, whis=1.5):
q1, q3 = np.quantile(data, [0.25, 0.75])
iqr = q3 - q1
return data[(data < q1 - whis * iqr) | (data > q3 + whis * iqr)]
find_outliers_by_iqr(temp)
find_outliers_by_iqr(temp, whis=3)
# zscore判定法(三西格玛法则 ---> 68-95-99.7法则)
def find_outliers_by_zscore(data, mul=3):
mu, sigma = np.mean(data), np.std(data)
zscore = (data - mu) / sigma
return data[np.abs(zscore) > mul]
find_outliers_by_zscore(temp)
find_outliers_by_zscore(temp, mul=2)
# 根据离群点的行索引删除行
df6.drop(index=find_outliers_by_zscore(df6.直接成本).index)
# 替换离群点
np.in1d(temp, find_outliers_by_zscore(temp, mul=2))
np.place(temp, np.in1d(temp, find_outliers_by_zscore(temp, mul=2)), med_value)
注意 IQR 公式中的 whis 参数与箱线图 whis 参数同源,默认 1.5,调大该值(如 3)会放宽异常值的判定边界。
删除与替换异常值
如果要删除异常值,可以使用 DataFrame 对象的 drop 方法,该方法可以根据行索引或列索引删除指定的行或列。例如认为月薪低于 2000 或高于 8000 的是员工表中的异常值:
emp_df.drop(emp_df[(emp_df.sal > 8000) | (emp_df.sal < 2000)].index)
如果要替换掉异常值,可以通过给单元格赋值的方式实现,也可以使用 replace 方法把指定值替换掉。例如把月薪 1800 和 9000 替换为月薪平均值,把补贴 800 替换为 1000:
avg_sal = np.mean(emp_df.sal).astype(int)
emp_df.replace({'sal': [1800, 9000], 'comm': 800}, {'sal': avg_sal, 'comm': 1000})
replace 的用法非常灵活:第一层字典的键是列名、值是“待替换的旧值”,第二层字典的键是列名、值是“替换后的新值”;同一列可以传入列表一次替换多个值。
三、数据预处理
对数据进行预处理是一个很大的话题,包含对数据的拆解、变换、归约、离散化等操作。
1. 数据拆解:日期时间维度的提取
如果数据表中的某个字段是时间日期,我们通常需要从年、季度、月、日、星期、小时、分钟等维度对其拆解。如果时间日期是用字符串表示的,可以先通过 pandas 的 to_datetime 函数将其处理成时间日期类型。
在下面的例子中,先读取 Excel 文件获取一组销售数据,其中第一列就是销售日期(示例数据文件为 2020年销售数据.xlsx,存放在 data 目录中,与文档示例同名;实际运行时需根据本地路径调整):
sales_df = pd.read_excel(
'data/2020年销售数据.xlsx',
usecols=['销售日期', '销售区域', '销售渠道', '品牌', '销售额']
)
sales_df.info()
输出:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1945 entries, 0 to 1944
Data columns (total 5 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 销售日期 1945 non-null datetime64[ns]
1 销售区域 1945 non-null object
2 销售渠道 1945 non-null object
3 品牌 1945 non-null object
4 销售额 1945 non-null int64
dtypes: datetime64ns, int64(1), object(3)
memory usage: 76.1+ KB
然后通过 Series.dt 属性把销售日期拆解为“月份”“季度”“星期”三个新列:
sales_df['月份'] = sales_df['销售日期'].dt.month
sales_df['季度'] = sales_df['销售日期'].dt.quarter
sales_df['星期'] = sales_df['销售日期'].dt.weekday
sales_df
输出(节选):
销售日期 销售区域 销售渠道 品牌 销售额 月份 季度 星期
0 2020-01-01 上海 拼多多 八匹马 8217 1 1 2
1 2020-01-01 上海 抖音 八匹马 6351 1 1 2
2 2020-01-01 上海 天猫 八匹马 14365 1 1 2
3 2020-01-01 上海 天猫 八匹马 2366 1 1 2
4 2020-01-01 上海 天猫 皮皮虾 15189 1 1 2
... ... ... ... ... ... ... ... ...
1940 2020-12-30 北京 京东 花花姑娘 6994 12 4 2
1941 2020-12-30 福建 实体 八匹马 7663 12 4 2
1942 2020-12-31 福建 实体 花花姑娘 14795 12 4 3
1943 2020-12-31 福建 抖音 八匹马 3481 12 4 3
1944 2020-12-31 福建 天猫 八匹马 2673 12 4 3
在上面的代码中,通过日期时间类型 Series 对象的 dt 属性获得一个访问日期时间的对象,通过该对象的 year、month、quarter、hour 等属性,就可以获取年、月、季度、小时等时间信息,获取到的仍然是一个 Series 对象(包含一组时间信息),所以也常把这个 dt 属性称为日期时间向量。
在 day04.ipynb 中,时间拆解还与业务计算结合得更深:先用 pd.to_datetime 把字符串日期标准化,再通过 dt.days 把出生年月换算成年龄,并进一步用 pd.cut 划分年龄段:
# 将字符串处理成日期
settle_df['出生年月'] = pd.to_datetime(settle_df['出生年月'])
# 将生日换算成年龄
settle_df['年龄'] = (pd.to_datetime('2023-01-01') - settle_df.出生年月).dt.days // 365
# 添加季度、月份列
df6['季度'] = df6['销售日期'].dt.quarter
df6['月份'] = df6['销售日期'].dt.month
2. 字符串数据的处理:筛选、提取与变换
先从一个指定的 CSV 文件中读取某招聘网站的招聘数据(本仓库的 jobs 目录 提供了结构类似的多城市招聘数据 CSV,可供替换练习):
jobs_df = pd.read_csv(
'data/某招聘网站招聘数据.csv',
usecols=['city', 'companyFullName', 'positionName', 'salary']
)
jobs_df.info()
输出:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3140 entries, 0 to 3139
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 city 3140 non-null object
1 companyFullName 3140 non-null object
2 positionName 3140 non-null object
3 salary 3140 non-null object
dtypes: object(4)
memory usage: 98.2+ KB
查看前 5 条数据:
jobs_df.head()
输出:
city companyFullName positionName salary
0 北京 达疆网络科技(上海)有限公司 数据分析岗 15k-30k
1 北京 北京音娱时光科技有限公司 数据分析 10k-18k
2 北京 北京千喜鹤餐饮管理有限公司 数据分析 20k-30k
3 北京 吉林省海生电子商务有限公司 数据分析 33k-50k
4 北京 韦博网讯科技(北京)有限公司 数据分析 10k-15k
上面的数据表一共有 3140 条数据,但并非所有职位都是“数据分析”岗位。如果要筛选出数据分析岗位,需要检查 positionName 字段是否包含“数据分析”关键词,即模糊匹配。由于该列的 dtype 是字符串,可以通过 str 属性获取对应的字符串向量,然后使用熟悉的字符串方法:
jobs_df = jobs_df[jobs_df.positionName.str.contains('数据分析')]
jobs_df.shape
输出:
(1515, 4)
筛选后还剩 1515 条数据。接下来处理 salary 字段:如果希望统计所有岗位的平均工资或每个城市的平均工资,首先需要把用范围表示的工资处理成中间值。这里通过正则表达式捕获组,从字符串中抽取出工资的下限和上限两组数字:
jobs_df.salary.str.extract(r'(\d+)[kK]?-(\d+)[kK]?')
输出(节选):
0 1
0 15 30
1 10 18
2 20 30
3 33 50
4 10 15
... ... ...
3065 8 10
3069 6 10
3070 2 4
3071 6 12
3088 8 12
需要提醒的是,抽取出来的两列都是字符串类型,需要先转换成 int 类型才能计算平均值。转换可以使用 DataFrame 对象的 applymap 方法,该方法的参数是一个函数,函数会作用于 DataFrame 的每个元素;完成转换后,再用 apply 方法把每行的上下限处理成中间值,apply 通过 axis 参数指定作用于行还是列:
temp_df = jobs_df.salary.str.extract(r'(\d+)[kK]?-(\d+)[kK]?').applymap(int)
temp_df.apply(np.mean, axis=1)
输出(每条记录对应的工资中间值):
0 22.5
1 14.0
2 25.0
3 41.5
4 12.5
...
3065 9.0
3069 8.0
3070 3.0
3071 9.0
3088 10.0
Length: 1515, dtype: float64
接下来用上面的结果替换掉原来的 salary 列,完整的代码如下:
temp_df = jobs_df.salary.str.extract(r'(\d+)[kK]?-(\d+)[kK]?').applymap(int)
jobs_df['salary'] = temp_df.apply(np.mean, axis=1)
jobs_df.head()
输出:
city companyFullName positionName salary
0 北京 达疆网络科技(上海)有限公司 数据分析岗 22.5
1 北京 北京音娱时光科技有限公司 数据分析 14.0
2 北京 北京千喜鹤餐饮管理有限公司 数据分析 25.0
3 北京 吉林省海生电子商务有限公司 数据分析 41.5
4 北京 韦博网讯科技(北京)有限公司 数据分析 12.5
applymap 和 apply 两个方法在数据预处理时经常用到。Series 对象也有 apply 方法,同样用于数据预处理;而 DataFrame 对象还有一个 transform 方法,也是通过传入的函数对数据进行变换,类似 Series 对象的 map 方法。需要特别强调的是:apply 方法具有归约效果,简单说就是能把较多的数据处理成较少的数据甚至一条数据;而 transform 方法没有归约效果,只能对数据进行变换,原来有多少条数据,处理后还是多少条。
在 day04.ipynb 中,字符串处理管线展示得更为完整,包括正则提取后直接分配成两列、拆分列、正则替换、批量模糊筛选等:
# 通过正则表达式从列中提取信息,并直接转换为整型
jobs_df[['salary_lower', 'salary_upper']] = jobs_df.salary.str.extract(r'(\d+)-(\d+)').astype('i8')
jobs_df['salary'] = (jobs_df.salary_lower + jobs_df.salary_upper) / 2
# 拆分列
jobs_df['city'] = jobs_df.site.str.split(expand=True)[0]
# 字符串正则表达式替换
jobs_df['year'] = jobs_df.year.replace(r'5-10年|10年以上', '5年以上', regex=True)
jobs_df['edu'] = jobs_df.edu.replace(r'中专|高中', '学历不限', regex=True)
jobs_df['edu'] = jobs_df.edu.replace(r'硕士|博士', '研究生', regex=True)
# 统一大小写后做多关键词模糊筛选
jobs_df['job_name'] = jobs_df.job_name.str.lower()
jobs_df = jobs_df[jobs_df.job_name.str.contains('python|数据|产品|运营|data', regex=True)]
3. 字符串变量的类别化处理
如果要对数据进行深度的分析和挖掘,字符串、日期时间这类非数值类型都需要处理成数值,因为非数值类型没有办法计算相关性,也没有办法进行 检验等操作。对于字符串类型,通常可以分为以下三类再分别处理:
- 有序变量(Ordinal Variable):字符串表示的数据有顺序关系,可以对字符串进行序号化处理。
- 分类变量(Categorical Variable)/ 名义变量(Nominal Variable):字符串表示的数据没有大小关系和等级之分,可以使用独热编码处理成哑变量(虚拟变量)矩阵。
- 定距变量(Scale Variable):字符串本质上对应到有大小高低之分、而且可以进行加减运算的数据,只需要把字符串处理成对应的数值即可。
对于第 1 类和第 3 类,可以用上面提到的 apply 或 transform 方法处理,也可以利用 scikit-learn 中的 OrdinalEncoder 处理第 1 类字符串(后续课程会讲到)。对于第 2 类字符串,可以使用 pandas 的 get_dummies() 函数生成哑变量矩阵。先构造一个示例数据:
persons_df = pd.DataFrame(
data={
'姓名': ['关羽', '张飞', '赵云', '马超', '黄忠'],
'职业': ['医生', '医生', '程序员', '画家', '教师'],
'学历': ['研究生', '大专', '研究生', '高中', '本科']
}
)
persons_df
输出:
姓名 职业 学历
0 关羽 医生 研究生
1 张飞 医生 大专
2 赵云 程序员 研究生
3 马超 画家 高中
4 黄忠 教师 本科
把“职业”处理成哑变量矩阵:
pd.get_dummies(persons_df['职业'])
输出:
医生 教师 画家 程序员
0 1 0 0 0
1 1 0 0 0
2 0 0 0 1
3 0 0 1 0
4 0 1 0 0
可以看到,get_dummies 为每个取值生成一列 0/1 指示变量,这正是机器学习建模前对分类特征的标准处理方式。
把“学历”这种有高低等级之分的字符串处理成大小不同的数值(有序变量序号化):
def handle_education(x):
edu_dict = {'高中': 1, '大专': 3, '本科': 5, '研究生': 10}
return edu_dict.get(x, 0)
persons_df['学历'].apply(handle_education)
输出:
0 10
1 3
2 10
3 1
4 5
Name: 学历, dtype: int64
4. 数据离散化:分箱
离散化也叫分箱。如果变量的取值是连续值,那么它有无数种可能的取值,在做数据分组时会非常不方便,此时把连续变量离散化就很重要。之所以叫分箱,是因为可以预先设置一些“箱子”,每个箱子代表数据取值的范围,把连续值分配到不同箱子中,从而完成离散化。
下面的例子读取了 2018 年北京积分落户数据,根据落户积分对数据进行分组。仓库中的 2023年北京积分落户数据.csv 提供了同构的示例数据,字段一致,可替换练习:
luohu_df = pd.read_csv('data/2018年北京积分落户数据.csv', index_col='id')
luohu_df.score.describe()
输出(describe 一次性给出计数、均值、标准差与四分位数等统计量):
count 6019.000000
mean 95.654552
std 4.354445
min 90.750000
25% 92.330000
50% 94.460000
75% 97.750000
max 122.590000
Name: score, dtype: float64
可以看出,落户积分最大值是 122.59,最小值是 90.75。可以构造一个从 90 分到 125 分、每 5 分一组的 7 个箱子,用 pandas 的 cut 函数完成分箱:
bins = np.arange(90, 126, 5)
pd.cut(luohu_df.score, bins, right=False)
说明:
cut函数的right参数默认值为True,表示箱子左开右闭;修改为False可以让箱子的右边界为开区间、左边界为闭区间。
输出:
id
1 [120, 125)
2 [120, 125)
3 [115, 120)
4 [115, 120)
5 [115, 120)
...
6015 [90, 95)
6016 [90, 95)
6017 [90, 95)
6018 [90, 95)
6019 [90, 95)
Name: score, Length: 6019, dtype: category
Categories (7, interval[int64, left]): [[90, 95) < [95, 100) < [100, 105) < [105, 110) < [110, 115) < [115, 120) < [120, 125)]
分箱结果是一个 category 类型的列,区间默认按左闭右开(right=False)展示。在 day04.ipynb 中,cut 还可以配合 labels 参数为每个箱子指定有业务含义的名字,让结果更可读:
# 将年龄划分到年龄段 - 分箱 - 数据桶
settle_df['年龄段'] = pd.cut(
settle_df.年龄,
bins=np.arange(35, 61, 5),
labels=['35~39岁', '40~44岁', '45~49岁', '50~54岁', '55~59岁'],
right=False
)
得到分箱结果后,可以根据分箱结果对数据进行分组,再使用聚合函数对每个组进行统计——这是数据分析中非常常用的操作,将在下一个章节(分组与聚合)中深入介绍。此外,pandas 还提供了 qcut 函数,可以按分位数对数据进行分箱(等频分箱),例如 pd.qcut(data, q=4) 会把数据切成四分位区间,读者可以自行研究它与 cut(等宽分箱)的区别。
小结与实战路径
本文围绕“拿到数据之后怎么办”展开,梳理了 pandas 数据处理的完整链条:
- 数据重塑:结构相同的数据用
concat拼接(可配合ignore_index=True),带外键关系的数据用merge连接(how控制连接方式,on/left_on/right_on指定连接列),为多维度拆解数据做准备; - 数据清洗:用
isna/isnull甄别缺失值,用dropna删除、fillna填充;用duplicated甄别重复值,用drop_duplicates(配合keep)去重;用 Z-score(3σ 法则)或 IQR 方法检测异常值,再用drop删除或replace替换; - 数据预处理:用
dt属性拆解日期时间维度,用str属性做字符串的筛选(str.contains)、提取(str.extract)、拆分与替换,用apply/applymap/transform做逐元素变换,用get_dummies对分类变量做独热编码、用自定义函数对有序变量做序号化,最后用cut/qcut对连续变量做分箱离散化。
本仓库的 Day66-80/code/day04.ipynb 完整收录了本文涉及的全部操作(含 jobs 多城市招聘数据 的批量拼接练习、2020年销售数据.xlsx 的日期拆解、2023年北京积分落户数据.csv 的分箱离散化等),建议读者对照 Notebook 逐单元格运行,亲手验证每个方法的输入输出,再结合 深入浅出 pandas 系列(数据加载与初步检查)和后续的分组聚合章节,构建起完整的数据分析基本功。