处理缺失值

In [87]:

from pandas import Series,DataFrame
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt 
import matplotlib as mpl
import seaborn as sns

In [88]:

%matplotlib inline

In [3]:

df1 = DataFrame([[3,5,3],[1,6,np.nan],
                ['lili',np.nan,'pop'],[np.nan,'a','b']])    # 创建有缺失值的DataFrame
df1

Out[3]:

查找缺失值df.isnull()、df.notnull()、df.info()

In [4]:

df1.isnull()   #True的为缺失值

Out[4]:

In [5]:

df1.notnull()   #False为缺失值

Out[5]:

In [6]:

df1.isnull().sum()    # 获取每列的缺失值数量，再通过求和就可以获取整个DataFrame的缺失值数量

Out[6]:

0    1
1    1
2    1
dtype: int64

In [7]:

df1.isnull().sum().sum()

Out[7]:

3

In [9]:

df1.isnull().values.any()

Out[9]:

True

In [10]:

df1.info()   # 通过info方法，也可以看出DataFrame每列数据的缺失值情况

RangeIndex: 4 entries, 0 to 3
Data columns (total 3 columns):
0    3 non-null object
1    3 non-null object
2    3 non-null object
dtypes: object(3)
memory usage: 176.0+ bytes

删除缺失值df.dropna()、df.dropna(how='all')

In [11]:

df1.dropna()    # dropna方法可以删除具有缺失值的行，整行删除，传入how='all'，则只会删除全为NaN的那些行

Out[11]:

In [17]:

df2 = DataFrame(np.arange(12).reshape(3,4))
df2

Out[17]:

In [19]:

df2.ix[2,:] = np.nan    # 索引为2，即第三行所有列为缺失值
df2[3] = np.nan      # 新建列索引为3的所有数据为缺失值
df2

Out[19]:

In [20]:

df2.dropna(how='all')     # 传入how='all'，则只会删除全为NaN的那些行

Out[20]:

In [21]:

df2.dropna(how='all',axis=1)     #axis=1，轴向为列，删除整列为缺失值的，默认为行删除

Out[21]:

填充缺失值df.fillna(0)

In [22]:

df2

Out[22]:

In [24]:

df2.fillna(0)   # 通过fillna方法可以将缺失值替换为常数值

Out[24]:

In [25]:

df2.fillna({1:6,3:0})     # 针对列索引1和列索引3的缺失值进行相应的填充
'''
在fillna中传入字典结构数据，可以针对不同列填充不同的值，
fillna返回的是新对象，不会对原数据进行修改
'''

Out[25]:

In [26]:

df2

Out[26]:

In [27]:

df2.fillna({1:6,3:0},inplace=True)   # 通过inplace就地进行修改
'''
1.df.fillna()函数的功能:该函数的功能是用指定的值去填充dataframe中的缺失值。
2.df.fillna()函数的基本语法:df.fillna(a,[inplace=False]),
    其中参数a表示的是常数或字典，若a为常数，则用常数a填充缺失值，
    若a为字典，则表示第key列的缺失值用key对应的value值填充，
    如：df.fillna({0:10,1:20}),表示用10去填充第0列的缺失值，用20去填充第1列的缺失值；
    inplace为可选参数，默认为False，表示不修改原对象，若指定inplace=True,则直接修改原对象。
3.df.fillna()函数的返回值：若指定inplace=True，则函数返回值为None，若未指定，则函数返回填充缺失值后的数据。
4.df.fillna()函数的用法补充：
4.1 指定method参数：
（1）method='ffill'或'pad'，表示用前一个非缺失值去填充该缺失值，语法为df.fillna(method='ffill')；
（2）method ='bflii'或'backfill'，表示用下一个非缺失值填充该缺失值，语法为df.fillna(method='bflii')；
4.2 指定limit参数和axis参数：
    limit参数用于指定每列或每行缺失值填充的数量，默认按列操作，
    axis参数用于指定对行还是对列操作。若axis=0，则对各行数据进行填充，若axis=1，则对各列数据进行填充，
    如：df.fillna(method='ffill', limit=1，axis=1)
    表示用上一个非缺失值填充该缺失值，且每行中只有一列被填充，
    因为method='ffill'并且limit=1，所以每行中只有最先出现缺失值的一列被填充

'''
df2

