一：检测与处理缺失值的操作
 
创建一个表格
 
import pandas as pd
import numpy as np

data = pd.DataFrame({
    "goods":["苹果","香蕉","芒果","猕猴桃","榴莲"],
    "price":[3.5, 2, np.NAN, 3, np.NAN],
    "num":[np.NAN, 41, 20, 12, np.NAN]
})
 
 
isnull
 
 
判断元素时空值，如果是空值返回True，不是空值则返回False
 
# 判断df中的元素是否为空，返回一个bool类型的df
print(data.isnull())

# 结果
   goods  price    num
0  False  False   True
1  False  False  False
2  False   True  False
3  False  False  False
4  False   True   True
 
# 计算空值个数
print(data.isnull().sum())

# 结果
goods    0
price    2
num      2
dtype: int64
 
 
notnull
 
 
判断元素不是空值的方法，如果是空值返回False，不是空值返回True
 
# 判断df中的元素是否不为空，返回一个bool类型的df
print(data.notnull())

# 结果
   goods  price    num
0   True   True  False
1   True   True   True
2   True  False   True
3   True   True   True
4   True  False  False
 
# 计算非空值个数
data.notnull().sum()  # 相当于data.count

# 结果
goods    5
price    3
num      3
dtype: int64
 
 
fillna
 
 
填充空值的方法
 
格式：fillna({“列索引”:“修改值”,…})
 
参数：
 
limit，限制修改的个数，默认为None值，修改全部
 
inplace，是否在原表上修改，默认为False，不在原表修改，有返回值
 
# 填充每一列的第一个空值
res = data.fillna({"price":4,"num":0},limit=1,inplace=False)
print(res)

# 结果
  goods  price   num
0    苹果    3.5   0.0
1    香蕉    2.0  41.0
2    芒果    4.0  20.0
3   猕猴桃    3.0  12.0
4    榴莲    NaN   NaN
 
 
dropna
 
 
how：为any时表示有空则删，为all时全为空才删除
 
thresh：阈值，当这一行的非空数目小于thresh值时进行删除
 
subset：指定字段进行判断后删除
 
# 删除含有空值的行
res2 = data.dropna(axis=0,how="any")
print(res2)

# 结果
  goods  price   num
1    香蕉    2.0  41.0
3   猕猴桃    3.0  12.0

 
# 如果price和num这两列的值都为空时则删除这一行数据
res2 = data.dropna(subset=["price","num"],axis=0,how="all")
print(res2)

# 结果
  goods  price   num
0    苹果    3.5   NaN
1    香蕉    2.0  41.0
2    芒果    NaN  20.0
3   猕猴桃    3.0  12.0
 
二：处理缺失值方法
 
插值法
 
 
线性插值：要求x,y之间满足线性关系，即满足y = kx + b
 
只能在规定的x范围内插值
 
import numpy as np
from scipy.interpolate import interpld
 
# y = (x+1) * 2
x = np.array([0,1,2,3,5])
y = np.array([2,4,6,8,12])
Linear1 = interp1d(x,y,kind="linear")
print(Linear1([4]))  # 此处传入的参数只能在x的范围内
print(Linear1([4.5]))  # 可传入小数,因为它是先推导表达式，然后传值进行计算的

# 结果
[10.]
[11.2]
 
 
多项插值的方法：利用已知的值，拟合一个多项式(拉格朗日插值，牛顿插值)
 
from scipy.interpolate import lagrange
 
# y1 = 2 * (x1+1)**2，且在5和6的位置上缺失两个值
x1 = [0,1,2,3,4,7,8,9]
y1 = [2,8,18,32,50,128,162,200]
Larg = lagrange(x1,y1)
print(Larg([5,6]))

# 结果
[72. 98.]
 
总结：用非线性函数拟合线性的数据是可以的，但是用线性函数拟合非线性的数据，结果会很差。
 
 
三：检测与处理重复值
 
 
记录重复
 
# 创建表格
df = pd.DataFrame({
	"name":["zs","ls","ww","zs"],
	"id":[1,2,3,1],
	"age":[12,15,12,12]
})
 
# 当二维表格不传入subset参数时，默认以整行为比较单位
ret = df.drop_duplicates(subset=["name","age"])
print(ret)

# 结果
  name  id  age
0   zs   1   12
1   ls   2   15
2   ww   3   12
 
 
特征重复
 
