pandas函数高级

一、处理丢失数据

有两种丢失数据：

• None
• np.nan(NaN)

1. None

None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。

#查看None的数据类型
None + 1

2. np.nan（NaN）

np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。

#查看np.nan的数据类型
np.nan + 1

nan

3. pandas中的None与NaN

1) pandas中None与np.nan都视作np.nan

创建DataFrame

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

df = DataFrame(data=np.random.randint(0,100,size=(8,6)))

df.iloc[2,4] = None
df.iloc[3,3] = np.nan
df.iloc[5,2] = None
df.iloc[2,1] = None

2) pandas处理空值操作

• isnull()
• notnull()
• dropna(): 过滤丢失数据
• fillna(): 填充丢失数据

(1)判断函数

• isnull()
• notnull()

df.isnull()

df.loc[[True,True,False,False,True,False,True,True]]

df.notnull()

df.notnull().any(axis=1)
df.notnull().all(axis=1)

df.loc[df.notnull().all(axis=1)]

df.isnull().any(axis=1)

#固定搭配
isnull=》any
notnull=》all
#结论：将df.notnull().all(axis=1)作为源数据的行索引，就可以将空对应的行删除

indexs = df.loc[df.isnull().any(axis=1)].index #获取的是值对应行的行索引
df.drop(labels=indexs,axis=0)

• df.dropna() 可以选择过滤的是行还是列（默认为行）:axis中0表示行，1表示的列

df.dropna(axis=0)

(3) 填充函数 Series/DataFrame

• fillna():value和method参数

df.fillna(method='bfill',axis=0)

# 可以选择前向填充还是后向填充

二、pandas的拼接操作

pandas的拼接分为两种：

• 级联：pd.concat, pd.append
• 合并：pd.merge, pd.join

1. 使用pd.concat()级联

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

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

1)匹配级联

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

df1 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['A','B','C'],columns=['a','b','c'])
df2 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['A','B','D'],columns=['a','b','d'])
pd.concat((df1,df1),axis=0)

2) 不匹配级联

不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致

有2种连接方式：

• 外连接：补NaN（默认模式）

• 内连接：只连接匹配的项

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

pd.concat((df1,df2),axis=1,join='inner')

2.使用pd.merge()合并

merge与concat的区别在于，merge需要依据某一共同的列来进行合并

使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。

注意每一列元素的顺序不要求一致

参数：

• how：out取并集 inner取交集

• on：当有多列相同的时候，可以使用on来指定使用那一列进行合并，on的值为一个列表

1) 一对一合并

df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                'group':['Accounting','Engineering','Engineering'],
                })

df2 = DataFrame({'employee':['Lisa','Bob','Jake'],
                'hire_date':[2004,2008,2012],
                })

pd.merge(df1,df2)

2) 多对一合并

df3 = DataFrame({
    'employee':['Lisa','Jake'],
    'group':['Accounting','Engineering'],
    'hire_date':[2004,2016]})

df4 = DataFrame({'group':['Accounting','Engineering','Engineering'],
                       'supervisor':['Carly','Guido','Steve']
                })

pd.merge(df3,df4)

3) 多对多合并

df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                 'group':['Accounting','Engineering','Engineering']})

df5 = DataFrame({'group':['Engineering','Engineering','HR'],
                'supervisor':['Carly','Guido','Steve']
                })

pd.merge(df1,df5,how='outer',on='group')

pd.merge(df1,df5,how='inner',on='group')

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

4) key的规范化

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

df1 = DataFrame({'employee':['Jack',"Summer","Steve"],
                 'group':['Accounting','Finance','Marketing']})

df2 = DataFrame({'employee':['Jack','Bob',"Jake"],
                 'hire_date':[2003,2009,2012],
                'group':['Accounting','sell','ceo']})

pd.merge(df1,df2,on='group')

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

df1 = DataFrame({'employee':['Bobs','Linda','Bill'],
                'group':['Accounting','Product','Marketing'],
               'hire_date':[1998,2017,2018]})

df5 = DataFrame({'name':['Lisa','Bobs','Bill'],
                'hire_dates':[1998,2016,2007]})

pd.merge(df1,df5,left_on='employee',right_on='name')

5) 内合并与外合并:out取并集 inner取交集

• 内合并：只保留两者都有的key（默认模式）

df6 = DataFrame({'name':['Peter','Paul','Mary'],
               'food':['fish','beans','bread']}
               )
df7 = DataFrame({'name':['Mary','Joseph'],
                'drink':['wine','beer']})

# 外合并 how='outer'：补NaN
df6 = DataFrame({'name':['Peter','Paul','Mary'],
               'food':['fish','beans','bread']}
               )
df7 = DataFrame({'name':['Mary','Joseph'],
                'drink':['wine','beer']})

三、pandas数据处理

1、删除重复元素

使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True

• keep参数：指定保留哪一重复的行数据

• 创建具有重复元素行的DataFrame

#创建一个df
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

df = DataFrame(data=np.random.randint(0,100,size=(8,6)))

#手动将df的某几行设置成相同的内容
df.iloc[1] = [6,6,6,6,6,6]
df.iloc[3] = [6,6,6,6,6,6]
df.iloc[7] = [6,6,6,6,6,6]

# 使用drop_duplicates()函数删除重复的行
# drop_duplicates(keep='first/last'/False)
df.drop_duplicates(keep='first')

2. 映射

1) replace()函数：替换元素

使用replace()函数，对values进行映射操作

DataFrame替换操作

• 单值替换
  • 普通替换： 替换所有符合要求的元素:to_replace=15,value='e'
  • 按列指定单值替换： to_replace={列标签：替换值} value='value'

• 多值替换
  • 列表替换: to_replace=[] value=[]
  • 字典替换（推荐） to_replace={to_replace:value,to_replace:value}

df.replace(to_replace=5,value='five')

df.replace(to_replace=6,value='six')

df.replace(to_replace={88:'8888888'})

df.replace(to_replace={3:6},value='six')

# 注意：DataFrame中，无法使用method和limit参数

2) map()函数：新建一列 ， map函数并不是df的方法，而是series的方法

• map()可以映射新一列数据

• map()中可以使用lambd表达式

• map()中可以使用方法，可以是自定义的方法

  eg:map({to_replace:value})

• 注意 map()中不能使用sum之类的函数，for循环

• 新增一列：给df中，添加一列，该列的值为中文名对应的英文名

dic = {
    'name':['周杰伦','张三','周杰伦'],
    'salary':[15000,20000,15000]
}
df = DataFrame(data=dic)

#映射关系表（字典）
dic = {
    '周杰伦':'jay',
    '张三':'tom'
}
df['e_name'] = df['name'].map(dic)

map当做一种运算工具，至于执行何种运算，是由map函数的参数决定的（参数：lambda，函数）

• 使用自定义函数

def after_sal(s):
    return s - (s-3000)*0.5
#超过3000部分的钱缴纳50%的税
df['after_sal'] = df['salary'].map(after_sal)

注意：并不是任何形式的函数都可以作为map的参数。只有当一个函数具有一个参数且有返回值，那么该函数才可以作为map的参数。

3. 使用聚合操作对数据异常值检测和过滤

使用df.std()函数可以求得DataFrame对象每一列的标准差

• 创建一个1000行3列的df 范围（0-1），求其每一列的标准差

df = DataFrame(data=np.random.random(size=(1000,3)),columns=['A','B','C'])

# 对df应用筛选条件,去除标准差太大的数据:假设过滤条件为 C列数据大于两倍的C列标准差

twice_std = df['C'].std() * 2

df['C'] > twice_std
df.loc[df['C'] > twice_std]
drop_indexs = df.loc[df['C'] > twice_std].index
df.drop(labels=drop_indexs,axis=0)

4. 排序

使用.take()函数排序

- take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
- eg:df.take([1,3,4,2,5])

可以借助np.random.permutation()函数随机排序

np.random.permutation(5)
out: array([4, 3, 0, 2, 1])

df.take(indices=[1,2,0],axis=1).take(indices=np.random.permutation(1000),axis=0)[0:10]

# np.random.permutation(x)可以生成x个从0-(x-1)的随机数列

随机抽样

当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样

5. 数据分类处理【重点】

数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

数据分类处理：

• 分组：先把数据分为几组
• 用函数处理：为不同组的数据应用不同的函数以转换数据
• 合并：把不同组得到的结果合并起来

数据分类处理的核心： - groupby()函数 - groups属性查看分组情况 - eg: df.groupby(by='item').groups

分组

df = DataFrame({'item':['Apple','Banana','Orange','Banana','Orange','Apple'],
                'price':[4,3,3,2.5,4,2],
               'color':['red','yellow','yellow','green','green','green'],
               'weight':[12,20,50,30,20,44]})

df.groupby(by='item',axis=0)

# 使用groups查看分组情况
#该函数可以进行数据的分组，但是不显示分组情况
df.groupby(by='item',axis=0).groups

# 分组后的聚合操作：分组后的成员中可以被进行运算的值会进行运算，不能被运算的值不进行运算

#给df创建一个新列，内容为各个水果的平均价格
df.groupby(by='item',axis=0).mean()['price']
mean_price_s = df.groupby(by='item',axis=0)['price'].mean()
mean_price_s

dic = mean_price_s.to_dict()
df['item'].map(dic)

df['mean_price'] = df['item'].map(dic)

color_mean_price_s = df.groupby(by='color')['price'].mean()

dic = color_mean_price_s.to_dict()
df['mean_price_color'] = df['color'].map(dic)

6.高级数据聚合

使用groupby分组后，也可以使用transform和apply提供自定义函数实现更多的运算

• df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
• transform和apply都会进行运算，在transform或者apply中传入函数即可
• transform和apply也可以传入一个lambda表达式

def my_mean(p):
    sum = 0
    for i in p:
        sum += i
    return sum/len(p)

df.groupby(by='item')['price'].apply(my_mean) 

df.groupby(by='item')['price'].transform(my_mean)