老男孩-数据分析 04 基于pandas的数据清洗

一、数据清洗

1.1有两种丢失的数据类型

• None
• np.nan(NaN）

)

NaN是可以参与运算的

import numpy as np
import pandas as pd
from pandas import DataFrame,Series
type(None)
Out[166]: NoneType
type(np.nan)
Out[168]: float


df = DataFrame(data=np.random.randint(0,100,size=(7,5)))
df.iloc[3,4] = None
df.iloc[2,2] = np.nan
df.iloc[5,3] = None
df
Out[175]: 
    0   1     2     3     4
0  74  92  99.0  50.0   9.0
1  43  31  16.0  31.0  94.0
2  40  68   NaN  20.0  71.0
3   0  69  18.0  36.0   NaN
4  64  26  65.0  23.0  65.0
5  65   8  17.0   NaN  98.0
6  73   6  20.0  13.0  64.0

1.2对空值进行过滤（删除空所在的行数据）

方式1： 技术：isnull,notnull,any,all

#step1：返回有空值的行（any作用到的df中,检查该行是否含空值，即返回False）

df.isnull().any(axis=1)
Out[177]: 
0    False
1    False
2     True
3     True
4    False
5     True
6    False
dtype: bool

#eg:检查某一列
df[2].isnull()
Out[42]: 
0    False
1    False
2     True
3    False
4    False
5    False
6    False

#step2：将布尔值作为源数据的行索引：保留True对应的行数据

df.loc[df.isnull().any(axis=1)]
Out[179]: 
    0   1     2     3     4
2  40  68   NaN  20.0  71.0

#step3：提取出存在空值的行索引

drop_index = df.loc[df.isnull().any(axis=1)].index
df.drop(labels = drop_index,axis=0)
Out[181]: 
    0   1     2     3     4
0  74  92  99.0  50.0   9.0
1  43  31  16.0  31.0  94.0
4  64  26  65.0  23.0  65.0
6  73   6  20.0  13.0  64.0

方式2： 技术：dropna

df.dropna(axis=0)
Out[182]: 
    0   1     2     3     4
0  74  92  99.0  50.0   9.0
1  43  31  16.0  31.0  94.0
4  64  26  65.0  23.0  65.0
6  73   6  20.0  13.0  64.0

1.3对空值进行覆盖

方式1：使用指定的值填充空值

df.fillna(value=666)

方式2：使用空值的近邻值填充

#ffill向前填充，bfill向后填充

df.fillna(method='ffill',anxis=0)#前填充
df.fillna(method='bfill',axis=1)#后填充

1.4处理重复数据

df = DataFrame(data=np.random.randint(0,100,size=(7,4)))
df.iloc[1]=[6,6,6,6]
df.iloc[2]=[6,6,6,6]
df.iloc[4]=[6,6,6,6]
df
Out[189]: 
    0   1   2   3
0   1  77  58  61
1   6   6   6   6
2   6   6   6   6
3  86  39  94  37
4   6   6   6   6
5  16  24  89  69
6  20  97   8  39

df.drop_duplicates(keep='first')
Out[190]: 
    0   1   2   3
0   1  77  58  61
1   6   6   6   6
3  86  39  94  37
5  16  24  89  69
6  20  97   8  39

1.5处理异常数据

例：自定义一个1000行3列（A,B,C）取值范围为0-1的数据源，然后将C列中的值大于其两倍的异常值进行清洗。

df = DataFrame(data=np.random.random(size=(1000,3)),columns=['A','B','C'])
df
Out[192]: 
            A         B         C
0    0.677511  0.741696  0.123118
1    0.109894  0.276689  0.327384
2    0.690454  0.646032  0.863023
3    0.331916  0.661893  0.426813
4    0.543461  0.625236  0.817895
..        ...       ...       ...
995  0.126886  0.338262  0.896376
996  0.243436  0.619466  0.264355
997  0.526397  0.491602  0.042839
998  0.899412  0.712483  0.679588
999  0.673219  0.755196  0.394561
[1000 rows x 3 columns]
#判定异常值的条件：C列中值大于其两倍的异常值进行清洗
std_twice = df['C'].std()*2
df['C']>std_twice
Out[207]: 
0      False
1       True
2      False
3      False
4      False
       ...  
