文章目录

一、groupby 分组操作详解
- 1. Groupby 的基本原理
- 2. agg 聚合操作
- 3. transform 转换值
- 4. apply
二、pandas 缺失数据处理
- 1. 缺失值类型
- - 1.1 np.nan
  - 1.2 None
  - 1.3 NA 标量
- 2. 缺失值处理
- - 2.1 查看缺失值的情形
  - 2.2 缺失值的判断
  - 2.3 删除缺失值
  - 2.4 缺失值填充

在开始之前，我们需要先把 pandas、numpy 等一些必备的库导入。

import pandas as pd
import numpy as np
from datetime import datetime

一、groupby 分组操作详解

在数据分析中，我们经常会遇到这样的情况：根据某一列（或多列）标签把数据划分为不同的组别，然后再对其进行数据分析。
比如，某网站对注册用户的性别或者年龄等进行分组，从而研究出网站用户的画像（特点）。在 Pandas 中，要完成数据的分组操作，需要使用 groupby() 函数，它和 SQL 的 GROUP BY 操作非常相似。
在划分出来的组（group）上应用一些统计函数，从而达到数据分析的目的，比如对分组数据进行聚合、转换，或者过滤。这个过程主要包含以下三步：
（1）拆分（Spliting）：表示对数据进行分组；
（2）应用（Applying）：对分组数据应用聚合函数，进行相应计算；
（3）合并（Combining）：最后汇总计算结果。
例如，我们模拟生成的 10 个样本数据，代码和数据如下：

company=["A","B","C"]
data=pd.DataFrame({
        "company":[company[x] for x in np.random.randint(0,len(company),10)],
        "salary":np.random.randint(5,50,10),
        "age":np.random.randint(15,50,10)
    }
)
data
#company	salary	age
#0	A	32	18
#1	A	30	29
#2	B	34	38
#3	C	44	37
#4	B	30	31
#5	C	28	19
#6	A	44	26
#7	A	6	34
#8	B	48	18
#9	A	37	33

1. Groupby 的基本原理

在 pandas 中，实现分组操作的代码很简单，仅需一行代码，在这里，将上面的数据集按照 company 字段进行划分：

group = data.groupby("company")
group
#<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001E9B57A3C88>

将上述代码输入 ipython 后，会得到一个 DataFrameGroupBy 对象。
那这个生成的 DataFrameGroupBy 是啥呢？对 data 进行了 groupby 后发生了什么？
ipython 所返回的结果是其内存地址，并不利于直观地理解，为了看看 group 内部究竟是什么，这里把 group 转换成 list 的形式来看一看：

list(group)
#[('A',
#    company  salary  age
#  0       A      32   18
#  1       A      30   29
#  6       A      44   26
#  7       A       6   34
#  9       A      37   33),
# ('B',
#    company  salary  age
#  2       B      34   38
#  4       B      30   31
#  8       B      48   18),
# ('C',
#    company  salary  age
#  3       C      44   37
#  5       C      28   19)]

– 转换成列表的形式后，可以看到，列表由三个元组组成，每个元组中，第一个元素是组别（这里是按照 company 进行分组，所以最后分为了 A,B,C），第二个元素的是对应组别下的 DataFrame，整个过程可以图解如下：

在这里插入图片描述

总结来说，groupby 的过程就是将原有的 DataFrame 按照 groupby 的字段（这里是 company），划分为若干个分组 DataFrame，被分为多少个组就有多少个分组 DataFrame。所以说，在 groupby 之后的一系列操作（如 agg、apply 等），均是基于子 DataFrame 的操作。

2. agg 聚合操作

聚合（Aggregation）操作是 groupby 后非常常见的操作，会写 SQL 的朋友对此应该是非常熟悉了。聚合操作可以用来求和、均值、最大值、最小值等，下面的表格列出了 Pandas 中常见的聚合操作。

函数	用途
min	最小值
max	最大值
sum	求和
mean	均值
median	中位数
std	标准差
var	方差
count	计数

