(五) Pandas之DataFrame03

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

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

• keep参数表示最终只保留哪一行
• first表示只保留第一次出现的重复行
• last只保留最后一次出现的重复行
• False表示不保留重复出现的行.

# 1.导包
import numpy as np
import pandas
from pandas import Series,DataFrame

创建具有重复元素行的DataFrame

# 2.创建一个df
df = DataFrame(data=np.random.randint(0,100,size=(8,4)))

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

使用duplicated查看所有重复元素行

~df.duplicated(keep='first')  # keep为first表示保留第一行

df.loc[~df.duplicated(keep=False)]  # False表示全删不保留

删除重复元素的行

#drop
indexs = df.loc[df.duplicated(keep='last')].index  # keep为last为保留最后一行
df.drop(labels=indexs,axis=0)

使用drop_duplicates()函数删除重复的行

• drop_duplicates(keep='first/last'/False)

# 如果想要删除重复的行,就可以直接使用drop_duplicates()函数
df.drop_duplicates(keep='first',inplace=False)

二. replace(to_replace,value)函数

替换元素.参数to_replace表示将被替换的值,value表示替换成的值

Series替换操作

• 单值替换
  • 普通替换
  • 字典替换(推荐）
• 多值替换
  • 列表替换
  • 字典替换（推荐）
• 参数
  • to_replace:被替换的元素

# to_replace即将要替换的值, value替换后的值
s = Series(data=[3,4,5,6,8,10,9])
s.replace(to_replace=[5,6],value=['five','six']) 

# 将df中所有的9替换成字符串nine,然后返回一个新的DataFrame
df.replace(to_replace=9,value='nine')

# 将df中的4全部替换成444,返回一个新的DataFrame
df.replace(to_replace={4:444})

# 按列指定单值替换： to_replace={列标签(显示索引)：替换值} value='value'
df.replace(to_replace={'c':4},value=444)

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=666,value='sixsixsix')  # 一次替换所有符合要求的元素

df.replace(to_replace={0:'zero'})  # 还可以通过字典的形式进行替换

# 如果后面带value表示前面to_replace的字典的键是列, 前面不带value的表示元素
df.replace(to_replace={2:666},value='six')

三. 映射:map()函数：新建一列 ， map函数并不是df的方法，而是series的方法

• map()可以映射新一列数据
• map()中可以使用lambd表达式
• map()中可以使用方法，可以是自定义的方法
• eg:map({to_replace:value})
• 注意 map()中不能使用sum之类的函数，for循环

# 新增一列：给df中，添加一列，该列的值为英文名对应的中文名
dic = {
    'name':['alex','jay','tom'],
    'salary':[5000,6000,9000],
    'dep':['sal','dev','sal']
}
df = DataFrame(data=dic)
# 使用map实现映射,map会返回映射完成后的一个Series
s = df['name'].map({'alex':'李杰','tom':'张三','jay':'周杰伦'})
# 将映射结果添加到源数据中
df['china_name'] = s

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

#求出df中每个人的税后薪资(超过3000部分的钱需要交纳50%的个税),将税后薪资作为df源数据的一个新列
def aflter_salary(s):
    if s >= 3000:
        return s-(s-3000)*0.5
    return s
df['after_salary'] = df['salary'].map(aflter_salary)

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

使用df.std()函数可以求得DataFrame对象每一列的标准差
创建一个1000行3列的df 范围（0-1），求其每一列的标准差

#对df应用筛选条件,去除标准差太大的数据:假设过滤条件为 C列数据大于两倍的C列标准差
df = DataFrame(np.random.random(size=(1000,3)),col=['A','B','C'])

# 指定过滤条件, 如果值大于标准差2倍返回True
std_twice = df['C'].std() * 2  # .std()方法求标准差
df['C']  > std_twice

# 将异常值进行过滤
df.loc[~(df['C']  > std_twice)]

# 由于fillna无法填充有值的元素，所以先找到异常元素的索引，将元素改为空，再用fillna填充
df.loc[df['C']  > std_twice]
indexs = df.loc[df['C']  > std_twice].index
indexs
#将元素改为空
df.loc[indexs,'C'] = np.nan

# 使用fillna填充
df.fillna(axis=0,method='ffill',inplace=True)
df.fillna(axis=0,method='bfill',inplace=True)
df

五. 排序

使用.take()函数排序

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

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

# 这里只能使用隐式索引,这里假如有300列,就要把显式索引全部填出来，隐式索引我们可以随机生成一组索引列表
df.take([2,1,0],axis=1)

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

# 生成5个随机数列
np.random.permutation(5)

# 对列索引进行随机打乱
df.take(np.random.permutation(3),axis=1)

随机抽样

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

# 对行和列索引一并进行随机打乱
random_df = df.take(np.random.permutation(3),axis=1).take(np.random.permutation(1000),axis=0)
random_df

# 取前100条数据
random_df[0:100]

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

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

数据分类处理：

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

数据分类处理的核心：

• 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]})

使用groupby实现分组

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

使用groups查看分组情况

# 使用goups属性查看分组情况
df.groupby(by='item',axis=0).groups

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

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

mean_price = df.groupby(by='item',axis=0)['price'].mean()
mean_price

使用映射将水果的平均价格添加到原表中的一列

dic = mean_price.to_dict()

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

按颜色查看各种颜色的水果的平均价格

color_mean_price = df.groupby(by='color',axis=0)['price'].mean()
color_mean_price

汇总:将各种颜色水果的平均价格和df进行汇总

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

高级聚合操作:

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

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

# 只能调用gropuby封装好的方法mean()，自定义的方法在groupby里面没有
df.groupby(by='item')['price'].mean()

#求出各种水果价格的平均值
df.groupby(by='item')['price']
df.groupby(by='item').groups

# 定义一个求水果平均价格的函数
def my_mean(s):
    sum = 0
    for i in s:
        sum+=i
    return sum/s.size

# 使用apply函数求出水果的平均价格
# 自己定义的my_mean函数，需要借助.apply()运算工具来执行
df.groupby(by='item')['price'].apply(my_mean)

#使用transform函数求出水果的平均价格(返回Series，不用再做映射)
df.groupby(by='item')['price'].transform(my_mean)

# apply还可以代替运算工具形式map
s = Series(data=[1,2,3,4,5,6,7,87,9,9])
# s.map(func)
s.apply(func)  # apply执行效率要比map()高很多