995    False
996     True
997     True
998     True
999     True
Name: C, Length: 1000, dtype: bool
df.loc[~(df['C']>std_twice)]
Out[208]: 
            A         B         C
0    0.286439  0.179538  0.074626
2    0.977677  0.898987  0.386865
3    0.846330  0.834379  0.353600
4    0.739670  0.758042  0.071040
5    0.677392  0.763973  0.018698
..        ...       ...       ...
988  0.960497  0.379126  0.229842
990  0.555953  0.159244  0.439978
992  0.184596  0.900605  0.132270
994  0.062044  0.110570  0.303954
995  0.834983  0.089065  0.312663
[579 rows x 3 columns]

二、级联&合并操作

2.1级联操作

pd.concat,pd.append

——pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数

• objs
• axis=0
• keys
• join=‘outer’/‘inner’：表示的是级联的方式,outer会将所有的项进行级联（忽略匹配和不匹配），而inner只会将匹配的项级联到一起，不匹配的不级联
• ignore_index = False

2.1.1匹配级联。两个DataFrame数组行列、索引一致

pd.concat((df1,df1),axis=1)

2.2.2不匹配级联

——级联的维度的索引不一致。例如纵向级联时列索引不一致， 横向级联时行索引不一致
有2种连接方式:

1）. 外连接outer:补NaN (默认模式)（不能连的硬连，不够空来补）
2）. 内连接inner:只连接匹配的项（能不连就不练，只连能连的）

#创建列表数组：
df1 = DataFrame(data=np.random.randint(0,20,size=(3,4)),columns=['A','B','C','D'])
df1
Out[213]: 
    A   B   C  D
0  12   7   8  7
1  19   7  16  4
2  11  18  18  1
df2 = DataFrame(data=np.random.randint(0,20,size=(4,4)),columns=['B','C','D','F'])
df2
Out[215]: 
    B   C   D   F
0   7   3  17   2
1   9  19  17   1
2  17  16   5   6
3  19   1   0  13

#级联操作：
pd.concat((df1,df2),axis=0,join='outer')
Out[218]: 
      A   B   C   D     F
0  12.0   7   8   7   NaN
1  19.0   7  16   4   NaN
2  11.0  18  18   1   NaN
0   NaN   7   3  17   2.0
1   NaN   9  19  17   1.0
2   NaN  17  16   5   6.0
3   NaN  19   1   0  13.0
pd.concat((df1,df2),axis=0,join='inner')
Out[219]: 
    B   C   D
0   7   8   7
1   7  16   4
2  18  18   1
0   7   3  17
1   9  19  17
2  17  16   5
3  19   1   0

2.2.3.append函数的使用

只能列之间级联

df1.append(df2)
Out[221]: 
      A   B   C   D     F
0  12.0   7   8   7   NaN
1  19.0   7  16   4   NaN
2  11.0  18  18   1   NaN
0   NaN   7   3  17   2.0
1   NaN   9  19  17   1.0
2   NaN  17  16   5   6.0
3   NaN  19   1   0  13.0
df1.append(df1)
Out[222]: 
    A   B   C  D
0  12   7   8  7
1  19   7  16  4
2  11  18  18  1
0  12   7   8  7
1  19   7  16  4
2  11  18  18  1

2.2合并操作

●merge与concat的区别在于, merge需要依据某-共同列来进行合并
●使用pd.merge()合井时，会自动根据两者相同column名称的那一列,作为key来进行合并。
●注意每一列元素的顺序不要求一致

2.2.1一对一合并

pd.merge(df1,df2,on='employee'

2.2.2一对多合并

pd.merge(df3,df4)
#参数on不写，默认的合并条件就是两张表公有的列索引

2.2.3多对多连接

pd.merge(df1,df5,how='left')

2.3key的规范化

当列冲突时，即有多个列名称相同，需要使用on= 来指定哪一个列作为key,配合suffxes指定冲突名

2.4当两张表没有可进行连接的列时（列名不一样），可使用left_on和right_on手动指定merge中左右两边的哪一列作为连接的列

2.5内合并与外合并:out取并集inner取交集

如果字段相似：用级联
如果字段差异: 用合并