针对样例数据集，如果我们想求不同公司员工的平均年龄和平均薪水，可以按照下方的代码进行：
以 company 进行分组操作，聚合操作选择 mean 平均值。

data.groupby("company").agg('mean')
salary	age
#company		
#A	29.800000	28.0
#B	37.333333	29.0
#C	36.000000	28.0

如果想对针对不同的列求不同的值，比如要计算不同公司员工的平均年龄以及薪水的中位数，可以利用字典进行聚合操作的指定：

data.groupby('company').agg({'salary':'median','age':'mean'})
salary	age
#company		
#A	32	28
#B	34	29
#C	36	28

在这里插入图片描述

3. transform 转换值

在上面的 agg 中，我们学会了如何求不同公司员工的平均薪水，如果现在需要在原数据集中新增一列 avg_salary，代表员工所在的公司的平均薪水（相同公司的员工具有一样的平均薪水），该怎么实现呢？
如果按照正常的步骤来计算，需要先求得不同公司的平均薪水，然后按照员工和公司的对应关系填充到对应的位置，不用 transform 的话，需要使用 to_dict 将表格中的数据转换成字典格式。

avg_salary_dict= data.groupby('company')['salary'].mean().to_dict()
avg_salary_dict
#{'A': 29.8, 'B': 37.333333333333336, 'C': 36.0}

map() 函数可以用于 Series 对象或 DataFrame 对象的一列，接收函数作为或字典对象作为参数，返回经过函数或字典映射处理后的值。

data['avg_salary'] = data['company'].map(avg_salary_dict)
data
#company	salary	age	avg_salary
#0	A	32	18	29.800000
#1	A	30	29	29.800000
#2	B	34	38	37.333333
#3	C	44	37	36.000000
#4	B	30	31	37.333333
#5	C	28	19	36.000000
#6	A	44	26	29.800000
#7	A	6	34	29.800000
#8	B	48	18	37.333333
#9	A	37	33	29.800000

但是，如果我们使用 transform 的话，仅需要一行代码：

data['avg_salary1'] = data.groupby('company')['salary'].transform('mean')
data
#company	salary	age	avg_salary	avg_salary1
#0	A	32	18	29.800000	29.800000
#1	A	30	29	29.800000	29.800000
#2	B	34	38	37.333333	37.333333
#3	C	44	37	36.000000	36.000000
#4	B	30	31	37.333333	37.333333
#5	C	28	19	36.000000	36.000000
#6	A	44	26	29.800000	29.800000
#7	A	6	34	29.800000	29.800000
#8	B	48	18	37.333333	37.333333
#9	A	37	33	29.800000	29.800000

还是以图解的方式来看看进行 groupby 后 transform 的实现过程（为了更直观展示，图中加入了 company 列，实际按照上面的代码只有 salary 列）：

在这里插入图片描述

图中的大方框是 transform 和 agg 所不一样的地方，对 agg 而言，会计算得到 A，B，C 公司对应的均值并直接返回，但对 transform 而言，则会对每一条数据求得相应的结果，同一组内的样本会有相同的值，组内求完均值后会按照原索引的顺序返回结果。

4. apply

它相比 agg 和 transform 而言更加灵活，能够传入任意自定义的函数，实现复杂的数据操作。
对于 groupby 后的 apply，以分组后的子 DataFrame 作为参数传入指定函数的，基本操作单位是 DataFrame。
假设我现在需要获取各个公司年龄最大的员工的数据，该怎么实现呢？可以用以下代码实现：

def get_oldest_staff(x):   
    df = x.sort_values(by = 'age',ascending=True)    
    return df.iloc[-1,:]
oldest_staff = data.groupby('company',as_index=False).apply(get_oldest_staff)
oldest_staff
#company	salary	age	avg_salary	avg_salary1
#company					
#A	A	6	34	29.800000	29.800000
#B	B	34	38	37.333333	37.333333
#C	C	44	37	36.000000	36.000000