Out[27]:

In [28]:

df2.fillna(method='ffill')   # method='ffill'或'pad'，表示用前一个非缺失值去填充该缺失值

Out[28]:

In [29]:

df2

Out[29]:

In [31]:

df2[0] = df2[0].fillna(df2[0].mean())   # 指定第0列缺失值通过平均值作为填充数
df2

Out[31]:

In [32]:

df2.fillna?   #fillna的参数，可以通过“? ”进行帮助查询，这也是自我学习最好的方法

移除重复数据

In [33]:

data = {
    'name':['张三', '李四', '张三', '小明'],
    'sex':['female', 'male', 'female', 'male'],
    'year':[2001, 2002, 2001, 2002],
    'city':['北京', '上海', '北京', '北京']
}
df1 = DataFrame(data)
df1

Out[33]:

In [34]:

df1.duplicated()    # 判断各行是否有重复数据，当每行的每个字段都相同时才会判断为重复项

Out[34]:

0    False
1    False
2     True
3    False
dtype: bool

In [35]:

df1.drop_duplicates()   # 删除多余的重复项，当每行的每个字段都相同时才会判断为重复项

Out[35]:

In [36]:

df1.drop_duplicates(['sex','year'])   # 指定部分列作为判断重复项的依据，默认保留的数据为第一个出现的组合

Out[36]:

In [39]:

df1.drop_duplicates(['sex','year'],keep='last')   # 传入keep='last’可以保留最后一个出现的组合

Out[39]:

替换值

In [41]:

data = {
    'name':['张三', '李四', '王五', '小明'],
    'sex':['female', 'male', '', 'male'],
    'year':[2001, 2003, 2001, 2002],
    'city':['北京', '上海', '', '北京']
}
df1 = DataFrame(data)
df1

Out[41]:

In [42]:

df1.replace('','不详')   # 通过replace可完成替换值的功能，空值替换为不详

Out[42]:

In [43]:

df1.replace(['',2001],['不详',2002])  #列表格式  多值替换，空值替换为不详，2001替换为2002

Out[43]:

In [44]:

df1.replace({'':'不详',2001:2002})  #字典格式  多值替换，空值替换为不详，2001替换为2002

Out[44]:

利用函数或映射进行数据转换

In [45]:

data = {
    'name':['张三', '李四', '王五', '小明'],
    'math':[79, 52, 63, 92]
}
df2 = DataFrame(data)
df2

Out[45]:

In [46]:

def f(x):        # 定义函数f
    if x >= 90:
        return '优秀'
    elif 70<=x<90:
        return '良好'
    elif 60<=x<70:
        return '合格'
    else:
        return '不合格'

map()函数接收两个参数，一个是函数，一个是Iterable， map将传入的函数依次作用到序列的每一个元素，并把结果作为新的Iterable返回。 其语法格式为： map(function，iterable...) function---函数名 iterable---一个或多个序列

In [48]:

df2['class'] = df2['math'].map(f)     # 新增class列，math列每个元素都运行函数f后填入class列
df2

Out[48]:

In [49]:

del df2['class']     # 删除class列
df2

Out[49]:

In [50]:

df2['class'] = df2['math'].apply(f)   #apply函数运行f函数
df2

Out[50]:

检测异常值

In [2]:

df3 = DataFrame(np.arange(10),columns=['X'])
df3['Y'] = 2 * df3['X'] + 0.5
df3.iloc[9,1] = 185
df3

Out[2]:

In [8]:

df3.plot(kind='scatter',x='X',y='Y')

Out[8]:

虚拟变量

在数学建模和机器学习中，只有数值型数据才能供算法使用， 对于一些分类变量则需要将其转换为虚拟变量（哑变量）（也就是0,1矩阵）， 通过get_dumnies函数即可实现该功能

In [10]:

df = DataFrame({
    '朝向':['东','南','东','西','北'],
    '价格':[1200,2100,2300,2900,1400]
})
df