需要是连续型数值，通过相似度的方法判定两列值是否具有某种关系，得到的值的范围为-1~1，越靠近1则表示相关性越强
 
参数：
 
  
 
method
 
​ pearson：皮尔森相关性系数
 
​ kendall：肯德尔相关性系数
 
​ spearman：斯皮尔曼相关性系数
 
 
# 方法一
ret = df[["id","age"]].corr(method="kendall")
print(ret)


# 结果
           id       age
id   1.000000  0.258199
age  0.258199  1.000000

 
# 方法二
ret = df[["id","age"]].corr(method="spearman")
print(ret)

# 结果
           id       age
id   1.000000  0.272166
age  0.272166  1.000000
 
注：这个方法只能处理数值型，不能处理类别型。类型型特征之间是无法通过相关系数来计算相似度的。
 
 
哑变量处理
 
将类别型数据转化为数值型数据
 
返回的数据类型是一个df矩阵，类似于一个稀疏矩阵，one-hot编码
 
ret = pd.get_dummies(df["name"])
print(ret)

# 结果
   ls  ww  zs
0   0   0   1
1   1   0   0
2   0   1   0
3   0   0   1
 
 
四：异常值处理
 
异常值是指我们的数据中个别数值明显偏离其余数值的数据，也称为离群点
 
检测异常值就是检测数据中是否录入错误以及是否有不合理的数据
 
 
3σ原则：[拉伊达准则]
 
该法则就是假设一组检验数据只有随机误差，对原始数据进行计算处理得到标准差。按照一定的概率确定一个区间，认为误差超过这个区间就属于异常值。3σ原则仅适用于服从正态分布或者近似正态分布的数据。
 
μ - 3 σ < x < μ + 3σ，为正常区间数据，此区间的概率值为0.9973
 
# 创建表格
df = pd.DataFrame({
    "name":["zs","ls","ww","zl","aq","xm"],
    "weight":[168,174,181,155,170,172]
    })
 
# 定义3σ原则表达式
min_mask = df["weight"] < (df["weight"].mean() - 3 *  df["weight"].std())
max_mask = df["weight"] > (df["weight"].mean() + 3 * df["weight"].std())
# 只要满足上诉表达式的任一个就为异常值，所以这里使用位与运算
mask = min_mask | max_mask
print(df.loc[mask,"weight"])

# 结果
# 没有不符合3σ表达式的值，即无异常值
Series([], Name: weight, dtype: float64)
 
 
根据项目场景自定义阈值范围
 
 
五：连续数据离散化
 
分析一个问题时，某些特征是连续的，比如：年龄
 
 
等宽法
 
尽力要求区间宽度是一致的，但是落到每个区间内的频数就不能保持一致的，用此方法更多的是关注区间的宽度。最终会得到一个一维数组
 
参数：
 
bins，表示区间，当bins中传入数值型的时候，表示区间的个数；当bins中传入列表时，为自定义分割的区间
 
right=False，改变区间的封闭方向，由右改为左
 
labels=[item1,item2,…]，使用自定义的分箱名称，这样就不只显示数字了
 
precision=n，整数自动分箱时的精度
 
方法：
 
ret.codes，显示数据在对应的区间索引
 
ret.categories，显示分类区间的详细信息
 
pd.value_counts(ret)，显示各分段的数量
 
# 创建表格
df = df.DataFrame({
	"name":["zs","ls","ww","zl","xm","lh"],
	"age":[26,54,33,10,43]
})
 
# bins为整数型时，将年龄分为3个区间
ret = pd.cut(df3["age"],bins = 3)

# 结果
0     (22.0, 38.0]
1     (38.0, 54.0]
2     (22.0, 38.0]
3    (5.952, 22.0]
4     (38.0, 54.0]
5    (5.952, 22.0]
Name: age, dtype: category
Categories (3, interval[float64]): [(5.952, 22.0] < (22.0, 38.0] < (38.0, 54.0]]
	
 
# 自定义区间
ret2 = pd.cut(df3["age"],bins=[0,20,40,60])
print(ret2)

# 结果
0    (20, 40]
1    (40, 60]
2    (20, 40]
3     (0, 20]
4    (40, 60]
5     (0, 20]
Name: age, dtype: category
Categories (3, interval[int64]): [(0, 20] < (20, 40] < (40, 60]]
 
 
等频法
 
尽力使得数据能够均匀落到每个区间
 
参数：
 
q：当q传入数值型时，为区间的个数；当q传入一个列表时，列表中必须为分位数，为自定义区间
 
# q为数值型时，表示区间的个数
ret3 = pd.qcut(df3["age"],q=3)
print(ret3)

# 结果
0    (5.999, 29.5]
1     (29.5, 54.0]
2     (29.5, 54.0]
3    (5.999, 29.5]
4     (29.5, 54.0]
5    (5.999, 29.5]
Name: age, dtype: category
Categories (2, interval[float64]): [(5.999, 29.5] < (29.5, 54.0]]
 
# q传入一个列表，为自定义区间
ret4 = pd.qcut(df3["age"],q=[0, 0.3, 1])
print(ret4)

# 结果
(21.5, 54.0]     4
(5.999, 21.5]    2
Name: age, dtype: int64
 
等频与等差的区别：
 
​ 传入一个整数型时，等宽会照数组中的最大值和最小值平均分成5份，即分为5个区间，等频是先划分出5个区间并保证区间内的值个数相等，在满足频数的条件下再设置每个区间的开头和结尾值；传入一个列表时，等宽中的列表值即是每个区间的开头和结尾值，而等频中，列表中的值确定的是每个区间的个数，然后根据区间的个数确定每个区间的开头和结尾值。
 
 
六：数据标准化
 
当样本数据中属性的量纲差别很大的时候，相似度的计算结果就会完全由数值大的属性支配。
 
 
离差标准化
 
x` = (x-min) / (max-min)
 
x`的范围：0~1
 
缺点
 
  
标准化的数据不能取值完全一样。如果取值完全一样，则分母为0，公式不成立。
该方法完全取决于max和min值，当max或min值为异常值的时候，标准化不准确，可能出现趋于0的情况。
 
import numpy as np
import pandas as pd

x = pd.Series([-10, 20, 15, 16, 18, 21, 12])
def get_transform(x):
	new_x = (x-x.min()) / (x.max()-x.min())
	return new_x
x.transform(get_transform)
 
 
标准差标准化
 
x` = (x-u) / σ 【u:均值，σ:标准差】
 
标准差标准化之后的数据满足：u = 0, σ=1
 
x` 范围为：负无穷~正无穷
 
import numpy as np
import pandas as pd

x = pd.Series([-10, 20, 15, 16, 18, 21, 12])
def get_transform(x):
	new_x = (x-x.mean()) / x.std()
	return new_x
x.transform(get_transform)
 
 
小数定标标准化
 
x` = x / 10k
 
x`的范围通常设定在 -1~1 之间
 
k值的确定：k = np.ceil(np.log10(x.abs().max()))
 
缺点
 
  
当出现异常值时，就会出现较大的误差
 
import numpy as np
import pandas as pd

x = pd.Series([-10, 20, 15, 16, 18, 21, 12])
def get_transform(x):
	k = np.ceil(np.log10(x.abs().max()))
	return x/10**k
x.transform(get_transform)
 

异常值是指那些在数据集中存在的不合理的值，需要注意的是，不合理的值是偏离正常范围的值，不是错误值。比如人的身高为-1m，人的体重为1吨等，都属于异常值的范围。虽然异常值不常出现，但是又会对实际项目分析有影响，造成结果的偏差，所以在数据挖掘的过程中不能不重视。
 
异常值出现的原因
 
数据集中的异常值可能是由于传感器故障、人工录入错误或异常事件导致。如果忽视这些异常值，在某些建模场景下就会导致结论的错误（如线性回归模型、K均值聚类等），所以在数据的探索过程中，有必要识别出这些异常值并处理好它们。
 
异常值检测
 
简单统计分析
 
最常用的统计量是最大值和最小值，用来判断这个变量的取值是否超出合理的范围。
 
3σ原则
 
3σ原则是建立在正态分布的等精度重复测量基础上而造成奇异数据的干扰或噪声难以满足正态分布。
 
 正态分布，又叫做高斯分布。特征为中间高两边低左右对称。
 
正态分布特性：
 
集中性：曲线的最高峰位于正中央，并且位置为均数所在的位置。
对称性：以均数所在的位置为中心呈左右对称，并且曲线两段无限趋近于横轴。
均匀变动性：正态分布曲线以均数所在的位置为中心均匀向左右两侧下降。
 