这样便得到了每个公司年龄最大的员工的数据，整个流程图解如下：

在这里插入图片描述

虽然说 apply 拥有更大的灵活性，但 apply 的运行效率会比 agg 和 transform 更慢。所以，groupby 之后能用 agg 和 transform 解决的问题还是优先使用这两个方法。

二、pandas 缺失数据处理

在一些数据分析业务中，数据缺失是我们经常遇见的问题，缺失值会导致数据质量的下降，从而影响模型预测的准确性，这对于机器学习和数据挖掘影响尤为严重。因此妥善的处理缺失值能够使模型预测更为准确和有效。
稀疏数据，指的是在数据库或者数据集中存在大量缺失数据或者空值，我们把这样的数据集称为稀疏数据集。稀疏数据不是无效数据，只不过是信息不全而已，只要通过适当的方法就可以变废为宝。
稀疏数据的来源与产生原因有很多种，大致归为以下几种：
（1）由于调查不当产生的稀疏数据。
（2）由于天然限制产生的稀疏数据。
（3）文本挖掘中产生的稀疏数据。

1. 缺失值类型

在 pandas 中，缺失数据显示为 NaN。缺失值有 3 种表示方法：np.nan，None，pd.NA。

1.1 np.nan

缺失值有个特点，它不等于任何值，连自己都不相等。如果用 nan 和任何其它值比较都会返回 nan。

np.nan == np.nan
#False

也正由于这个特点，在数据集读入以后，不论列是什么类型的数据，默认的缺失值全为 np.nan。
因为 nan 在 Numpy 中的类型是浮点，因此整型列会转为浮点；而字符型由于无法转化为浮点型，只能归并为 object 类型（‘O’），原来是浮点型的则类型不变。
我们可以通过代码来观察 np.nan 的数据类型。

type(np.nan)
#float

np.nan 可以将整型列转换为浮点型。

pd.Series([1,np.nan,3]).dtype
#dtype('float64')

除此之外，还要介绍一种针对时间序列的缺失值，它是单独存在的，用 NaT 表示，是 pandas 的内置类型，可以视为时间序列版的 np.nan，也是与自己不相等。
我们先生成最初的数据，三个 20220101。

s_time = pd.Series([pd.Timestamp('20220101')]*3)
s_time
#0   2022-01-01
#1   2022-01-01
#2   2022-01-01
#dtype: datetime64[ns]

将第三个 20220101 设置为 np.nan。

s_time[2] = np.nan
s_time
#0   2022-01-01
#1   2022-01-01
#2          NaT
#dtype: datetime64[ns]

1.2 None

还有一种就是 None，它要比 nan 好那么一点，因为它至少自己与自己相等。

None == None
#True

在传入数值类型后，会自动变为 np.nan。

pd.Series([1,None])
#0    1.0
#1    NaN
#dtype: float64

1.3 NA 标量

pandas1.0 以后的版本中引入了一个专门表示缺失值的标量 pd.NA，它代表空整数、空布尔值、空字符。
对于不同数据类型采取不同的缺失值表示会很乱。pd.NA 就是为了统一而存在的。 pd.NA 的目标是提供一个缺失值指示器，可以在各种数据类型中一致使用（而不是 np.nan、None 或者 NaT 分情况使用）。
我们可以先生成初始数据。

s_new = pd.Series([1, 2], dtype="Int64")
s_new
#0    1
#1    2
#dtype: Int64

我们将第二个数设置为 pd.NA，发现整体的数据类型并没有发生改变。

s_new[1] = pd.NA
s_new
#0       1
#1    <NA>
#dtype: Int64

下面是 pd.NA 的一些常用算术运算和比较运算的示例：

# 加法
print("pd.NA + 1 :\t", pd.NA + 1)

# 乘法
print('"a" * pd.NA:\t', "a" * pd.NA)