Out[10]:

In [11]:

pd.get_dummies(df['朝向'])    # '朝向' 列转换为虚拟变量（哑变量）（也就是0,1矩阵）

Out[11]:

In [12]:

df2 = DataFrame({
    '朝向':['东/北','西/南','东','西/北','北'],
    '价格':[1200,2100,2300,2900,1400]
})
df2

Out[12]:

In [16]:

dummies = df2['朝向'].apply(lambda x:Series(x.split('/')).value_counts())  
# 对于多类别的数据而言，需要通过apply函数来实现
dummies

Out[16]:

In [19]:

dummies = dummies.fillna(0).astype(int)
dummies

Out[19]:

数据合并与重塑

In [43]:

price = DataFrame({
    'fruit':['apple','banana','orange'],
    'price':[23,32,45]
})
amount = DataFrame({
    'fruit':['apple','banana','apple','apple','banana','pear'],
    'amount':[5,3,6,3,5,7]
})

In [44]:

price

Out[44]:

In [45]:

amount

Out[45]:

merge合并

In [46]:

pd.merge(amount,price)     # merge函数是通过一个或多个键（DataFrame的列）将两个DataFrame按行合并起来

Out[46]:

In [47]:

pd.merge(amount,price,on='fruit')   # 指定键名合并

Out[47]:

merge函数常用参数

In [48]:

pd.merge(amount,price,left_on='fruit',right_on='fruit')
'''merge默认为内连接（inner），也就是返回交集。
通过how参数可以选择连接方法：
左连接（left）、右连接（right）和外连接（outer）
'''

Out[48]:

In [49]:

pd.merge(amount,price,how='left')

Out[49]:

In [50]:

pd.merge(amount,price,how='right')

Out[50]:

In [52]:

pd.merge(amount,price,how='outer')

Out[52]:

In [53]:

price2 = DataFrame({
    'fruit':['apple','banana','orange','apple'],
    'price':[23,32,45,25]
})
amount2 = DataFrame({
    'fruit':['apple','banana','apple','apple','banana','pear'],
    'amount':[5,3,6,3,5,7]
})

In [54]:

amount2

Out[54]:

In [55]:

price2

Out[55]:

In [57]:

pd.merge(amount2,price2)

Out[57]:

In [59]:

left = DataFrame({
    'key1':['one','one','two'],
    'key2':['a','b','a'],
    'val1':[2,3,4]
})
right = DataFrame({
    'key1':['one','one','two','two'],
    'key2':['a','a','a','b'],
    'val2':[5,6,7,8]
})

In [60]:

left

Out[60]:

In [61]:

right

Out[61]:

In [62]:

pd.merge(left,right,on=['key1','key2'],how='outer')    # 多键进行合并，即传入一个list即可

Out[62]:

In [63]:

pd.merge(left,right,on='key1')

Out[63]:

In [64]:

pd.merge(left,right,on='key1',suffixes=('_left','_right'))    # 重复列名的修改,suffixes方法

Out[64]:

In [66]:

left2 = DataFrame({
    'key':['a','a','b','b','c'],
    'val1':range(5)
})
right2 = DataFrame({
    'val2':[5,7]},
    index = ['a','b']
)

In [67]:

left2

Out[67]:

In [68]:

right2

Out[68]:

In [70]:

pd.merge(left2,right2,left_on='key',right_index=True)   
''' 
连接的键位于DataFrame的行索引上，
可通过传入left_index=True或者right_index=True指定将索引作为连接键来使用
'''

Out[70]:

In [71]:

left3 = DataFrame({
    'val1':range(4)},
    index = ['a','b','a','c']
)
right3 = DataFrame({
    'val2':[5,7]},
    index = ['a','b']
)

In [72]:

left3

Out[72]:

In [73]:

right3

Out[73]:

In [74]:

left3.join(right3,how='outer')     # join方法，可以快速完成按索引合并

Out[74]:

concat连接

In [3]:

s1 = Series([0,1],index=['a','b'])
s2 = Series([2,3],index=['c','d'])
s3 = Series([4,5],index=['e','f'])

In [4]:

pd.concat([s1,s2,s3])   # 需要合并的DataFrame之间没有连接键,通过pandas的concat方法实现

Out[4]:

a    0
b    1
c    2
d    3
e    4
f    5
dtype: int64

In [5]:

pd.concat([s1,s2,s3],axis=1)   # 默认情况下，concat是在axis=0上工作的，通过指定轴向也可以按列进行连接

Out[5]:

In [6]:

s4 = pd.concat([s1*10,s3])
s4

Out[6]:

a     0
b    10
e     4
f     5
dtype: int64

In [8]:

pd.concat([s1,s4],axis=1)

Out[8]:

In [9]:

pd.concat([s1,s4],axis=1,join='inner')   # concat默认为外连接（并集），传入join='inner’可以实现内连接

Out[9]:

In [14]:

pd.concat([s1,s4],axis=1,join='inner',join_axes=[['b','a']])   # 通过join_axes指定使用的索引顺序

Out[14]:

In [15]:

pd.concat([s1,s4])   # concat只有内连接和外连接

Out[15]:

a     0
b     1
a     0
b    10
e     4
f     5
dtype: int64

In [17]:

pd.concat([s1,s4],keys=['one','two'])    # 通过keys参数给连接对象创建一个层次化索引

Out[17]:

one  a     0
     b     1
two  a     0
     b    10
     e     4
     f     5
dtype: int64

In [18]:

pd.concat([s1,s4],axis=1,keys=['one','two'])   # 如果按列连接，keys就成了DataFrame的列索引

Out[18]:

In [28]:

df1 = DataFrame({
    'val1':range(3)},
    index = ['a','b','c']
)
df2 = DataFrame({
    'val2':[5,7]},
    index = ['a','b']
)

In [29]:

df1

Out[29]:

In [30]:

df2

Out[30]:

In [32]:

pd.concat([df1,df2],axis=1,keys=['one','two'])

Out[32]:

In [33]:

pd.concat({'one':df1,'two':df2},axis=1)    # 通过字典数据也可以完成连接，字典的键就是keys的值

Out[33]:

In [34]:

df1 = DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
df2 = DataFrame(np.random.randn(2,2),columns=['d','c'])

In [35]:

df1

Out[35]:

In [36]:

df2

Out[36]:

In [37]:

pd.concat([df1,df2])

Out[37]:

In [38]:

pd.concat([df1,df2],ignore_index=True)    # 通过ignore_index=‘True’忽略索引，以达到重排索引的效果

Out[38]:

combine_first合并

In [39]:

df1 = DataFrame({
    'a':[3,np.nan,6,np.nan],
    'b':[np.nan,4,6,np.nan]
})
df2 = DataFrame({
    'a':range(5),
    'b':range(5)
})

In [40]:

df1

Out[40]:

In [41]:

df2

Out[41]:

In [42]:

df1.combine_first(df2)     # 需要合并的两个DataFrame存在重复的索引，使用combine_first方法

Out[42]:

数据重塑

In [48]:

df = DataFrame(np.arange(9).reshape(3,3),
              index = ['a','b','c'],
              columns=['one','two','three'])
df.index.name = 'alph'
df.columns.name = 'number'
df

Out[48]:

In [50]:

result = df.stack()    # stack方法用于将DataFrame的列“旋转”为行；默认情况下，数据重塑的操作都是最内层的
result

Out[50]:

alph  number
a     one       0
      two       1
      three     2
b     one       3
      two       4
      three     5
c     one       6
      two       7
      three     8
dtype: int32

In [51]:

result.unstack()    # unstack方法用于将DataFrame的行“旋转”为列，默认情况下，数据重塑的操作都是最内层的

Out[51]:

In [52]:

result.unstack(0)

Out[52]:

In [53]:

result.unstack('alph')

Out[53]:

In [54]:

df = DataFrame(np.arange(16).reshape(4,4),
              index=[['one','one','two','two'],['a','b','a','b']],
              columns=[['apple','apple','orange','orange'],['red','green','red','green']])
df

Out[54]:

In [55]:

df.stack()

Out[55]:

In [56]:

df.unstack()