正态分布函数公式如下：
 
 如果一组测量数据中的某个测量值的残余误差的绝对值 νi>3σ，则该测量值为坏值，应剔除。通常把等于 ±3σ的误差作为极限误差,对于正态分布的随机误差，落在 ±3σ以外的概率只有 0.27%，它在有限次测量中发生的可能性很小，故存在3σ准则。3σ准则是最常用也是最简单的粗大误差判别准则，它一般应用于测量次数充分多( n ≥30)或当 n>10做粗略判别时的情况。
 
σ代表标准差,μ代表均值
 
样本数据服从正态分布的情况下：
 
数值分布在(μ-σ,μ+σ)中的概率为0.6826
数值分布在(μ-2σ,μ+2σ)中的概率为0.9544
数值分布在(μ-3σ,μ+3σ)中的概率为0.9974
 
 可以认为，Y 的取值几乎全部集中在（μ-3σ,μ+3σ)区间内，超出这个范围的可能性仅占不到0.3%。
 
箱线图
 
箱线图是通过数据集的四分位数形成的图形化描述，是非常简单而且效的可视化离群点的一种方法。
 上下须为数据分布的边界，只要是高于上须，或者是低于下触须的数据点都可以认为是离群点或异常值。
 
 下四分位数：25%分位点所对应的值(Q1)
 
中位数：50%分位点对应的值(Q2)
 
上四分位数：75%分位点所对应的值(Q3)
 
上须：Q3+1.5(Q3-Q1)
 
下须：Q1-1.5(Q3-Q1)
 
其中Q3-Q1表示四分位差
 
异常值处理
 
删除
 
直接将含有异常值的记录删除，通常有两种策略：整条删除和成对删除。这种方法最简单简单易行，但缺点也不容忽视，一是在观测值很少的情况下，这种删除操作会造成样本量不足;二是，直接删除、可能会对变量的原有分布造成影响，从而导致统计模型不稳定。
 
视为缺失值
 
视为缺失值，利用处理缺失值的方法来处理。这一方法的好处是能够利用现有变量的信息，来填补异常值。需要注意的是，将该异常值作为缺失值处理，需要根据该异常值(缺失值)的特点来进行，针对该异常值(缺失值)是完全随机缺失、随机缺失还是非随机缺失的不同情况进行不同处理。
 
平均值修正
 
如果数据的样本量很小的话，也可用前后两个观测值的平均值来修正该异常值。这其实是一种比较折中的方法，大部分的参数方法是针对均值来建模的，用平均值来修正，优点是能克服了丢失样本的缺陷，缺点是丢失了样本“特色”。
 
盖帽法
 
整行替换数据框里99%以上和1%以下的点，将99%以上的点值=99%的点值；小于1%的点值=1%的点值。
 
 
分箱法
 
分箱法通过考察数据的“近邻”来光滑有序数据的值。有序值分布到一些桶或箱中。
 分箱法包括等深分箱：每个分箱中的样本量一致；等宽分箱：每个分箱中的取值范围一致。
 
回归插补
 
发现两个相关的变量之间的变化模式，通过使数据适合一个函数来平滑数据。
 若是变量之间存在依赖关系，也就是y=f(x)，那么就可以设法求出依赖关系f，再根据x来预测y，这也是回归问题的实质。实际问题中更常为见的假设是p(y)=N(f(x))，N为正态分布。假设y是观测值并且存在噪声数据，根据我们求出的x和y之间的依赖关系，再根据x来更新y的值，这样就能去除其中的随机噪声，这就是回归去噪的原理 。
 
多重插补
 
多重插补的处理有两个要点：先删除Y变量的缺失值然后插补
 1)被解释变量有缺失值的观测不能填补，只能删除，不能自己乱补；
 2)只对放入模型的解释变量进行插补。
 
不处理
 
根据该异常值的性质特点，使用更加稳健模型来修饰，然后直接在该数据集上进行数据挖掘。

异常值处理
 
指那些偏离正常范围的值，不是错误值
异常值出现频率较低，但又会对实际项目分析造成偏差
异常值一般用过箱线图法(分位差法)或者分布图(标准差法)来判断
异常值检测可以使用均值的二倍标准差范围，也可以使用上下4分位数差方法
异常值往往采取盖帽法或者数据离散化
 
import pandas as pd
import numpy as np
import os
 
os.getcwd()
 
'D:\\Jupyter\\notebook\\Python数据清洗实战\\数据清洗之数据预处理'
 
os.chdir('D:\\Jupyter\\notebook\\Python数据清洗实战\\数据')
 
df = pd.read_csv('MotorcycleData.csv', encoding='gbk', na_values='Na')
 
def f(x):
    if '$' in str(x):
        x = str(x).strip('$')
        x = str(x).replace(',', '')
    else:
        x = str(x).replace(',', '')
    return float(x)
 
df['Price'] = df['Price'].apply(f)
 
df['Mileage'] = df['Mileage'].apply(f)
 
df.head(5)
 
 
 
Condition
Condition_Desc
Price
Location
Model_Year
Mileage
Exterior_Color
Make
Warranty
Model
...
Vehicle_Title
OBO
Feedback_Perc
Watch_Count
N_Reviews
Seller_Status
Vehicle_Tile
Auction
Buy_Now
Bid_Count
0
Used
mint!!! very low miles
11412.0
McHenry, Illinois, United States
2013.0
16000.0
Black
Harley-Davidson
Unspecified
Touring
...
NaN
FALSE
8.1
NaN
2427
Private Seller
Clear
True
FALSE
28.0
1
Used
Perfect condition
17200.0
Fort Recovery, Ohio, United States
2016.0
60.0
Black
Harley-Davidson
Vehicle has an existing warranty
Touring
...
NaN
FALSE
100
17
657
Private Seller
Clear
True
TRUE
0.0
2
Used
NaN
3872.0
Chicago, Illinois, United States
1970.0
25763.0
Silver/Blue
BMW
Vehicle does NOT have an existing warranty
R-Series
...
NaN
FALSE
100
NaN
136
NaN
Clear
True
FALSE
26.0
3
Used
CLEAN TITLE READY TO RIDE HOME
6575.0
Green Bay, Wisconsin, United States
2009.0
33142.0
Red
Harley-Davidson
NaN
Touring
...
NaN
FALSE
100
NaN
2920
Dealer
Clear
True
FALSE
11.0
4
Used
NaN
10000.0
West Bend, Wisconsin, United States
2012.0
17800.0
Blue
Harley-Davidson
NO WARRANTY
Touring
...
NaN
FALSE
100
13
271
OWNER
Clear
True
TRUE
0.0
 
5 rows × 22 columns
 
# 对价格异常值处理
# 计算价格均值
x_bar = df['Price'].mean()
 
# 计算价格标准差
x_std = df['Price'].std()
 
# 异常值上限检测
any(df['Price'] > x_bar + 2 * x_std)
 
True
 
# 异常值下限检测
any(df['Price'] < x_bar - 2 * x_std)
 
False
 
# 描述性统计
df['Price'].describe()
 
count      7493.000000
mean       9968.811557
std        8497.326850
min           0.000000
25%        4158.000000
50%        7995.000000
75%       13000.000000
max      100000.000000
Name: Price, dtype: float64
 
# 25% 分位数
Q1 = df['Price'].quantile(q = 0.25)
 
# 75% 分位数
Q3 = df['Price'].quantile(q = 0.75)
 
# 分位差
IQR = Q3 - Q1
 
any(df['Price'] > Q3 + 1.5 * IQR)
 
True
 
any(df['Price'] < Q1 - 1.5 * IQR)
 
False
 
import matplotlib.pyplot as plt
 
%matplotlib inline
 
df['Price'].plot(kind='box')
 
<matplotlib.axes._subplots.AxesSubplot at 0x11ddad20ac8>
 
 
# 设置绘图风格
plt.style.use('seaborn')
# 绘制直方图
df.Price.plot(kind='hist', bins=30, density=True)
# 绘制核密度图
df.Price.plot(kind='kde')
# 图形展现
plt.show()
 
 
# 用99分位数和1分位数替换
# 计算P1和P99
P99 = df['Price'].quantile(q=0.99)
P1 = df['Price'].quantile(q=0.01)
 
P99
 
39995.32
 
df['Price_new'] = df['Price']
 
# 盖帽法
df.loc[df['Price'] > P99, 'Price_new'] = P99
df.loc[df['Price'] < P1, 'Price_new'] = P1
 
df[['Price', 'Price_new']].describe()
 
 
 
Price
Price_new
count
7493.000000
7493.000000
mean
9968.811557
9821.220873
std
8497.326850
7737.092537
min
0.000000
100.000000
25%
4158.000000
4158.000000
50%
7995.000000
7995.000000
75%
13000.000000
13000.000000
max
100000.000000
39995.320000
 
# df['Price_new'].plot(kind='box')

背景：
 
不论是在机器/深度学习还是普通的业务场景的描述性统计分析等，我们首先要做的就是了解拿到的基础数据，观察数据结构，类型，缺失值，异常值等情况。其中，异常值是指数据集中存在的不合理的点，这些异常点如果不加以剔除或者修正而错误的包括进数据的计算分析过程中，那么会对结果产生非常不好的影响，导致结果偏差。因此，重视异常值的出现，分析其产生原因，并对异常值进行剔除或者修正就显得尤其重要。本篇幅主要列举了本人遇到的一些异常值的处理方法，如有更好的，欢迎指正！
 
1. 如何发现异常值？
 
异常值的方法想法有很多种，基于业务的认知，简单的确定某个指标的阈值，进行判断，也可以基于统计学方法，同时还有基于机器学习的离群点检测方法，今天主要介绍统计学方法和机器学习的方法。
 1.1 3∂原则
 在统计学中，如果一个数据分布近似正态，那么大约 68% 的数据值会在均值的一个标准差范围内，大约 95% 会在两个标准差范围内，大约 99.7% 会在三个标准差范围内。但是，当数据不服从正态分布，可以通过远离平均距离多少倍的标准差来判定，多少倍的取值需要根据经验和实际情况来决定。
 
 
###正态分布标准差
import numpy as np
import matplotlib.pyplot as plt

def find_outliter_std(random_data,c):
    anomalies = []
    random_data_std = np.std(random_data) 
    random_data_mean = np.mean(random_data) 
    anomaly_cut_off = random_data_std * c 
    lower_limit = random_data_mean - anomaly_cut_off 
    upper_limit = random_data_mean + anomaly_cut_off 
    #print(lower_limit)
    for outlier in random_data: 
        if outlier > upper_limit or outlier < lower_limit: 
            anomalies.append(1) 
        else:
            anomalies.append(0)
    res4=pd.merge(pd.DataFrame(random_data),pd.DataFrame(anomalies),left_index=True,right_index=True)
    res4.columns=['values','is_outliter']
    return res4
 
1.2 箱线图
 箱线图是通过数据集的四分位数形成的图形化描述。这是一种非常简单但有效的可视化离群点的方法。考虑把上下触须作为数据分布的边界。任何高于上触须或低于下触须的数据点都可以认为是离群点或异常值。箱型图依据实际数据绘制，没有对数据作任何限制性要求（如服从某种特定的分布形式），它只是真实直观地表现数据分布的本来面貌；另一方面，箱型图判断异常值的标准以四分位数和四分位距为基础，四分位数具有一定的鲁棒性：多达25%的数据可以变得任意远而不会很大地扰动四分位数，所以异常值不能对这个标准施加影响。由此可见，箱型图识别异常值的结果比较客观，在识别异常值方面有一定的优越性
 
 如下是绘制箱形图的代码：
 
import numpy as np
import pandas as pd
import scipy
def find_outliter_quantile(random_data,c):
    anomalies = []
    random_data_q1 = np.quantile(random_data,0.25)
    random_data_q3 = np.quantile(random_data,0.75) 
    anomaly_cut_off = (random_data_q3-random_data_q1) * c #c一般为1.5或者3，但是个人认为可以根据实际业务情况进行更改，比如涨幅超过1倍的情况就是极端异常的情况，那我们可以c取值为1
    lower_limit = random_data_q1 - anomaly_cut_off 
    upper_limit = random_data_q3 + anomaly_cut_off 
    for outlier in random_data: 
        if outlier > upper_limit or outlier < lower_limit: 
            anomalies.append(1) 
        else:
            anomalies.append(0)
    res5=pd.merge(pd.DataFrame(random_data),pd.DataFrame(anomalies),left_index=True,right_index=True)
    res5.columns=['values','is_outliter']
    return res5

if __name__=='__main__':
	data=np.array([1338,1338,2,1047,688,520,1408,225,206,280])
	outliers=find_outliter_quantile(random_data,c)
 
