pandas 数据处理

删除重复数据

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

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

创建具有重复元素行的dataframe数据

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

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

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

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

df.loc[~(df.duplicated(keep='first'))] #指定保留第一行重复数据

 使用drop去除重复数据

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

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

参数: drop_duplicates(keep='first/last'/False)

df.drop_duplicates(keep='first',inplace=False)

映射

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

Series替换操作

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

单值普通替换　

s = Series(data=[2,3,4,5,6,7])

s.replace(to_replace=[5,6],value=['five','six'])

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={9:'nine'}) #将9替换为nine

df.replace(to_replace={3:666},value='six') #将第三列中的666替换为six

 map()函数

新建一列, map函数并不是df的方法，而是series的方法

• map()可以映射新一列数据
• map()中可以使用lambd表达式

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

  eg:map({to_replace:value})

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

重新创建一个df

dic = {
    'name':['jay','tom','jay'],
    'salary':[12000,7000,12000]
}
df = DataFrame(data=dic)

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

dic = {
    "jay":'周杰伦',
    "tom":'张三',
}
df['c_name'] = df['name'].map(dic)

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

 使用自定义函数

 超过3000部分的钱缴纳50%的税

def after_salary(s):
    if s <= 3000:
        return s
    else:
        return s - (s-3000)*0.5

df['after_sal'] = df['salary'].map(after_salary)

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

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

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

#创建一个1000行3列的df 范围（0-1），求其每一列的标准差
df = DataFrame(data=np.random.random(size=(1000,3)),columns=['A','B','C'])

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

std_twice = df['C'].std() * 2
df['C']  > std_twice
df.loc[~(df['C']  > std_twice)]

填充

df.loc[df['C']  > std_twice]
indexs = df.loc[df['C']  > std_twice].index
df.loc[indexs,'C'] = np.nan #将大于两倍的值赋值为空

df.fillna(axis=0,method='ffill',inplace=True) #前一个值填充
df.fillna(axis=0,method='bfill',inplace=True) #后一个值填充

排序

使用.take()函数排序

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

df.take([2,1,0],axis=1)

 

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

df.take(np.random.permutation(3),axis=1)

random_df = df.take(np.random.permutation(3),axis=1).take(np.random.permutation(1000),axis=0)

 

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

np.random.permutation(5)

数据分类处理

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

数据分类处理：

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

数据分类处理的核心：

 - groupby()函数
 - groups属性查看分组情况
 - eg: df.groupby(by='item').groups

 分组

from pandas import DataFrame,Series

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)

使用goups属性查看分组

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

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

给df创建一个新列，内容为各个水果的平均价格, mean():平均

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

#结果
    item
    Apple     3.00
    Banana    2.75
    Orange    3.50
    Name: price, dtype: float64

将数据转化为字典

dic = mean_price.to_dict()

结果: {'Apple': 3.0, 'Banana': 2.75, 'Orange': 3.5}

将结果添加数据中

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

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

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

高级数据聚合

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

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

使用apply函数求出水果的平均价格

def fun(s):
  　　sum = 0
  　　for i in s:
  　　　　sum+=i
  　　return sum/s.size

df.groupby(by='item')['price'].apply(fun)   #性能要不map好

使用transform函数求出水果的平均价格

　def fun(s):
  　　sum = 0
  　　for i in s:
  　　　　sum+=i
  　　return sum/s.size

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

 apply还可以替代运算工具map,效率高很多

s = Series(data=[1,2,3,4,5,6,7,87,9,9])
# s.map(func)
s.apply(func)