Out[56]:

字符串处理

In [71]:

data = {
    'data':['张三|男', '李四|女', '王五|女', '小明|男'],
}
df = DataFrame(data)
df

Out[71]:

In [67]:

result = df['data'].apply(lambda x:Series(x.split('|')))   
# 把数据分成两列，常用的方法是通过函数应用来完成
result

Out[67]:

In [81]:

new_df = df['data'].str.split('|')
# pandas中字段的str属性可以轻松调用字符串的方法
new_df

Out[81]:

0    [张三, 男]
1    [李四, 女]
2    [王五, 女]
3    [小明, 男]
Name: data, dtype: object

In [82]:

df['name'] = new_df.str[0]     # pandas中字段的str属性可以轻松调用字符串的方法
df['sex'] = new_df.str[1]      # # pandas中字段的str属性可以轻松调用字符串的方法
df

Out[82]:

正则表达式

In [83]:

df2 = DataFrame({
    'email':['102345@qq.com','342167@qq.com','65132@qq.com']
})
df2

Out[83]:

In [84]:

df2['email'].str.findall('(.*?)@')

Out[84]:

0    [102345]
1    [342167]
2     [65132]
Name: email, dtype: object

In [85]:

df2['QQ'] = df2['email'].str.findall('(.*?)@').str.get(0)
df2

Out[85]:

综合示例——Iris数据集

In [101]:

from pandas import Series,DataFrame
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt   #导入pyplot绘图模块
import matplotlib as mpl    #导入matplotlib绘图库
import seaborn as sns  #导入seaborn绘图库
%matplotlib inline

In [107]:

iris_data = pd.read_csv(open('H:python数据分析数据iris-data.csv'))   # 读取数据
iris_data.head()

Out[107]:

首先对数据进行简单描述，看其中是否有异常值

In [108]:

iris_data.shape    # 数据大小行数和列数

Out[108]:

(150, 5)

In [110]:

iris_data.describe()   

Out[110]:

In [112]:

iris_data['class'].unique()   # 去重
# unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表

Out[112]:

array(['Iris-setosa', 'Iris-setossa', 'Iris-versicolor', 'versicolor',
       'Iris-virginica'], dtype=object)

In [115]:

iris_data.ix[iris_data['class'] == 'versicolor', 'class'] = 'Iris-versicolor'
iris_data.ix[iris_data['class'] == 'Iris-setossa', 'class'] = 'Iris-setosa'

iris_data['class'].unique()

Out[115]:

array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object)

In [118]:

sns.pairplot(iris_data, hue='class')   # 利用seaborn绘制散点图矩阵

F:Anacondaenvsdata-analysislibsite-packages
umpylibfunction_base.py:748: RuntimeWarning: invalid value encountered in greater_equal
  keep = (tmp_a >= mn)
F:Anacondaenvsdata-analysislibsite-packages
umpylibfunction_base.py:749: RuntimeWarning: invalid value encountered in less_equal
  keep &= (tmp_a <= mx)

Out[118]:

In [119]:

iris_data.ix[iris_data['class'] == 'Iris-setosa', 'sepal_width_cm'].hist()

Out[119]:

In [125]:

iris_data = iris_data.loc[(iris_data['class'] != 'Iris-setosa') | (iris_data['sepal_width_cm'] >= 2.5)]
iris_data.loc[iris_data['class'] == 'Iris-setosa', 'sepal_width_cm'].hist()

Out[125]:

In [126]:

iris_data.loc[(iris_data['class'] == 'Iris-versicolor') &
              (iris_data['sepal_length_cm'] < 1.0)]

Out[126]:

In [127]:

iris_data.loc[(iris_data['class'] == 'Iris-versicolor') &
              (iris_data['sepal_length_cm'] < 1.0),
              'sepal_length_cm'] *= 100.0

In [128]:

iris_data.isnull().sum()

Out[128]:

sepal_length_cm    0
sepal_width_cm     0
petal_length_cm    0
petal_width_cm     5
class              0
dtype: int64

In [131]:

iris_data[iris_data['petal_width_cm'].isnull()]

Out[131]: