数据预处理

数据清洗

数据清洗目的：将脏数据（这里指是对数据分析没有意义、格式非法、不在指定范围的数据）清洗干净，是原数据具有完整性、唯一性、权威性、合法性、一致性等特点。
pandas常见数据清洗：空值和缺失值的处理，重复值的处理，异常值的处理，统一数据格式。

空值和缺失值的处理

空值：数据未知，不适用或将在以后添加数据。None
缺失值：数据集中或某些属性的值是不完整的，产生的原因主要有人为原因和机械原因，机器原因是由于机械故障未能是搜集或存储失败，认为原因是由主观失误或有意隐瞒造成。NaN
使用isnull和notnull函数可以判断数据集中是否存在空值和缺失值，对于缺失数据可以使用dropna()和fillna()方法进行删除和填充

isnull()函数和notnull()函数

isnull()函数和notnull()函数的语法格式如下：
pandas.isnull(obj) 存在NaN或者None的话则就将在这个位置标记True，否则标记False
pandas.notnull(obj) 存在NaN或者None的话则就将在这个位置标记False，否则标记True

ser_obj = Series([1,NaN,None]) #notnull
pd.notnull(ser_obj)
0     True
1    False
2    False
dtype: boolpd.isnull(ser_obj)          #isnull
0    False
1     True
2     True
dtype: boolpd.isna(ser_obj)          #isna
0    False
1     True
2     True
dtype: bool

dropna()方法

dropna()的方法是删除含有空值和缺失值的行和列，
dropna(axis=0,how=‘any’,thresh=None,subset=None,inplace=False)
axis:确定过滤行或列，取值可以为

0或index：删除包含缺失值的行，默认为0
1或columns:删除包含缺失值的列

how:

any:默认值，如果存在NaN值，则删除该行或者该列
all：如果所有值都是NaN值，则删除该行或者该列

thresh:表示有效数据量的最小要求，若传入了2，则是要求该行或该列至少有两个非NaN值时将其保留
subset:表示在特定的子集中寻找空值
inplace:表示是否在原数据上操作，如果设置为True，则表示修改源数据，如果设置为False，则表示修改原数据的副本，返回新的数据

df_obj = pd.DataFrame({'类别':['小说','随笔散文','青春文字','传记'],'书名':[NaN,'《皮囊》','《旅行结束时》','《老舍自传》'],'作者':['老舍',None,'张琪新','老舍']})
df_obj类别    书名  作者
0   小说  NaN 老舍
1   随笔散文    《皮囊》    None
2   青春文字    《旅行结束时》 张琪新
3   传记  《老舍自传》  老舍
df_obj.dropna()
类别  书名  作者
2   青春文字    《旅行结束时》 张琪新
3   传记  《老舍自传》  老舍

填充空值和缺失值

填充空值和缺失值的方法有很多，比如人工填写，特殊值填写，热卡填充等，在pd中的fillna()方法可以实现填充空值或缺失值
fillna(
value=None,
method=None,
axis=None,
inplace=False,
limit=None,
downcast=None,
**kwargs,
)
value:用于填充的数值
method：表示填充方式，默认值为None，另外还有以下取值

ffill：将最后一个有效数据向后传播，也就是说用缺失值前面以得一个值代替缺失值
bfill：将最后一个有效值向前传播，也就是说用缺失值后面的一个值代替缺失值
limit：可以连续填充的最大数量，默认为None

df_obj = pd.DataFrame({'A':[1.0,2.0,3.0,NaN],'B':[NaN,2.0,NaN,6.0],'C':['a',7,8,9],'D':[NaN,2.0,3.0,NaN]})
df_obj                 #查看原数据
A   B   C   D
0   1.0 NaN a   NaN
1   2.0 2.0 7   2.0
2   3.0 NaN 8   3.0
3   NaN 6.0 9   NaNdf_obj.fillna(66)        #使用66进行填充
A   B   C   D
0   1.0 66.0    a   66.0
1   2.0 2.0 7   2.0
2   3.0 66.0    8   3.0
3   66.0    6.0 9   66.0df_obj.fillna({'A':5.0,'B':8.0,'C':99}) #传入字典根据索引进行填充
A   B   C   D
0   1.0 8.0 a   NaN
1   2.0 2.0 7   2.0
2   3.0 8.0 8   3.0
3   5.0 6.0 9   NaNdf_obj.fillna(method='bfill')    #使用缺失值后边一个的数据进行填充
A   B   C   D
0   1.0 2.0 a   2.0
1   2.0 2.0 7   2.0
2   3.0 6.0 8   3.0
3   NaN 6.0 9   NaN

重复值的处理

当数据出先重复值的时候，大部分时间都需要把重复值进行删除，pandas提供了两个方法专门处理数据中的重复值，分别为duplicated()和drop_duplicates()方法
duplicated:确认是否有缺失值
drop_duplicates:删除缺失值

使用duplicated()方法处理重复值

duplicated(subset=None,keep=‘first’)

subset:用于识别重复的列标或列标签序列，默认识别所有的列标签
keep:删除重复项并保留第一次出现的项，取值可以为first，last，False（first:从前向后查找，除了第一次出现外，其余相同的标记为重复，last：从后向前查找，除了最后一次出现外，其余相同的标记为重复，False：所有相同的都标为重复）

df_obj = pd.DataFrame({'id':[1,2,3,4,4,5],'name':['小鸣','小月月','彭艳','硫化','硫化','周华'],'age':[18,18,29,58,58,36],'height':[180,180,185,175,175,178],'gender':['女','女','男','男','男','男']})
df_objid    name    age height  gender
0   1   小鸣  18  180 女
1   2   小月月 18  180 女
2   3   彭艳  29  185 男
3   4   硫化  58  175 男
4   4   硫化  58  175 男
5   5   周华  36  178 男
df_obj.duplicated()  #从前向后查找重复值
0    False
1    False
2    False
3    False
4     True
5    False
dtype: bool

drop_duplicates(subset=None, keep=‘first’, inplace=False)

subset:用于识别重复的列标或列标签序列，默认识别所有的列标签
keep:删除重复项并保留第一次出现的项，取值可以为first，last，False（first:从前向后查找，除了第一次出现外，其余相同的标记为重复，last：从后向前查找，除了最后一次出现外，其余相同的标记为重复，False：所有相同的都标为重复）
inplace:参数接受一个布尔类型的值，表示是否替换原来的数据，默认为False

df_obj.drop_duplicates()id   name    age height  gender
0   1   小鸣  18  180      女
1   2   小月月 18  180      女
2   3   彭艳  29  185      男
3   4   硫化  58  175      男
5   5   周华  36  178      男

异常值处理

基于拉依达原理：它是指假设一组数据只含有随机误差，对其进行计算处理得到的标准偏差，按一定概率确定一个区间，凡是超过这个区间的误差都是粗大误差，在此误差范围内的数据都应予以剔除

我的理解就是数据要在(u-3a,u+3a)之间 u是平均值 a是标准差

定义一个基于本原理的函数，用来检测一组数据中是否有异常值

arr = pd.DataFrame({'A':[1,1,2,3,4,5,6,4,8,5,1,4,52,],'B':[1,2,2,6,8,321,5,4,8,1,3,5,1]})
arrA    B
0   1   1
1   1   2
2   2   2
3   3   6
4   4   8
5   5   321
6   6   5
7   4   4
8   8   8
9   5   1
10  1   3
11  4   5
12  52  1import numpy as np
def three_sigma(arr):#求平均值mean_value = arr.mean()#求标准差std_value = arr.std()#位于(u-3a,u+3a)的值为正常值，不在这个区间的就是异常值，一旦发现异常值就标记为True，否则标记为Falserule = ((mean_value-3 * std_value>arr)) | ((mean_value+3*std_value<arr))#返回异常值的索引index = np.arange(arr.shape[0])[rule]#获取异常数据outrange = arr.iloc[index]return outrangethree_sigma(arr['B'])
5    321
Name: B, dtype: int64

基于箱型图检测异常值

在箱型图中异常值通常被定义为小于Ql+1.5QR或大于Qu+1.5IQR的值

Ql被称为下四分位数，表示全部观察四分之一的数据取值比他小
Qu成为上四分位数，表示全部观察值中有四分之一的数据取值比他小
IQR成为四分位数间距，是上四分位数Qu与下四分位数Ql之差，其间包含了全部观察值的一半

为了能从箱型图中查看异常值，Pandas中提供给了一个boxplot()方法，专门用于绘制箱型图

df = pd.DataFrame({'A':[1,2,3,4],'B':[2,2,3,2],'C':[1,4,7,4],'D':[1,2,30,4]})
df.boxplot(column=['A','B','C','D'])

检测出异常值后，通常采用的方式有以下四种

直接将含有异常值的记录删除
用具体的值进行替换，可用前后两个观测值的平均值修正该异常值
不处理，直接在具有异常值的数据集上进行统计分析
视为缺失值，利用缺失值的处理方法处理该异常值

修改异常值可以用replace()方法进行替换，既可以替换单个数据，也可以多个数据执行批量替换操作
replace(
to_replace=None,
value=None,
inplace=False,
limit=None,
regex=False,
method=‘pad’,
)
to_replace:表示查找被替换值的方式
value：用来替换任何匹配to_replace的值，默认值为None
limit：表示前向或后向填充的最大间隙
regex：接受布尔值或与to_replace相同的类型，默认为False，表示是否将to_replace和value解释为正则表达式
method：ffill向前填充 bfill向后填充

接上边代码中的df
df.replace(to_replace=30,value=2)A    B   C   D
0   1   2   1   1
1   2   2   4   2
2   3   3   7   2
3   4   2   4   4

更改数据类型

使用dtype属性进行查看数据类型

可以在创建对象时指定数据类型

通过astype()方法强行转换数据类型

astype(dtype,compy=True,errors= ‘raise’,**kwargs)（除数字以外的数据会报错）

dtype:表示数据的类型
copy：是否建立副本，默认为True
erroes：错误采取的处理方式，可以取值为raise或ignore，默认为raise，其中raise表示允许引发异常，ignore表示抑制异常

df = pd.DataFrame({'A':['1','2','3','4'],'B':['-1','-2','33','24']})
df = df.astype(dtype='int')
dfA B
0   1   -1
1   2   -2
2   3   33
3   4   24
df.dtypes
A    int32
B    int32
dtype: object

通过to_numeric()函数转换数据类型

to_numeric()函数可以解决astype转换类型时，除数字以外的数据会报错的问题，
pandas.to_numeric(arg,errors=‘raise’,downcast=None)

arg：表示要转换的数据，可以是list tuple Series
erroes：错误采取的处理方式

astype和to_numeric的区别(我自己理解的不喜勿喷)：astype转换类型时需要看原数据的类型，如果原数据是’5.5’这种的数据，在转int类型时会报错

ser_obj = pd.Series(['1.5','5'])
ser_obj
0    1.5
1      5
dtype: objectpd.to_numeric(arg=ser_obj,downcast='integer')
0    1.5
1    5.0
dtype: float64

数据合并

pandas在合并数据集时，常见的操作有轴向堆叠数据、主键合并数据、根据行索引合并数据和合并重叠数据，这些操作各有各的特点。

轴向堆叠数据

concat()函数可以沿着以条轴将多个对象进行堆叠，
pd.concat(
objs,
axis=0,
join=‘outer’,
join_axes=None,
ignore_index=False,
keys=None,
levels=None,
names=None,
verify_integrity=False,
sort=None,
copy=True,
)
axis：表示连接的轴向，可以为0或者1，默认为0
join：表示连接的方式，inner表示内连接，outer表示外连接，默认为外连接
ignore_index:接受布尔值，默认为False，如果设置为True，则表示清楚现在有的索引并重置索引值
keys：接收序列，表示添加最外层索引
levels：用于构建MultIndex的特定级别(唯一值)
names：在设置了keys和level参数后，用于创建分层级别的名称
verify_integerity:检查新的链接轴是否包含重复项，接收布尔值，当设置为True时，如果有重复的轴将会抛出错误，默认为False

内连接所得结果是他们的交集，外连接是他们的并集

横向堆叠和外连接

df1 = pd.DataFrame({'A':['A0','A0','A1'],'B':['B0','B0','B1']})
df2 = pd.DataFrame({'C':['C0','C0','C1','C3'],'D':['D0','D2','D2','D3']})
pd.concat([df1,df2],join='outer',axis=1)A   B   C   D
0   A0  B0  C0  D0
1   A0  B0  C0  D2
2   A1  B1  C1  D2
3   NaN NaN C3  D3

纵向堆叠和内连接

df1 = pd.DataFrame({'A':['A0','A0','A1'],'B':['B0','B0','B1']})
df2 = pd.DataFrame({'B':['C0','C0','C1','C3'],'D':['D0','D2','D2','D3']})
pd.concat([df1,df2],axis=0,join='inner')B
0   B0
1   B0
2   B1
0   C0
1   C0
2   C1
3   C3

主键合并数据

主键合并就是根据一个或多个键将不同的DataFrame对象连接起来，大多数是将两个DataFrame对象中重叠的列作为合并的键，Pandas中提供了用于主键合并的merge(),
pd.merge(
left,
right,
how=‘inner’,
on=None,
left_on=None,
right_on=None,
left_index=False,
right_index=False,
sort=False,
suffixes=(’_x’, ‘_y’),
copy=True,
indicator=False,
validate=None,
)
left：参与合并的左侧DataFrame对象
right：参与合并的右侧的DataFrame对象
how：连接方式，默认为inner，支持以下连接方式

left:使用左侧的DataFrame的键，类似于SQL的左外连接

right：使用右侧的DataFrame的键，类似于SQL的右外连接

outer：使用两个DataFrame所有键，类似于SQL的全连接

inner：使用两个DataFrame键的交集，类似于SQL的内连接

on:用于连接的列名，必须存在于左右两个DataFrame对象中
left_on：以左侧DataFrame作为连接键
right_on：以右侧DataFrame作为连接键
left_index：左侧的行索引用作连接键
right_index：右侧的行索引用作连接键
sort：是否排序，接受布尔值，默认是False
suffixes：用于追加到重叠列名的末尾，默认为(_x,_y)

在使用merge()函数时，默认会使用重叠的列作为合并键，并采用内连接方式合并数据，既取行索引重叠的部分

left = pd.DataFrame({'key':['K0','K1','K2'],'A':['A0','A1','A2'],'B':['B0','B1','B2']})
right = pd.DataFrame({'key':['K0','K1','K2','K3'],'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3']})leftkey   A   B
0   K0  A0  B0
1   K1  A1  B1
2   K2  A2  B2rightkey  C   D
0   K0  C0  D0
1   K1  C1  D1
2   K2  C2  D2
3   K3  C3  D3pd.merge(left,right,on='key')  #通过key来连接
key A   B   C   D
0   K0  A0  B0  C0  D0
1   K1  A1  B1  C1  D1
2   K2  A2  B2  C2  D2

两个主键和并

left = pd.DataFrame({'key':['K0','K1','K2'],'A':['A0','A1','A2'],'B':['B0','B1','B2']})
right = pd.DataFrame({'key':['K0','K1','K2','K3'],'B':['B0','B1','B2','B3'],'D':['D0','D1','D2','D3']})
leftkey A   B
0   K0  A0  B0
1   K1  A1  B1
2   K2  A2  B2rightkey  B   D
0   K0  B0  D0
1   K1  B1  D1
2   K2  B2  D2
3   K3  B3  D3pd.merge(left,right,on=['key','B'])key   A   B   D
0   K0  A0  B0  D0
1   K1  A1  B1  D1
2   K2  A2  B2  D2

内外向连接和轴向堆叠的内外连接时一样的，这里就不演示代码部分了
左连接就是分别按照左边表为基准连接，右连接相反，这里也不演示代码了
即使左右两个表没有重叠的部分也可以强行拼接，只需要将left_index和right_index设置为True即可

left = pd.DataFrame({'A':['A0','A1','A2'],'B':['B0','B1','B2']})
right = pd.DataFrame({'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3']})
pd.merge(left,right,left_index=True,right_index=True)A    B   C   D
0   A0  B0  C0  D0
1   A1  B1  C1  D1
2   A2  B2  C2  D2

根据行索引合并数据

join(other,on=None,how=‘left’,lsuffix=’’,sort=False)

on:用于连接列名
how:可以从{‘left’,‘right’,‘outer’,‘inner’}中任选一个，默认使用left的方式
lsuffix:接受字符串，用于在左侧重叠的列名后添加后缀名
rsuffix:接收字符串，用于在右侧重叠的列名后添加后缀名
sort:接收布尔值，根据连接键对合并的数据进行排序，默认为False

当两张表没有重叠的索引时，可以设置merge()函数的left_index和right_index参数，而对join来说只需要将表名作为参数传入即可，join方法默认使用左连接方式，

left = pd.DataFrame({'A':['A0','A1'],'B':['B0','B1']},index=['a','b'])
right = pd.DataFrame({'C':['C0','C1'],'D':['D0','D1']},index=['c','d'])
left.join(right,how='outer')A    B   C   D
a   A0  B0  NaN NaN
b   A1  B1  NaN NaN
c   NaN NaN C0  D0
d   NaN NaN C1  D1

假设两个表中行索引和列索引重叠，那么当使用join方法进行合并时，使用参数on指定重叠的列名即可

left = pd.DataFrame({'A':['A0','A1','A2'],'B':['B0','B1','B2'],'key':['k0','k1','k2']})
right = pd.DataFrame({'C':['C0','C1','C2'],'D':['D0','D1','D2']},index=['k0','k1','k2'])
left.join(right,on='key')A   B   key C   D
0   A0  B0  k0  C0  D0
1   A1  B1  k1  C1  D1
2   A2  B2  k2  C2  D2

合并重叠数据

当一个DataFrame对象出现了缺失数据，而对于这些缺失数据，我们以往可以使用其他的DataFrame对象进行填充，可以使用combine_first()方法进行填充

需要强调的是，想要用right来填充left数据时，他们必须拥有重叠部分

数据重塑

重塑层次化索引

pandas中重塑层次化索引的方法有两种：stack()和unstack()，前者是将数据的列旋转为行，后者是将数据的行旋转为列

stack():将数据的列索引转换为行索引

DataFrame.stack(level=-1,dropna=True)

level:表示操作内层索引，若设为0，表示操作外层索引，默认为-1

dropna:表示是否将旋转后的缺失值删除，若设为True。则表示自动过滤缺失值，设置为Flase则相反

df = pd.DataFrame({'A':['A0','A1','A2'],'B':['B0','B1','B2']})
df
A   B
0   A0  B0
1   A1  B1
2   A2  B2
result = df.stack()
result
0  A    A0B    B0
1  A    A1B    B1
2  A    A2B    B2
dtype: object

unstack()：将数据行索引转换为类索引

DataFrame.unstack(level = -1,fill_value= None)

level：表示操作内层索引，若设置为0则操作外层索引，默认为-1

fill_value:若产生了缺失值，则可以设置这个参数用来代替NaN

result1 = result.unstack()
result1A    B
0   A0  B0
1   A1  B1
2   A2  B2

轴向旋转

根据给定的行索引或列索引重新组织一个DataFrame对象
DataFrame.pivot(index=None,columns=None,values=None)

index:用于创建新DataFrame对象的行索引，如果未设置，则使用原DataFrame对象的索引

colums:用于创建新DataFrame对象的列索引，如果未设置，则使用原DataFrame对象的索引

values:用于创建新DataFrame对象中的值

df = pd.DataFrame({'商品名称':['荣耀9青春版','小米6x','oppo al','荣耀9青春版','小米6x','oppo al'],'出售日期':['2017.05.25','2017.05.25','2017.05.25','2017.06.18','2017.06.18','2017.06.18'],'价格':['999元','1399元','1399元','800元','1200元','1250元']})
df商品名称  出售日期    价格
0   荣耀9青春版  2017.05.25  999元
1   小米6x    2017.05.25  1399元
2   oppo al 2017.05.25  1399元
3   荣耀9青春版  2017.06.18  800元
4   小米6x    2017.06.18  1200元
5   oppo al 2017.06.18  1250元df.pivot(index='出售日期',columns='商品名称',values='价格') #通过pivot进行轴向旋转
商品名称    oppo al 小米6x    荣耀9青春版
出售日期
2017.05.25  1399元   1399元   999元
2017.06.18  1250元   1200元   800元

