实用pandas进行数据预处理

1)数据合并原理与方法

import pandas as pd
impore numpy as np

1）纵向或横向堆叠 concat（）

detail=pd.DataFrame({
                   'A': ['A0', 'A1', 'A2', 'A3'],
                   'B': ['B0', 'B1', 'B2', 'B3'],
                    'C':['k0','k0','k1','k2'],
                   'D':['k0','k1','k0','k1'],
                    'E':['k0','k1','k1','k2'],
                   'F':['k0','k0','k0','k0'],
                   'G': ['C0', 'C1', 'C2', 'C3'],
                   'H': ['D0', 'D1', 'D2', 'D3'],
                   })
df1 = detail.iloc[0:3,:]
df2 = detail.iloc[2:4,:]
print(pd.concat([df1,df2],axis=1,join='inner')) #交集
print(pd.concat([df1,df2],axis=1,join='outer')) #并集

2）主键合并 merge（）

left=pd.DataFrame({
                   'A': ['A0', 'A1', 'A2', 'A3'],
                   'B': ['B0', 'B1', 'B2', 'B3'],
                    'key1':['k0','k0','k1','k2'],
                   'key2':['k0','k1','k0','k1'],
                   })
right=pd.DataFrame({
                    'key1':['k0','k1','k1','k2'],
                   'key2':['k0','k0','k0','k0'],
                   'C': ['C0', 'C1', 'C2', 'C3'],
                   'D': ['D0', 'D1', 'D2', 'D3'],
                   })
                   
print(pd.merge(left,right,how='right',on=['key1','key2']))
#以right表中key1,key2为主键合并

print(pd.merge(left,right,how='outer',on['key1','key2'],indicator=True)) 
#indicator=True显示表中数据来自合并前哪一个表
#outer 外合并  取并集

print(pd.merge(left, right, left_on='key2',right_on='key1',how='inner'))

print(pd.merge(left,right,how='inner',on=['key1','key2']))
#inner 内合并  取交集

3）重叠合并 combine_first（）

left=pd.DataFrame({
                   'id': [1,2,3,4],
                   'B': ['B0', 'B1', 'B2', np.nan],
                    'key1':['k0',np.nan,'k1','k2'],
                   })
right=pd.DataFrame({
                    'id':[1,2,3,4],
                   'key1':[np.nan,'k0','k1','k2'],
                   'B': [np.nan, 'B1', 'B2', np.nan],
                   })
print(left.combine_first(right))
#以第一张表为准，用第二张表补齐，

2)数据清洗的方法

1)检测处理重复值

right=pd.DataFrame({
                    'key1':['k0','k1','k1','k2'],
                   'key2':['k0','k0','k0','k1'],
                   'C': ['C0', 'C1', 'C1', 'C3'],
                    })
# 单列去重  
print(right['key2'].drop_duplicates()) 

#多列去重
print(right.drop_duplicates(subset=['key1','key2'],keep='first'))
#两列同时重复才去重，keep（first/last/False）/保留第一个重复值/保留最后一个/都不保留

# 特征去重   相似度 corr    方法pearson/spearman/kendall
# 如果两列相似度为1的时候，去除其中的某一列：
# 弊端：只能求解数值型特征，类别型的无法通过计算相似度衡量
corrDet = right[['key1','key2']].corr(method='kendall')

2)检测处理缺失值

#判断 如果数据中某个或某些特征不完整，这些值为缺失值
right=pd.DataFrame({
                    'key1':['k0','k1','k1','k2'],
                   'key2':['k0',np.nan,'k0','k0'],
                   'C': ['C0', 'C1', 'C2', 'C3'],
                   'D': ['D0', 'D1', 'np.nan', 'np.nan'],
                   })
print(right.isnull().sum())
print(right.notnull().sum())
#结合sum函数判断每个特征缺失值的总数目

#处理方法
#（1）删除  dropna()   删除比较简单容易引起数据结构变动，样本减少
right.dropna(axis=1,how='any',inplace=True)
#any 只要有缺失值就删， all 全是缺失值才删  axis(0/1)对行与列操作

#（2）替换   fillna()  替换法难度较低，但数据的标准差受影响，导致信息量变动
print(right.fillna(-99))  
#空值替换成 -99 

#(3)插值法  
x = np.array([1, 2, 3, 4, 5, 8, 9, 10])
y1 = np.array([2, 8, 18, 32, 50, 128, 162, 200])
y2 = np.array([3, 5, 7, 9, 11, 17, 19, 21])

#线性插值，（根据已有数据，求出线性方程，通过求解线性方程得到缺失值）

from scipy.interpolate import interp1d      
 # 线性拟合方式
 linearvalues = interp1d(x,y2,kind='linear')
 pring(linearbalues([6,7]))   
 #根据x,y2 得出的线性公式，传入6，7  返回值


#多项式插值，（利用所以数据拟合一个多项式，使得所有的店都满足多项式，通过求解得到缺失值）

from scipy.interpolate import lagrange
# 拉格朗日插值法
lagrangevalues=lagrange(x,y1)
print(lagrangevalues([6,7]))

#样条插值  （由一些多项式组成，每个多项式由相邻的两个点决定）

from scipy.interpolate import spline
splinevaluel=spline(x,y1,xnew=np.array([6,7]))
print(splinevaluel)

3)检测处理异常值
异常值/野值–表示个别的数明显偏离其他的数值，也成为离群点

arrli = np.array([3, 5, 7, 9, 11, 17, 19, 200])
def outrange(data):
	boolind=(data.mean() - 3 * data.std() > data) | (data.mean() + 3 * data.std() < data)
	return data[boolind]
print(outrange(arrli ))
#返回异常值数组

3)数据标准化的方法

标准化数据: 处理不同属性的量纲,需要将量纲统一

a = np.array([2, 3, 2, 4, 5, 8, 9, 10])

# (1)离差标准化
# x^* = (x -min)/(max - min) [0-1之间]
#缺点 (1)max=min ,(2)max很大,结果接近0,
def licha(data):
     x = (data-data.min())/(data.max()-data.min())
     return x
print(licha(a))

# (2)标准差标准化
#零均值标准化(将数据化为: 均值为0 ,方差为1)(负无穷,正无穷)
def zerohua(data):
     x = (data-data.mean())/data.std()
     return x
 print(zerohua(a))

# (3)小数定标标准化
# 通过移动数据小数位数,将所有数映射到[-1,1]区间,移动的小数位数取决于最大值
def scaler(data):
     return data/10**np.ceil(np.log(data.abs().max()))
print(scaler(a))

4)常用数据转换的方法

a = np.array(['北京','上海','广州','西藏','山西','云南'])
#1) 稀疏矩阵   哑变量处理(类别型数据)
print(pd.get_dummies(a))

#2)连续数据离散化
#等宽法 数据分布不均匀

a = np.random.randint(40,100,100)
pice =pd.cut(a,5)
print(pice.value_counts())
#返回5个区间内的a中数值出现的频率

#等频法

data =  np.random.randint(40,100,100)
w = data.quantile(np.arange(0,1+1.0/3,1.0/3))
# print(np.arange(0,1+1.0/3,1.0/3))     # [0.   0.33333333   0.66666667   1.   ]
# print(w)

print(pd.cut(data,w).value_counts())
#quantile 把data个数按照 np.arange(0,1+1.0/3,1.0/3) 分成3个区间，然后再使用cut()方法