# 以下两种其中结果为1
print("pd.NA ** 0 :\t", pd.NA ** 0)
print("1 ** pd.NA:\t", 1 ** pd.NA)

##### 比较运算
print("pd.NA == pd.NA:\t", pd.NA == pd.NA)
print("pd.NA < 2.5:\t", pd.NA < 2.5)

print("np.add(pd.NA, 1):\t", np.add(pd.NA, 1))

2. 缺失值处理

对于缺失值一般有 2 种处理方式，要么删除，要么填充（用某个值代替缺失值）。缺失值一般分 2 种，一种是某一列的数据缺失；另一种是整行数据都缺失，即一个空行。
本次所用到的 Excel 表格内容如下：

在这里插入图片描述

在最开始，我们先对 Excel 表格的内容进行读取。

df = pd.read_excel(r"data\data_test.xlsx")

从结果来看，每一列均有缺失值。这里特别注意，时间日期类型的数据缺失值用 NaT 表示，其他类型的都用 NaN 来表示。

2.1 查看缺失值的情形

我们可以使用 df.info() 来得知数据集各列的数据类型，是否为空值，内存占用情况。

df.info()

从结果来看，省份这一列是 8 non-null，说明省份这一列有 4 个 null 值。同理，时间这一列有 4 个缺失值，指标这一列有 3 个缺失值，城市这一列有 1 个缺失值，区域这一列有 1 个缺失值。

2.2 缺失值的判断

关于缺失值的判断，我们通过使用 isnull() 来判断具体的某个值是否是缺失值，如果是则返回 True，反之则为 False。

df.isnull()

2.3 删除缺失值

我们可以通过 dropna() 函数对缺失值进行删除，其语法模板如下：

df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

其中，axis：{0或’index’，1或’columns’}，默认为 0 确定是否删除了包含缺少值的行或列。
0 或索引表示删除包含缺少值的行；1 或列表示删除包含缺少值的列。
how：{‘any’，‘all’}，默认为 any 确定是否从 DataFrame 中删除行或列,至少存在一个 NA 或所有 NA。
any 表示如果存在任何 NA 值，请删除该行或列；all 表示如果所有值都是 NA，则删除该行或列。
thresh: int 需要至少非 NA 值数据个数。
subset 表示定义在哪些列中查找缺少的值。
inplace 表示是否更改源数据。
我们先生成初始数据，用于后续的操作观察。

df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],
                    "toy": [np.nan, 'Batmobile', 'Bullwhip'],
                    "born": [pd.NaT, pd.Timestamp("1940-04-25"), pd.NaT]})
df
#name	toy	born
#0	Alfred	NaN	NaT
#1	Batman	Batmobile	1940-04-25
#2	Catwoman	Bullwhip	NaT

我们删除至少缺少一个元素的行（axis 默认是行，how 默认是删除至少存在一个）。

df.dropna()
#name	toy	born
#1	Batman	Batmobile	1940-04-25

我们删除至少缺少一个元素的列。

df.dropna(axis='columns')
#name
#0	Alfred
#1	Batman
#2	Catwoman

我们删除缺少所有元素的行。

df.dropna(how='all')
#name	toy	born
#0	Alfred	NaN	NaT
#1	Batman	Batmobile	1940-04-25
#2	Catwoman	Bullwhip	NaT

我们仅保留至少有 2 个非 NA 值的行。

df.dropna(thresh=2)
#name	toy	born
#1	Batman	Batmobile	1940-04-25
#2	Catwoman	Bullwhip	NaT

我们定义在哪些列中查找缺少的值。

df.dropna(subset=['toy'])
#name	toy	born
#1	Batman	Batmobile	1940-04-25
#2	Catwoman	Bullwhip	NaT

我们在同一个变量中保留操作数据（会对初始数据造成影响）。

df.dropna(inplace=True)
df
#name	toy	born
#1	Batman	Batmobile	1940-04-25

2.4 缺失值填充

