Pandas数据规整 - 转换 - 离散化和面元划分
离散数据和连续数据
- 连续数据：
- 例如：降雨量：0，5， 10， 100
- 例如：年龄：0， 10， 20， 50， 100
- 并不是用数值表示就是连续数据，例如性别用0，1表示，仍然是离散数据
- 离散数据
- 例如：降雨量：晴，小雨，中雨，大雨，暴雨
- 例如：年龄：幼年，少年，青年，中年，老年
离散数据和连续数据的区分方式：
**如果在两个数据之间，可以插入新的数据，数据的应用不会出错，就是连续数据，否则就是离散数据
或者：数据去重的数量，如果太多，就是连续数据，否则就是离散数据（多的定义不好确定）
为什么区分两类数据
不同数据做指标运算时候是不一样的
- 连续数据：可以做运算
- 例如年龄，可以求平均年龄/最大/最小/年龄标准差。。。
- 不能做分组基准（因为太多了）只能做聚合运算
- 离散数据：不能做运算，但可以做计数
- 例如年龄：可以计数每个年龄段有多少人（频次）
- 可以做分组基准
数据分析时，为了方便分析，有时需要将连续数据转为离散数据（离散化，面元划分）
（没有离散数据转连续数据的需求，因为计算出来的指标无意义（如性别计算出1.5））
为了便于分析，连续数据常常被离散化或拆分为“面元”（bin，分组区间）
连续数据离散化：降雨量、年龄、身高这类连续数据，要分析：只能画直方图，无法分组聚合 ，所以可以将连续数据离散化，例如降雨量转为 小雨中雨大雨暴雨，年龄转为 少年青年中年老年，就可以分组聚合
例子：一组年龄数据，将它们划分为不同的年龄组
ages = [18, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32] # 面元区间 bins = [18, 25, 35, 60, 100] cats = pd.cut(ages, bins) type(cats) 总结 返回的是categories对象（划分的面元），可看做一组表示面元名称的字符串 底层含有： 一个codes属性中的年龄数据标签 一个表示不同分类的类型数组
cats.codes # 分组后的数据(下面分组区间的索引) #array([-1, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8) cats.categories # 类型，分组区间 #IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],closed='right',dtype='interval[int64]') # pd.cut结果的面元计数 cats.value_counts() # 统计每个分组区间的数据个数 pd.value_counts(cats)
cut方法：默认是左开右闭区间，不包含起始值，包含结束值
right=False后，左闭右开区间，包含起始值，不包含结束值
cats2 = pd.cut(ages, bins, right=False) cats2.codes cats2.categories
修改面元名称
cat3 = pd.cut(ages, bins) cat3 = pd.cut(ages, bins, labels=False) # 去掉面元名称 cat3 = pd.cut(ages, bins, labels=['少年', '青年', '中年', '老年']) # 自定义面元名称 cat3
不指定面元切分的起始结束值，而是指定面元切分的个数（切成几份），自动计算面元起始结束值
cat4 = pd.cut(ages, 4, precision=2) # 将数据分为4组，限定区间浮点数位数为2 # (61 - 18) / 4 # 18 + 10.75, 28.75 + 10.75, 39.5 + 10.75, 50.25 + 10.75
qcut根据样本分位数进行面元划分
某些数据分布情况cut可能无法使得各个面元含有相同数量的值
qcut使用样本分位数可以得到大小基本相等的面元
cat5 = pd.qcut(ages, 4) cat5 [(17.999, 22.75], (17.999, 22.75], (22.75, 29.0], (22.75, 29.0], (17.999, 22.75], ..., (29.0, 38.0], (38.0, 61.0], (38.0, 61.0], (38.0, 61.0], (29.0, 38.0]] Length: 12 Categories (4, interval[float64]): [(17.999, 22.75] < (22.75, 29.0] < (29.0, 38.0] < (38.0, 61.0]] cat5.value_counts() (17.999, 22.75] 3 (22.75, 29.0] 3 (29.0, 38.0] 3 (38.0, 61.0] 3 # 手输入4分位数，效果一样¶ cat6 = pd.qcut(ages, [0, 0.25, 0.5, 0.75, 1]) cat6.value_counts()
分位数和桶分析
Pandas有一些能根据指定面元或样本分位数将数据拆分成多块的工具（比如cut和qcut）
将这些函数跟groupby结合起来，就能实现对数据集的桶（bucket）或分位数（quantile）分析
age = np.random.normal(25,5,100).astype(np.int)
grade = np.around(np.random.normal(60,10,100), decimals=1)
gender = ['male', 'female'] * 40 + ['male'] * 20
a = pd.DataFrame({'gender': gender, 'age': age, 'grade': grade})
a.head()
gender age grade
0 male 20 72.4
1 female 19 51.8
2 male 22 57.4
3 female 32 65.2
4 male 19 61.4
对数据进行描述性分析
- 出指标：能出多少指标？（十几个）
- 先1列分析，再2列组合分析，再三列组合分析
- 对连续值分析：运算（mean(),求平均值）
- 对离散值分析：计数（size(),频次，个数）
- 可视化
单列分析
# 本班人数 a.shape[0] # 平均分 a.grade.mean() # 平均年龄 a.age.mean() # 最大值最小值 a.age.min(), a.age.max()
二列分析
# 不同性别的人数
a.groupby('gender').size()
a.gender.value_counts()
# 不同性别的平均年龄
a.groupby('gender')['age'].mean()
# 不同性别的平均分
x = a.groupby('gender')['grade'].mean()
x.plot.bar()
结论
因为数据只有1列离散值（可做分组基准），组合计算后指标比较少，也不能做透视表和交叉表
解决方法：将连续值列离散化后继续分析
桶分析（分位数分析）
bins = [5, 10, 15, 20, 25, 30, 35] # 年龄分组
a['age_cut'] = pd.cut(a.age, bins)
a.head()
gender age grade age_cut
0 male 20 72.4 (15, 20]
1 female 19 51.8 (15, 20]
2 male 22 57.4 (20, 25]
3 female 32 65.2 (30, 35]
4 male 19 61.4 (15, 20]
# 不同年龄段的人数
a.age_cut.value_counts()
# 不同年龄段的平均分
a.groupby('age_cut')['grade'].mean()
# 不同年龄段/不同性别的个数差异
# a.groupby('age_cut')['gender'].size() # 错误，求的是年龄段的人数，不是性别人数
# 正确方式：使用交叉表
pd.crosstab(a.age_cut, a.gender)
# 不同年龄段的平均年龄和平均成绩
a.groupby('age_cut').mean()
# 不同年龄段/不同性别的成绩差异
# a.groupby('age_cut')['grade'].mean() # 差一个维度
a.pivot_table('grade', index='age_cut', columns='gender')
桶分析例子2
frame = pd.DataFrame({'data1': np.random.randn(1000), 'data2': np.random.randn(1000)})
frame.head()
data1 data2
0 0.690169 0.334458
1 1.087660 -2.594456
2 0.216865 1.504087
3 0.252574 0.585563
4 -0.495215 0.066818
q = pd.cut(frame.data1, 4)
q.head()
# q是Series类型，不是面元类型类型
type(q)
# q是Series类型，不是面元类型类型
type(q.cat)
q.cat
q.cat.codes
q.cat.categories
q.value_counts()
由cut返回的Categorical对象可直接传递到groupby。我们可以像下面这样对data2列做一些统计计算
传入的q 相当于 frame['data1_cut'] = pd.cut(pd.data1,4)
frame.groupby(q).size()
frame.groupby(q)['data2'].mean()
frame.groupby(q).sum()
使用自定义函数同时计算多个指标,快速综合统计
自定义函数内构建字典或Series数据返回，会输出DataFrame
Pandas数据规整 - 转换 - 离散化和面元划分
离散数据和连续数据
连续数据：
例如：降雨量：0，5， 10， 100
例如：年龄：0， 10， 20， 50， 100
并不是用数值表示就是连续数据，例如性别用0，1表示，仍然是离散数据
离散数据
例如：降雨量：晴，小雨，中雨，大雨，暴雨
例如：年龄：幼年，少年，青年，中年，老年
离散数据和连续数据的区分方式：
**如果在两个数据之间，可以插入新的数据，数据的应用不会出错，就是连续数据，否则就是离散数据
或者：数据去重的数量，如果太多，就是连续数据，否则就是离散数据（多的定义不好确定）
为什么区分两类数据
不同数据做指标运算时候是不一样的
连续数据：可以做运算
例如年龄，可以求平均年龄/最大/最小/年龄标准差。。。
不能做分组基准（因为太多了）只能做聚合运算
离散数据：不能做运算，但可以做计数
例如年龄：可以计数每个年龄段有多少人（频次）
可以做分组基准
数据分析时，为了方便分析，有时需要将连续数据转为离散数据（离散化，面元划分）
（没有离散数据转连续数据的需求，因为计算出来的指标无意义（如性别计算出1.5））
为了便于分析，连续数据常常被离散化或拆分为“面元”（bin，分组区间）
连续数据离散化：降雨量、年龄、身高这类连续数据，要分析：只能画直方图，无法分组聚合 ，所以可以将连续数据离散化，例如降雨量转为 小雨中雨大雨暴雨，年龄转为 少年青年中年老年，就可以分组聚合
import numpy as np
import pandas as pd
例子：一组年龄数据，将它们划分为不同的年龄组
划分为“18到25”、“26到35”、“35到60”以及“60以上”几个面元
# 年龄
ages = [18, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
# 面元区间
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
cats
[NaN, (18.0, 25.0], (18.0, 25.0], (25.0, 35.0], (18.0, 25.0], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25, 35]]
Length: 12
Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]
type(cats)
pandas.core.arrays.categorical.Categorical
返回的是categories对象（划分的面元），可看做一组表示面元名称的字符串
底层含有：
一个codes属性中的年龄数据标签
一个表示不同分类的类型数组
cats.codes # 分组后的数据(下面分组区间的索引)
array([-1, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
cats.categories # 类型，分组区间
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],
closed='right',
dtype='interval[int64]')
cats[1]
Interval(18, 25, closed='right')
# pd.cut结果的面元计数
cats.value_counts() # 统计每个分组区间的数据个数
pd.value_counts(cats)
(18, 25] 4
(35, 60] 3
(25, 35] 3
(60, 100] 1
dtype: int64
cut方法：默认是左开右闭区间，不包含起始值，包含结束值
right=False后，左闭右开区间，包含起始值，不包含结束值
cats2 = pd.cut(ages, bins, right=False)
cats2
[[18, 25), [18, 25), [25, 35), [25, 35), [18, 25), ..., [25, 35), [60, 100), [35, 60), [35, 60), [25, 35)]
Length: 12
Categories (4, interval[int64]): [[18, 25) < [25, 35) < [35, 60) < [60, 100)]
cats2.codes
array([0, 0, 1, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
cats2.categories
IntervalIndex([[18, 25), [25, 35), [35, 60), [60, 100)],
closed='left',
dtype='interval[int64]')
修改面元名称
cat3 = pd.cut(ages, bins)
cat3 = pd.cut(ages, bins, labels=False) # 去掉面元名称
cat3 = pd.cut(ages, bins, labels=['少年', '青年', '中年', '老年']) # 自定义面元名称
cat3
[NaN, 少年, 少年, 青年, 少年, ..., 青年, 老年, 中年, 中年, 青年]
Length: 12
Categories (4, object): [少年 < 青年 < 中年 < 老年]
cat3[1]
'少年'
cat3.codes
array([-1, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
cat3.categories
Index(['少年', '青年', '中年', '老年'], dtype='object')
不指定面元切分的起始结束值，而是指定面元切分的个数（切成几份），自动计算面元起始结束值
cat4 = pd.cut(ages, 4, precision=2) # 将数据分为4组，限定区间浮点数位数为2
cat4
[(17.96, 28.75], (17.96, 28.75], (17.96, 28.75], (17.96, 28.75], (17.96, 28.75], ..., (28.75, 39.5], (50.25, 61.0], (39.5, 50.25], (39.5, 50.25], (28.75, 39.5]]
Length: 12
Categories (4, interval[float64]): [(17.96, 28.75] < (28.75, 39.5] < (39.5, 50.25] < (50.25, 61.0]]
(61 - 18) / 4
10.75
18 + 10.75, 28.75 + 10.75, 39.5 + 10.75, 50.25 + 10.75
(28.75, 39.5, 50.25, 61.0)
cat4.codes
cat4.categories
cat4.value_counts()
pd.value_counts(cat4)
(17.96, 28.75] 6
(28.75, 39.5] 3
(39.5, 50.25] 2
(50.25, 61.0] 1
dtype: int64
qcut根据样本分位数进行面元划分
某些数据分布情况cut可能无法使得各个面元含有相同数量的值
qcut使用样本分位数可以得到大小基本相等的面元
cat5 = pd.qcut(ages, 4)
cat5
[(17.999, 22.75], (17.999, 22.75], (22.75, 29.0], (22.75, 29.0], (17.999, 22.75], ..., (29.0, 38.0], (38.0, 61.0], (38.0, 61.0], (38.0, 61.0], (29.0, 38.0]]
Length: 12
Categories (4, interval[float64]): [(17.999, 22.75] < (22.75, 29.0] < (29.0, 38.0] < (38.0, 61.0]]
cat5.value_counts()
(17.999, 22.75] 3
(22.75, 29.0] 3
(29.0, 38.0] 3
(38.0, 61.0] 3
dtype: int64
手输入4分位数，效果一样
cat6 = pd.qcut(ages, [0, 0.25, 0.5, 0.75, 1])
cat6
[(17.999, 22.75], (17.999, 22.75], (22.75, 29.0], (22.75, 29.0], (17.999, 22.75], ..., (29.0, 38.0], (38.0, 61.0], (38.0, 61.0], (38.0, 61.0], (29.0, 38.0]]
Length: 12
Categories (4, interval[float64]): [(17.999, 22.75] < (22.75, 29.0] < (29.0, 38.0] < (38.0, 61.0]]
cat6.value_counts()
(17.999, 22.75] 3
(22.75, 29.0] 3
(29.0, 38.0] 3
(38.0, 61.0] 3
dtype: int64
cat6.codes
cat6.categories
IntervalIndex([(17.999, 22.75], (22.75, 29.0], (29.0, 38.0], (38.0, 61.0]],
closed='right',
dtype='interval[float64]')
分位数和桶分析
Pandas有一些能根据指定面元或样本分位数将数据拆分成多块的工具（比如cut和qcut）
将这些函数跟groupby结合起来，就能实现对数据集的桶（bucket）或分位数（quantile）分析
例：对下面数据集进行数据分析
gender age grade
male 18 50
female 28 90
female 38 88
male 48 61
。。。 ... ....
age = np.random.normal(25,5,100).astype(np.int)
grade = np.around(np.random.normal(60,10,100), decimals=1)
gender = ['male', 'female'] * 40 + ['male'] * 20
a = pd.DataFrame({'gender': gender, 'age': age, 'grade': grade})
a.head()
gender age grade
0 male 20 72.4
1 female 19 51.8
2 male 22 57.4
3 female 32 65.2
4 male 19 61.4
对数据进行描述性分析
出指标：能出多少指标？（十几个）
先1列分析，再2列组合分析，再三列组合分析
对连续值分析：运算（mean(),求平均值）
对离散值分析：计数（size(),频次，个数）
可视化
# 本班人数
a.shape[0]
100
单列分析
# 平均分
a.grade.mean()
60.644
# 平均年龄
a.age.mean()
24.34
# 最大值最小值
a.age.min(), a.age.max()
(10, 35)
2列分析
# 不同性别的人数
a.groupby('gender').size()
a.gender.value_counts()
male 60
female 40
Name: gender, dtype: int64
# 不同性别的平均年龄
a.groupby('gender')['age'].mean()
gender
female 24.425000
male 24.283333
Name: age, dtype: float64
# 不同性别的平均分
x = a.groupby('gender')['grade'].mean()
x
gender
female 60.53
male 60.72
Name: grade, dtype: float64
x.plot.bar()
<matplotlib.axes._subplots.AxesSubplot at 0x20609e00ef0>
x.plot.pie()
<matplotlib.axes._subplots.AxesSubplot at 0x20609e3e630>
因为数据只有1列离散值（可做分组基准），组合计算后指标比较少，也不能做透视表和交叉表
解决方法：将连续值列离散化后继续分析
桶分析（分位数分析）
bins = [5, 10, 15, 20, 25, 30, 35] # 年龄分组
a['age_cut'] = pd.cut(a.age, bins)
a.head()
gender age grade age_cut
0 male 20 72.4 (15, 20]
1 female 19 51.8 (15, 20]
2 male 22 57.4 (20, 25]
3 female 32 65.2 (30, 35]
4 male 19 61.4 (15, 20]
继续出指标
# 不同年龄段的人数
a.age_cut.value_counts()
(20, 25] 40
(25, 30] 25
(15, 20] 22
(30, 35] 12
(5, 10] 1
(10, 15] 0
Name: age_cut, dtype: int64
# 不同年龄段的平均分
a.groupby('age_cut')['grade'].mean()
age_cut
(5, 10] 65.300000
(10, 15] NaN
(15, 20] 60.090909
(20, 25] 60.955000
(25, 30] 60.280000
(30, 35] 60.991667
Name: grade, dtype: float64
3列分析
# 不同年龄段/不同性别的个数差异
# a.groupby('age_cut')['gender'].size() # 错误，求的是年龄段的人数，不是性别人数
# 正确方式：使用交叉表
pd.crosstab(a.age_cut, a.gender)
gender female male
age_cut
(5, 10] 0 1
(15, 20] 7 15
(20, 25] 18 22
(25, 30] 9 16
(30, 35] 6 6
# 不同年龄段的平均年龄和平均成绩
a.groupby('age_cut').mean()
age grade
age_cut
(5, 10] 10.000000 65.300000
(10, 15] NaN NaN
(15, 20] 18.636364 60.090909
(20, 25] 23.350000 60.955000
(25, 30] 27.680000 60.280000
(30, 35] 32.333333 60.991667
# 不同年龄段/不同性别的成绩差异
# a.groupby('age_cut')['grade'].mean() # 差一个维度
a.pivot_table('grade', index='age_cut', columns='gender')
gender female male
age_cut
(5, 10] NaN 65.300000
(15, 20] 58.100000 61.020000
(20, 25] 62.288889 59.863636
(25, 30] 60.588889 60.106250
(30, 35] 58.000000 63.983333
考试成绩离散化后又可以来一波
略
桶分析例子2
frame = pd.DataFrame({'data1': np.random.randn(1000), 'data2': np.random.randn(1000)})
frame.head()
data1 data2
0 0.690169 0.334458
1 1.087660 -2.594456
2 0.216865 1.504087
3 0.252574 0.585563
4 -0.495215 0.066818
q = pd.cut(frame.data1, 4)
q.head()
0 (-0.921, 0.792]
1 (0.792, 2.505]
2 (-0.921, 0.792]
3 (-0.921, 0.792]
4 (-0.921, 0.792]
Name: data1, dtype: category
Categories (4, interval[float64]): [(-2.64, -0.921] < (-0.921, 0.792] < (0.792, 2.505] < (2.505, 4.218]]
# q是Series类型，不是面元类型类型
type(q)
pandas.core.series.Series
# q是Series类型，不是面元类型类型
type(q.cat)
pandas.core.arrays.categorical.CategoricalAccessor
q.cat
q.cat.codes
q.cat.categories
IntervalIndex([(-2.64, -0.921], (-0.921, 0.792], (0.792, 2.505], (2.505, 4.218]],
closed='right',
dtype='interval[float64]')
q.value_counts()
(-0.921, 0.792] 606
(0.792, 2.505] 204
(-2.64, -0.921] 182
(2.505, 4.218] 8
Name: data1, dtype: int64
由cut返回的Categorical对象可直接传递到groupby。我们可以像下面这样对data2列做一些统计计算
frame.describe()
data1 data2
count 1000.000000 1000.000000
mean -0.000793 0.022043
std 0.991748 0.977105
min -2.633535 -3.686072
25% -0.671546 -0.637730
50% -0.044528 0.027742
75% 0.651627 0.705526
max 4.217970 3.391034
frame.groupby(q).size()
frame.groupby(q)['data2'].mean()
data1
(-2.64, -0.921] 0.071577
(-0.921, 0.792] 0.008308
(0.792, 2.505] 0.023730
(2.505, 4.218] -0.107421
Name: data2, dtype: float64
frame.groupby(q).sum()
data1 data2
data1
(-2.64, -0.921] -256.036639 13.027102
(-0.921, 0.792] -39.514995 5.034517
(0.792, 2.505] 270.916347 4.840899
(2.505, 4.218] 23.842253 -0.859368
使用自定义函数同时计算多个指标,快速综合统计
自定义函数内构建字典或Series数据返回，会输出DataFrame
def aaa(x):
tmp = {
'count': x.count(),
'mean': x.mean(),
'std': x.std(),
'min': x.min(),
'max': x.max(),
}
return pd.Series(tmp)
frame.groupby(q).apply(aaa)
frame.groupby(q)['data2'].apply(aaa)
frame.groupby(q)['data2'].apply(aaa).unstack()
x = frame.groupby(q)['data2'].apply(aaa).unstack().T
# x.loc['count', '-2.64, -0.921'] # 分类值做索引，不能被直接输入查询
x.loc['count', x.columns.values[0]]
计算指标/哑变量（了解）
一种常用于统计建模或机器学习的转换方式是：将分类变量（categorical variable）转换为 哑变量、指标矩阵（虚拟变量，独热（one-hot）编码变量）
如果DataFrame的某一列含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1和0）
pandas有一个get_dummies函数可以实现该功能
独热编码的作用：将不能计算的字符串转为可以计算的数值（表格，或矩阵）
字符串：'一个对统计应用有用的方法：结合get_dummies和如cut之类的离散化函数'
[统计,应用,有用,方法,结合,离散化,函数]
将人能识别的字符串，转为计算机能计算的数值
- 最简单的方法：例如性别数据，[男, 女]转为[0, 1]
- 缺点：转后数值是分大小的，原值则不分，不很精确
- 独热编码方法：
- [1,1,1,1,1,1,1]
- 列表内有7个词，每个词出现的位置为1， 其他位置为0
- 统计：[1,0,0,0,0,0,0]
- 方法：[0,0,0,1,0,0,0]
- 词向量。。。
df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'], 'data1': range(6)})
手动转为独热编码
[a,b,c]
[1,1,1]
a: [1,0,0]
b: [0,1,0]
c：[0,0,1]
[b,b,a,c,a,b]
b:[1,1,0,0,0,1]
a:[0,0,1,0,1,0]
pd.get_dummies(df.key)
# 合并两个表格
dummies = pd.get_dummies(df.key, prefix='key')
df.join(dummies) # 按索引合并
例子：将一组数据转为哑变量
# 生成随机数据
np.random.seed(12345)
values = np.random.rand(10)
values
array([0.92961609, 0.31637555, 0.18391881, 0.20456028, 0.56772503,
0.5955447 , 0.96451452, 0.6531771 , 0.74890664, 0.65356987])
# 面元划分
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
x = pd.cut(values, bins)
pd.get_dummies(x)