1.3 DBSCAN
 从基于密度的观点来说，离群点是在低密度区域中的对象。基于密度的离群点检测与基于邻近度的离群点检测密切相关，因为密度通常用邻近度定义，DBSCAN就是一种使用密度的聚类算法，具体算法原理可以查阅：https://baike.baidu.com/item/DBSCAN/4864716?fr=aladdin
 
from sklearn.cluster import DBSCAN
import numpy as np
def dbscan(random_data):
	outlier_detection = DBSCAN(min_samples = 2, eps = 3)
	clusters = outlier_detection.fit_predict(random_data)
	print (list(clusters).count(-1))
	res2=pd.DataFrame(random_data,list(clusters)).reset_index()
	res2.columns=['is_outliter','values']
	return res2
 
1.4 k-means
 k-means方法是基于聚类的离群点识别方法，k-means的主要思想是一个对象是基于聚类的离群点，如果该对象不强属于任何簇，那么该对象属于离群点。
 离群点对初始聚类的影响：如果通过聚类检测离群点，则由于离群点影响聚类，存在一个问题：结构是否有效。这也是k-means算法的缺点，对离群点敏感。为了处理该问题，可以使用如下方法：对象聚类，删除离群点，对象再次聚类（这个不能保证产生最优结果）。
 优缺点：（1）基于线性和接近线性复杂度（k均值）的聚类技术来发现离群点可能是高度有效的；（2）簇的定义通常是离群点的补，因此可能同时发现簇和离群点；（3）产生的离群点集和它们的得分可能非常依赖所用的簇的个数和数据中离群点的存在性；（4）聚类算法产生的簇的质量对该算法产生的离群点的质量影响非常大。
 
####k-means方法异常点检测#####
from sklearn import preprocessing
from sklearn.cluster import KMeans
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def kmeans(data):
	data_scale = preprocessing.scale(data)#处理后需要转为dataframe，或者直接手动求均值、方差转换
	model = KMeans(n_clusters = 2,max_iter = 1000) # k=2，一类认为是异常的，一类是不异常的，最大迭代次数可以根据实际情况进行修改
	model.fit(data_scale)
	data_scale = pd.DataFrame(data_scale)
	#data_scale = pd.DataFrame(data_scale,index = data.index)
	data_scale['labels'] = model.labels_
	res3=pd.merge(data_scale,pd.DataFrame(data),left_index=True,right_index=True) 
	res3.columns=['distance','labels','values']
	#print (res3)
	return res3
 
1.5 孤立森林
 孤立森林是一种无监督学习算法，属于组合决策树家族。这种方法和以上所有方法都不同。之前的所有方法都在试图寻找数据的常规区域，然后将任何在此定义区域之外的点都视为离群点或异常值。
 这种方法的工作方式不同。它明确地隔离异常值, 而不是通过给每个数据点分配一个分数来分析和构造正常的点和区域。它利用了这样一个事实：异常值只是少数，并且它们具有与正常实例非常不同的属性值。该算法适用于高维数据集，并且被证明是一种非常有效的异常检测方法。
 
#孤立森林
#最好对数据集去重，在确定孤立点，因为如果多个异常点聚集，那么就不孤立了
from sklearn.ensemble import IsolationForest
import numpy as np
def  isolationforest(random_data):
	clf = IsolationForest(behaviour = 'new',max_samples='auto', random_state = 1, contamination= 'auto')
	preds = clf.fit_predict(random_data)
	print (list(preds).count(-1))
	res1=pd.DataFrame(random_data,list(preds)).reset_index()
	res1.columns=['is_outliter','values']
	return res1
 
2. 异常值如何处理？
 
检测到了异常值，我们需要对其进行一定的处理。而一般异常值的处理方法可大致分为以下几种：
 首先、如果模型或者分析对异常值比较敏感，如果不处理会极大的影响模型效果或者业务分析结果，那么则需要进行如下几种方式的处理：
 （1）删除含有异常值的记录：直接将含有异常值的记录删除；
 
（2）视为缺失值：将异常值视为缺失值，利用缺失值处理的方法进行处理；
 
（3）平均值修正：可用前后两个观测值的平均值修正该异常值；
 
其次、如果使用的模型对异常值不是很敏感，那么建议直接在具有异常值的数据集上进行数据挖掘；
 
参考文献：
 
【1】python-异常值分析
 【2】数据预处理之异常值处理
 【3】机器学习中的异常值检测和处理