一般有用 0 填充，用平均值填充，用众数填充（大多数时候用这个），众数是指一组数据中出现次数最多的那个数据，一组数据可以有多个众数，也可以没有众数。
也可以向前填充（用缺失值的上一行对应字段的值填充，比如 D3 单元格缺失，那么就用 D2 单元格的值填充），或者向后填充（与向前填充对应）等方式。
其语法模板如下：

df.fillna(value=None,method=None,axis=None,inplace=False,limit=None,downcast=None)

其参数含义如下：
value表示用于填充的值（例如 0），或者是一个 dict/Series/DataFrame 值，指定每个索引（对于一个系列）或列（对于一个数据帧）使用哪个值。不在 dict/Series/DataFrame 中的值将不会被填充。此值不能是列表。
method 当中，ffill 表示将上一个有效观察值向前传播，bfill 表示将下一个有效观察值向后传播。
axis 表示用于填充缺失值的轴。
inplace 表示是否操作源数据。
limit 表示要向前/向后填充的最大连续 NaN 值数。
我们先设定初始数据。

df = pd.DataFrame([[np.nan, 2, np.nan, 0],[3, 4, np.nan, 1],[np.nan, np.nan, np.nan, np.nan],
[np.nan, 3, np.nan, 4]],columns=list("ABCD"))
df
#A	B	C	D
#0	NaN	2.0	NaN	0.0
#1	3.0	4.0	NaN	1.0
#2	NaN	NaN	NaN	NaN
#3	NaN	3.0	NaN	4.0

我们可以将所有 NaN 元素替换为 0。

df.fillna(0)
#A	B	C	D
#0	0.0	2.0	0.0	0.0
#1	3.0	4.0	0.0	1.0
#2	0.0	0.0	0.0	0.0
#3	0.0	3.0	0.0	4.0

我们可以向前或传播非空值。

df.fillna(method="ffill")
#A	B	C	D
#0	NaN	2.0	NaN	0.0
#1	3.0	4.0	NaN	1.0
#2	3.0	4.0	NaN	1.0
#3	3.0	3.0	NaN	4.0

我们可以向后或传播非空值。

df.fillna(method="bfill")
	A	B	C	D
#0	3.0	2.0	NaN	0.0
#1	3.0	4.0	NaN	1.0
#2	NaN	3.0	NaN	4.0
#3	NaN	3.0	NaN	4.0

我们将列 A、B、C 和 D 中的所有 NaN 元素分别替换为 0、1、2 和 3。

values = {"A": 0, "B": 1, "C": 2, "D": 3}
df.fillna(value=values)
#A	B	C	D
#0	0.0	2.0	2.0	0.0
#1	3.0	4.0	2.0	1.0
#2	0.0	1.0	2.0	3.0
#3	0.0	3.0	2.0	4.0

我们可以只替换每列的第一个 NaN 元素。

df.fillna(0, limit=1)
#A	B	C	D
#0	0.0	2.0	0.0	0.0
#1	3.0	4.0	NaN	1.0
#2	NaN	0.0	NaN	0.0
#3	NaN	3.0	NaN	4.0

当我们使用数据填充时，替换会沿着相同的列名和索引进行。对此，我们生成一个与初始数据具有部分相同的行标签和列标签的数据。

df2 = pd.DataFrame(np.random.rand(4,4), columns=list("ABCE"))
df2
#A	B	C	E
#0	0.475937	0.169003	0.789308	0.772291
#1	0.554005	0.033041	0.732128	0.052256
#2	0.477042	0.375870	0.757475	0.794198
#3	0.912261	0.366646	0.730202	0.231903

我们用 df2 中的数据来填充 df1 中的空缺值。

df.fillna(value=df2)
#     A    B   C    D
#0	0.475937	2.00000	0.789308	0.0
#1	3.000000	4.00000	0.732128	1.0
#2	0.477042	0.37587	0.757475	NaN
#3	0.912261	3.00000	0.730202	4.0