数据转换

数据转换是指数据从一种表现形势变为另一种表现形势的过程，具体包括重命名轴索引，离散化和面元划分，计算指标/哑变量。

重命名轴索引

rename():重命名个别列索引或行索引的标签或名称

rename(napper=None,index=None,columns=None,axis=None,copy=True,inplace=False,level=None)

index,columns:表示待转换的行索引和列索引

axis：表示轴名称，可以使用index或columns，也可以使用0或1

copy:表示是否复制底层的数据，默认为Flase

inplace：默认为False，表示返回新的Pandas对象，如果设置为True，则会忽略复制的值

level：表示级别名称，默认为None，对于多级索引，只重命名指定的标签

df = pd.DataFrame({'A':['A0','A1','A2','A3'],   #原数据'B':['B0','B1','B2','B3'],'C':['C0','C1','C2','C3']})
df
A   B   C
0   A0  B0  C0
1   A1  B1  C1
2   A2  B2  C2
3   A3  B3  C3df.rename(columns={'A':'a','B':'b','C':'c'})  #使用rename修改列索引
a   b   c
0   A0  B0  C0
1   A1  B1  C1
2   A2  B2  C2
3   A3  B3  C3df.rename(str.lower,axis='columns')   #使用str内置函数直接变小写
a   b   c
0   A0  B0  C0
1   A1  B1  C1
2   A2  B2  C2
3   A3  B3  C3df.rename(index={0:'a',1:'b'})  #使用rename修改行索引
A   B   C
a   A0  B0  C0
b   A1  B1  C1
2   A2  B2  C2
3   A3  B3  C3

离散化连续数据

有时我们会碰到这样的需求，例如，将有关年龄的数据进行离散化或拆分为’面元’,直白来说就是将年龄分为几个区间，pandas的cut()函数能够实现离散化操作，该函数的语法如下：
pandas.cut(x,bins,right=True,labels=None,retbins=False,precision=3,include_lowest=False,duplicates=‘raise’)

x:表示要分箱的数组，必须是一维的

bins:接收int和序列类型的数据，如果传入的是int类型的值，则表示在x范围内的等宽单元的数量(划分为多少个等间距区)；如果传入的是一个序列，则表示将x划分在指定的序列中，若不在此序列中，则为NaN

right：是否包含右端点，决定区间的开闭，默认为True

labels: 用于生成区间的标签

retbins:是否返回bin

precision:精度，默认保存三位小数

include_lowest：是否包含左端点

cut()函数会返回一个Categorical对象，我们可以看作一组便是面元名称的字符串，它包含了分组数量以及不同分类的名称

ages = [20,22,25,27,21,23,37,31,61,45,32]
bins = [0,18,25,35,60,100]
cuts = pd.cut(ages,bins)
cuts
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (35, 60], (25, 35], (60, 100], (35, 60], (25, 35]]
Length: 11
Categories (5, interval[int64]): [(0, 18] < (18, 25] < (25, 35] < (35, 60] < (60, 100]]
#如果希望左闭右开区间，则可以在调用cut()函数时传入right=Flase进行修改
pd.cut(ages,bins,right=True)
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (35, 60], (25, 35], (60, 100], (35, 60], (25, 35]]
Length: 11
Categories (5, interval[int64]): [(0, 18] < (18, 25] < (25, 35] < (35, 60] < (60, 100]]

哑变量处理类别型数据

哑变量又称虚拟变量、名义变量，是人为虚设的变量用来反映某个变量的不同类别，使用哑变量处理数据就是将分类变量转换为哑变量矩阵或指标矩阵，矩阵的值通常用0或1表示。在pandas中可以用get_dummies()
pd.get_dummies(
data,
prefix=None,
prefix_sep=’_’,
dummy_na=False,
columns=None,
sparse=False,
drop_first=False,
dtype=None,
)
data, # 可接收数组，DF，Series对象，表示哑变量处理的数据
prefix=None, #表示列名的前缀，默认为None
prefix_sep=’’, #用于附加前缀作为分割符使用，默认为’’
dummy_na=False, # 表示是否为nan值添加一列
columns=None, # 表示DF要编码的列名，默认为none
sparse=False, # 表示虚拟列是否稀疏
drop_first=False, #是否通过从k个分类级别中删除第一个级来获取k-1个分类级别，默认为False
dtype=None,

df1 = pd.DataFrame({'职业':['学生','司机','老师','导游']})
df1
职业
0   学生
1   司机
2   老师
3   导游
_
pd.get_dummies(df1,prefix=['col_'])
col__司机 col__学生 col__导游 col__老师
0   0   1   0   0
1   1   0   0   0
2   0   0   0   1
3   0   0   1   0

数据预处理(纯干货，适合小白学习)相关推荐

为什么localstorage获取不到数据_纯干货！小白必看，为什么你微博超话引流不到人？揭秘在超话快速获取5000精准客源的引流实操方法...
星哥说引流,星哥说营销,星哥说社群大家好,我是引流哥尹星. 今天给大家分享的是一个通过微博给微信精准引流的玩法. 玩转微博超级话题快速获取5000精准客源,实操方法和注意事项全文2000字左右,耐 ...
【码农学编曲】基础乐理快速掌握（吐血整理纯干货适合小白）
[推荐视频教程]点这里 [乐理干货整理]往下看? 目录 [P1]节奏(动次打次) [P2]认识钢琴键盘 ? [P3]啥是调(以大调为例:qqbqqqb) [P4]音程 [P5]和弦 ...
Vue实现音乐播放效果（适合小白学习）
Vue实现音乐播放效果(适合小白学习) 播放器介绍五个html主要标签功能介绍 (1)搜索 (2)播放效果: 完整代码: 播放器介绍总体的效果如图所示,没有加很多css特效,需要美化的小白,可以 ...
北京python培训班价格-北京Python培训班，为什么Python超适合小白学习
原标题:北京Python培训班,为什么Python超适合小白学习每次在网上看到小白提问:零基础学编程,哪门编程语言更容易上手? 其实这个问题有两种回答,一是多去试试,常见的语言只有那么几种,挨个试 ...
python中小学生编程学习-推荐几个适合小白学习Python的免费网站
9gd少儿编程网-Scratch_Python_教程_免费儿童编程学习平台想要学好python,只靠看Python相关的书籍是远远不够的!互联网时代,我们还要充分利用网络上的免费资源,不然怎样成为一 ...
python自学网站免费-推荐几个适合小白学习Python的免费网站
9gd少儿编程网-Scratch_Python_教程_免费儿童编程学习平台想要学好python,只靠看Python相关的书籍是远远不够的!互联网时代,我们还要充分利用网络上的免费资源,不然怎样成为一 ...
时间序列预测——深度好文，ARIMA是最难用的（数据预处理过程不适合工业应用），线性回归模型简单适用，预测趋势很不错，xgboost的话，不太适合趋势预测，如果数据平稳也可以使用。...
补充:https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-15-276 如果用arima的话,还不如使用随机森 ...
04 数据操作 + 数据预处理【动手学深度学习v2】
数据操作宽是列的个数 4维是n个3维数组放一起比如每次读128张图片 5维视频有时间维度 [1:3,1:] 1:3--拿1,2行,左闭右开 1:--拿1到所有列 [::3,::2] ::所有行 ...
数据预处理--缺失值填补《菜菜学习笔记》
目录引言一.缺失值填补 impute.SimpleImputer函数 1.1 Simplelmputer四个重要参数 1.2 用各个值填补演示 1.3 在这里我们使用中位数填补Age,用众数填补E ...

数据预处理(纯干货，适合小白学习)

数据预处理

数据清洗

空值和缺失值的处理

重复值的处理

异常值处理

更改数据类型

数据合并

轴向堆叠数据

主键合并数据

根据行索引合并数据

合并重叠数据

数据重塑

重塑层次化索引

轴向旋转

数据转换

重命名轴索引

离散化连续数据

哑变量处理类别型数据

数据预处理(纯干货，适合小白学习)相关推荐

最新文章

热门文章