1.前言
 
 前一段时间，在小伙伴的怂恿下参加了京东的Jdata数据大赛（并以剪刀石头布的方式决定的组长，草率！
 
 
 
 
 不过非常感谢小伙伴们对我的信任，还有我们一起学习的热情让我一下恢复了对学习的xing趣了呢），作为一名小白，抱着学习的心态去的，所谓的万事开头难是真的，从来没接触过这种比赛或工作的我也是一头雾水，以前没上过数据处理和挖掘的课程，不知从何下手，就是在这样一穷二白的情况下开始了长达两周的工作。
 
 
 
 
 向曾经参加过类似比赛的师兄取经、请教老师解题思路、查阅相关书籍（幸好我之前有买许多相关书籍）、逛各种论坛、竞赛官方qq群，做了很多准备，当然最难的就是动手实践。很多理论在实战面前都是苍白的，比如书里面经常说可视化、可视化，对于数据的可视化我们可以得到很多的信息，然而有一些是可以这样做的，另一些如用户购买关系网络因为数据量的问题、而且就算抽样的话，可视化后我们依然分析不出个所以然来
 
 
 
 
 （可能还是方法没用对）。
 
 在这两周内在每天提交次数、每周截至提交日期的压力下，我快速成长了起来，一开始不知道用什么软件、代码处理数据，后来查资料、问人确定了几个可选方案，直接上手干，第一个方案不行，查查怎么回事还不行就换，最后决定使用jupyter notebook+pandas+matplot的方案果断上；(神奇的 )
 
 
 
 
 从pandas数据结构什么都不知道，到从各种博客搜集所需要的代码，后来发现遗忘速度真的很快，用完就忘还得重新找对应博客、资料很麻烦，所以就有了我这篇总结的雏形，经过不断的完善在经历了一整个数据处理流程下来，常用的代码都已经总结的很完善了，然后就是学习了一些大牛开源的代码后，发现：我艹，还能这么搞！于是进一步完善总结。
 
 两周的工作主要就是两个部分：数据处理+上模型跑代码，然后就不断的循环重复，跑完代码提交看看有什么问题，藉由这次比赛经历我也得到了许多宝贵的经验，如很多事情想和做是不一样的，做了才会有深刻的理解，理解了才会更好的思考。
 
 
 
 
  不过很遗憾的是，因为时间和精力有限，没能继续做下去，再往下做基本就是用户推荐的事了，也看了一些用户推荐的资料和具体的实现方法，可以实现的，但因为已过两周，超过了我的预算，而且与我感兴趣领域不很相关，而且在此期间有了一些成长，从无到有还是收获许多，所以选择退出。
 
  不过好记性不如烂笔头，已过去一段时间，发现再不总结归纳，又要忘的差不多，所以给自己一个借口，好好整理一下，以便日后需要的时候用的着，在这里也是想和大家分享一下。
 
  
 
  最后还想和大家分享的是微信文章的下载和学习小技巧，我一般都是直接将网页下载或者另存为pdf看，foxit reader还是一个很好的pdf阅读器，我可以在上面设置各种快捷键方便我做注释。
 
  
 
 PS:因为时间有限而且总结的内容有点多，格式来不及统计，各位将就看吧！
 


 
 2.常用数据预处理方法
 
 这个部分总结的是在python中常见的数据预处理方法。
 


 
 2.1标准化（Standardization or Mean Removal and Variance Scaling)
 
 变换后各维特征有0均值，单位方差。也叫z-score规范化（零均值规范化）。计算方式是将特征值减去均值，除以标准差。
 
 sklearn.preprocessing.scale(X)
 
 一般会把train和test集放在一起做标准化，或者在train集上做标准化后，用同样的标准化去标准化test集，此时可以用scaler
 
 scaler = sklearn.preprocessing.StandardScaler().fit(train)
 
 scaler.transform(train)
 
 scaler.transform(test)
 
 实际应用中，需要做特征标准化的常见情景：SVM
 


 
 2.2最小-最大规范化
 
 最小-最大规范化对原始数据进行线性变换，变换到[0,1]区间（也可以是其他固定最小最大值的区间）
 
 min_max_scaler = sklearn.preprocessing.MinMaxScaler()
 
 min_max_scaler.fit_transform(X_train)
 


 
 2.3规范化（Normalization）
 
 规范化是将不同变化范围的值映射到相同的固定范围，常见的是[0,1]，此时也称为归一化。
 
 将每个样本变换成unit norm。
 
 X = [[ 1, -1, 2],[ 2, 0, 0], [ 0, 1, -1]]
 
 sklearn.preprocessing.normalize(X, norm='l2')
 
 得到：
 
 array([[ 0.40, -0.40, 0.81], [ 1, 0, 0], [ 0, 0.70, -0.70]])
 
 可以发现对于每一个样本都有，0.4^2+0.4^2+0.81^2=1,这就是L2 norm，变换后每个样本的各维特征的平方和为1。类似地，L1 norm则是变换后每个样本的各维特征的绝对值和为1。还有max norm，则是将每个样本的各维特征除以该样本各维特征的最大值。
 在度量样本之间相似性时，如果使用的是二次型kernel，需要做Normalization
 
 2.4特征二值化（Binarization）
 
 给定阈值，将特征转换为0/1
 
 binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
 
 binarizer.transform(X)
 
 2.5标签二值化（Label binarization）
 
 lb = sklearn.preprocessing.LabelBinarizer()
 
 2.6类别特征编码
 
 有时候特征是类别型的，而一些算法的输入必须是数值型，此时需要对其编码。
 
 enc = preprocessing.OneHotEncoder()
 
 enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
 
 enc.transform([[0, 1, 3]]).toarray() #array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])
 
 上面这个例子，第一维特征有两种值0和1，用两位去编码。第二维用三位，第三维用四位。
 
 另一种编码方式
 
 newdf=pd.get_dummies(df,columns=["gender","title"],dummy_na=True)
 
 详细的说明可以在后面常用指令中看到
 
 Examples
 
 >>> import pandas as pd
 
 >>> s = pd.Series(list('abca'))
 
 >>> pd.get_dummies(s)
 
    a  b  c
 
 0  1  0  0
 
 1  0  1  0
 
 2  0  0  1
 
 3  1  0  0
 
 >>> s1 = ['a', 'b', np.nan]
 
 >>> pd.get_dummies(s1)
 
    a  b
 
 0  1  0
 
 1  0  1
 
 2  0  0
 
 >>> pd.get_dummies(s1, dummy_na=True)
 
    a  b  NaN
 
 0  1  0    0
 
 1  0  1    0
 
 2  0  0    1
 
 >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
 
                     'C': [1, 2, 3]})
 
 >>> pd.get_dummies(df, prefix=['col1', 'col2'])
 
    C  col1_a  col1_b  col2_a  col2_b  col2_c
 
 0  1       1       0       0       1       0
 
 1  2       0       1       1       0       0
 
 2  3       1       0       0       0       1
 
 >>> pd.get_dummies(pd.Series(list('abcaa')))
 
    a  b  c
 
 0  1  0  0
 
 1  0  1  0
 
 2  0  0  1
 
 3  1  0  0
 
 4  1  0  0
 
 2.7标签编码（Label encoding）
 
 le = sklearn.preprocessing.LabelEncoder()
 
 le.fit([1, 2, 2, 6])
 
 le.transform([1, 1, 2, 6]) #array([0, 0, 1, 2])
 
 #非数值型转化为数值型
 
 le.fit(["paris", "paris", "tokyo", "amsterdam"])
 
 le.transform(["tokyo", "tokyo", "paris"]) #array([2, 2, 1])
 
 2.8特征中含异常值时
 
 sklearn.preprocessing.robust_scale
 
 2.9生成多项式特征
 
 这个其实涉及到特征工程了，多项式特征/交叉特征。
 
 poly = sklearn.preprocessing.PolynomialFeatures(2)
 
 poly.fit_transform(X)
 
 原始特征：
 
 转化后：
 


 
 3常用指令
 
 #以后调用pandas函数都用pd
 
 import pandas as pd 
 
  
 
 #将matplotlib的图表直接嵌入到Notebook之中，或者使用指定的界面库显示图表
 
 %matplotlib inline
 
  
 
 df = pd.read_csv('文件路径地址/名.csv',header=0,encoding='gbk')
 
 df.head(5)
 
 df.tail(5)
 


 
 3.1对缺失值的处理
 
 #填充缺失值
 
 df.fillna(0)
 
 df.model_id.fillna(-1)
 
 pandas使用isnull()和notnull()函数来判断缺失情况。
 
 对于缺失数据一般处理方法为滤掉或者填充。
 
 滤除缺失数据
 
 对于一个Series，dropna()函数返回一个包含非空数据和索引值的Series，例如：
 
 
 
 
 对于DataFrame，dropna()函数同样会丢掉所有含有空元素的数据，例如：
 
 
 
 
 但是可以指定how='all'，这表示只有行里的数据全部为空时才丢弃，例如：
 
 
 
 
 如果想以同样的方式按列丢弃，可以传入axis=1，例如：
 
  
 
 #将第2列为空的行去掉 
 
 tmp=tmp[-pd.isnull(tmp.iloc[:,2])]
 
  
 
 填充缺失数据
 
 如果不想丢掉缺失的数据而是想用默认值填充这些空洞，可以使用fillna()函数：
 
 
 
 
 如果不想只以某个标量填充，可以传入一个字典，对不同的列填充不同的值：
 
 
 
 


 
 3.2快速描述
 
 df.describe()
 
  
 


 
 3.3返回df的长度
 
 len（df）
 
  
 


 
 3.4赋值
 
 df.loc[:,’a’]=np.array([5]*len(df))#给df赋新列‘a’
 
 df[df>0]=-df
 
 通过定位df.loc  or  df.iloc [,]=1
 
  
 
 3.5设置每列标签，推荐使用第二种。其实可以直接打开编辑，在表头写上标签（直接编辑这个如果不需要多次重复读取数据可以这么干，其他情况尽量不要这么干）。
 
 df.columns = ['water_year','rain_octsep', 'outflow_octsep',
 
 'rain_decfeb','outflow_decfeb','rain_junaug', 'outflow_junaug']
 
 df.rename(columns={'total_bill': 'total', 'tip': 'pit', 'sex': 'xes'}, inplace=True)
 
  
 
 3.6有时你想提取一整列，使用列的标签可以非常简单地做到：
 
 df['rain_octsep']或df.rain_ocstep
 
 注意，当我们提取列的时候，会得到一个 series ，而不是 dataframe 。记得我们前面提到过，你可以把 dataframe 看作是一个 series 的字典，所以在抽取列的时候，我们就会得到一个 series。
 
  
 
 还记得我在命名列标签的时候特意指出的吗？不用空格、破折号之类的符号，这样我们就可以像访问对象属性一样访问数
 
  
 
 3.7返回由【布尔值】构成的dataframe，就是这个标签小于1000和大于1000的信息。
 
 df.rain_octsep < 1000 # Or df['rain_octsep] < 1000  
 
 3.8过滤后，得到的表，信息的筛选
 
 df[df.rain_octsep < 1000]
 
  
 
 3.9选择区域
 
 df[0:3]选择行；df.loc[:,[‘a’,’b’]]通过标签在多个轴上选择
 
 df.loc[0:3,[‘a’,’b’]]标签切片
 
  
 
 #返回索引为xxx字符串的series
 
 df.loc['xxx'] 
 
 df.loc[3,’a’]快速访问标量
 
  
 
 #数据条件筛选，筛选出标签为a内容=x的行series
 
 df.loc[df[‘a’]==’x’]
 
 #保留b,c列筛选外加排序
 
 df.loc[df[‘a’]==’x’,[‘a’,‘b’,’c’]].sort([‘a’],ascending=False)
 
  
 
 #多列数据筛选并排序
 
 df.loc[(df[‘a’]==’x’)&(df[‘b’]>10),[‘a’,’b’,’c’]].sort([‘a’],ascending=False)
 
  
 
 #按筛选条件求和，满足前一条件则对b求和..还有按条件计算均值mean(),max(),min(),count()
 
 df.loc[df[‘a’]==’x’].b.sum()
 
 df.loc[(df[‘a’]==’x’)&(df[‘c’]>10)].b.sum()#就是多条件求和，sumifs
 
  
 
 3.10用isin()方法过滤，确认a列中是否有one、two，有则筛出来
 
 df[df[‘a’].isin([‘one’,’two’])]
 
  
 
 3.11iloc返回固定行的series，非常好用
 
 df.iloc[30]
 
 df.iloc[3]返回行
 
 df.iloc[3:5,1:2]返回某一选片  
 
 df.iloc[[1,2,4],[0,2]]返回特定选片交集  
 
 df.iloc[1:3,:]返回1:3行  
 
 df.iloc[1,2]返回特定位置数据
 
  
 
 3.12设置某标签为索引
 
 df=df.set_index(['xxx'])
 
  
 
 3.13将索引恢复为数据，如果先排序了，再恢复不影响排序结果
 
 df = df.reset_index('xxx')
 
  
 
 3.14排序，True是升序，False是降序，.head(x)选取特定行排序
 
 df.sort_index(ascending=True) 
 
 #对‘a’进行排序
 
 df.sort([‘a’],ascending=False)
 
 df.sort(colums=’a’)
 
 #对多列进行排序
 
 df.sort([‘a’,’b’],ascending=False)
 
  
 
 3.15分组，将某一列标签合并并统计将结果赋给tf，如size（），max、min、mean等函数
 
 #10*10指间隔为10,1000*1000间隔为1000
 
 tf=df.groupby(df.year // 10 *10).max()
 
 decade_rain = df.groupby([df.year // 10 * 10, df.rain_octsep // 1000 * 1000])[['outflow_octsep','outflow_decfeb', 'outflow_junaug']].mean()
 
  
 
 #分别对k1,k2列进行排序,df1,df2都是中间变量类型，为groupby类型，使用推导式【x for x in df1】显示
 
 df1=df.groupby([‘k1’,’k2’])
 
 df2=df.groupby(‘k1’)
 
 
 
 
 
 
 
   
 
 
 
 
 
 
 
 3.16返回数据规模，行和列
 
 df.shape
 
  
 
 3.17返回各列数据格式
 
 df.dtypes
 
  
 
 3.18python输出替代%s替代string，等，‘’%（a，b）后面括号内是几个替代值
 
 print("I'm %s. I'm %d year old" % ('Vamei', 99))
 
  
 
 3.19添加列，除了insert
 
 df[‘new’]=[‘a’,’b’,’c’]
 
  
 
 #插入列,第二个位置，名为‘e’，值=df[‘a’]
 
 df.insert(1,’e’,df[‘a’])
 
  
 
 3.20删除行列,1为列0为行
 
 df2=df.drop([‘a’,’b’],axis=1)
 
  
 
 #输出并删除‘b’列，将b列插入到第一列
 
 b=df.pop(‘b’)
 
 df.insert(0,’b’,b)
 
  
 
 3.21将结果输出成csv
 
 df.to_csv(‘xxx.csv’,index=False,encoding=’utf-8’,)
 
 
 
 
 
path_or_buf：字符串或文件句柄，默认为无
 
文件路径或对象，如果没有提供结果作为字符串返回。
 
sep：character，default'，'
 
输出文件的字段分隔符。
 
na_rep：string，default''
 
缺少数据表示
 
float_format：string，default None
 
格式化浮点数字符串
 
列：序列，可选
 
要写的列
 
标题：布尔或字符串列表，默认为True
 
写出列名。如果给出了一个字符串列表，那么它被认为是列名称的别名
 
index：boolean，默认为True
 
写行名（索引）
 
index_label：字符串或序列，或False，默认为无
 
如果需要，索引列的列标签。如果没有给出，并且 头和索引为True，则使用索引名称。如果DataFrame使用MultiIndex，则应该给出一个序列。如果False不打印索引名称的字段。使用index_label = False更容易在R中导入
 
模式：str
 
Python写入模式，默认'w'
 
encoding：string，可选
 
表示在输出文件中使用的编码的字符串，在Python 2上默认为“ascii”，在Python 3上默认为“utf-8”。
 
压缩：字符串，可选
 
表示在输出文件中使用的压缩字符串的字符串，允许的值为'gzip'，'bz2'，'xz'，仅在第一个参数为文件名时使用
 
line_terminator：string，default'\n'
 
在输出文件中使用的换行字符或字符序列
 
引用：来自csv模块的可选常量
 
默认为csv.QUOTE_MINIMAL。如果您设置了一个float_format， 那么float将被转换为字符串，因此csv.QUOTE_NONNUMERIC将它们视为非数字
 
quotechar：string（length 1），default'“'
 
字符用来引用字段
 
doublequote：boolean，默认为True
 
控制在一个字段内引用quotechar
 
escapechar：string（length 1），default None
 
适当时用于逃避sep和quotechar的字符
 
chunksize：int或None
 
一次写入的行
 
tupleize_cols：boolean，default False
 
将multi_index列作为元组列表（如果为True）或新（扩展格式），如果为False）
 
date_format：string，default无
 
格式为datetime对象的字符串
 
decimal：string，default'。'
 
字符识别为小数分隔符。例如使用'，'为欧洲数据
 
新版本0.16.0。
 
 
  
 
 3.22数据合并
 
 1.merge
 
 merge 函数通过一个或多个键来将数据集的行连接起来。该函数的主要 应用场景是针对同一个主键存在两张包含不同特征的表，通过该主键的连接，将两张表进行合并。合并之后，两张表的行数没有增加，列数是两张表的列数之和减一。 
 函数的具体参数为：
 
 merge(left,right,how='inner',on=None,left_on=None,right_on=None,
 
 left_index=False,right_index=False,sort=False,suffixes=('_x','_y'),copy=True)
 
 · on=None 指定连接的列名，若两列希望连接的列名不一样，可以通过left_on和right_on 来具体指定
 
 · how=’inner’,参数指的是左右两个表主键那一列中存在不重合的行时，取结果的方式：inner表示交集，outer 表示并集，left 和right 表示取某一边。 
 举例如下
 
 import pandas as pd
 
 df1 = pd.DataFrame([[1,2,3],[5,6,7],[3,9,0],[8,0,3]],columns=['x1','x2','x3'])
 
 df2 = pd.DataFrame([[1,2],[4,6],[3,9]],columns=['x1','x4'])
 
 print df1
 
 print df2
 
 df3 = pd.merge(df1,df2,how = 'left',on='x1')
 
 print df3
 
 在这里我分别设置了两个DataFrame类别的变量df1,df2,(平常我们用的表csv文件，读取之后也是DataFrame 格式)。然后我设置 on=’x1’,即以两个表中的x1为主键进行连接，设置how=’left’ ,即是以两个表中merge函数中左边那个表的行为准，保持左边表行数不变，拿右边的表与之合并。结果如下：
 
 
 
 
 
 第一个结果为how=’left’的情况。第二个结果为how=’inner’的情况。 
 注意:在how=’left’设置后，左边行之所以能够保持不变，是因为右边的表主键列没有重复的值，x下面我会举个例子作为思考题： 
 
 
  
 这是两张表，分别为df1,df2;
 
 第一个问题： 
 在默认情况下即merge(df1,df2)其他参数为默认值的返回结果是 什么？ 
 第二个问题： 
 在加上how=’left’之后的返回结果是什么？ 
 看完了问题之后，返回去看这两张表，不着急看答案，仔细想想。
 
  
 
 这两个问题明白之后，表之间的连接和映射应该都能够明白了。
 
 2.concat
 
 concat 与其说是连接，更准确的说是拼接。就是把两个表直接合在一起。于是有一个突出的问题，是横向拼接还是纵向拼接，所以concat 函数的关键参数是axis 。 
 函数的具体参数是：
 
 concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False,keys=None,levels=None,names=None,verigy_integrity=False)
 
 · objs 是需要拼接的对象集合，一般为列表或者字典
 
 · axis=0 是行拼接，拼接之后行数增加，列数也根据join来定，join=’outer’时，列数是两表并集。同理join=’inner’,列数是两表交集。
 
 在默认情况下，axis=0为纵向拼接，此时有
 
 concat([df1,df2]) 等价于 df1.append(df2)
 
 在axis=1 时为横向拼接 ，此时有
 
 concat([df1,df2],axis=1) 等价于 merge(df1,df2,left_index=True,right_index=True,how='outer')
 
 举个例子
 
 import pandas as pd
 
  
 
 df1 = pd.DataFrame({'key':['a','a','b','b'],'data1':range(4)})
 
 print df1
 
 df2 = pd.DataFrame({'key':['b','b','c','c'],'data2':range(4)})
 
 print df2
 
 print pd.concat([df1,df2],axis=1)
 
 print pd.merge(df1,df2,left_index=True,right_index=True,how='outer')
 
  
 
 3.23类别特征编码get_dummy
 
 是一种很实用的将字典中某一列的可能存在的值，多维化映射在对应行，有点像one-hot编码方式，统计该列所有可能存在的值（像sort），作为字典新添加的几个列向量，每一行之前存在哪个值，对应列处值就是1，否则为0。
 
 格式如下：pandas.get_dummies()
 
 参数有：data（数据），prefix（前缀），columns（选择进行处理的列），dummy_na（是否将NaN添加到dummies），drop_first(将统计出来的k个dummies去掉第一个得到k-1个dummies)
 
 举例：import pandas as pd
 
          S=pd.Series(list(‘abca’))
 
  
 
 >>> pd.get_dummies(s)
 
    a  b  c
 
 0  1  0  0
 
 1  0  1  0
 
 2  0  0  1
 
 3  1  0  0
 
 >>> s1 = ['a', 'b', np.nan]
 
 >>> pd.get_dummies(s1)
 
    a  b
 
 0  1  0
 
 1  0  1
 
 2  0  0
 
 >>> pd.get_dummies(s1, dummy_na=True)
 
    a  b  NaN
 
 0  1  0    0
 
 1  0  1    0
 
 2  0  0    1
 
 >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'], 'C': [1, 2, 3]})
 
 >>> pd.get_dummies(df, prefix=['col1', 'col2'])
 
    C  col1_a   col1_b  col2_a  col2_b  col2_c
 
 0  1       1       0       0       1       0
 
 1  2       0       1       1       0       0
 
 2  3       1       0       0       0       1
 
 >>> pd.get_dummies(pd.Series(list('abcaa')))
 
    a  b  c
 
 0  1  0  0
 
 1  0  1  0
 
 2  0  0  1
 
 3  1  0  0
 
 4  1  0  0
 
 >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True))
 
    b  c
 
 0  0  0
 
 1  1  0
 
 2  0  1
 
 3  0  0
 
 4  0  0
 
  
 
 3.24apply函数lambda部分
 
 python的lambda表达式很想swift语言里的Closure闭包，无函数名的语句块，可以指定传入参数、计算结果。
 
 语法格式如下：
    lambda 传入参数 ： 返回的计算表达式
 
 eg1， 求一个数的平方
 >>> g = lambda x : x ** 2
 # x为传入参数， 冒号后的x ** 2为传回表达式
 >>> print g(4)
 16
 >>> def h(x):
 ... return x ** 2
 ...
 >>> print h(4)
 16
 
 
 eg2， 求两数之和
 >>> t = lambda x,y: x +y
 # x和y为传入参数， 冒号后的 x + y为传回值的表达式
 >>> t(2, 4)
 6
 
 eg3，用map 求1...4平方 => 1*1,2*2,3*3,4*4
 map(lambda x : x * x, range(1,5))
 返回值是[1,4,9,16]
 
  
 
 lambda赋值语句是倒装的，0 if x==-1  #令x=0当x==-1时。
 
  
 
  
 
 3.25对多列条件进行apply处理，定义函数
 
 def do_something(x, y):
 
     return x * y
 
 df['new_col'] = map(lambda x, y: do_something(x, y) , df['col_1'], df['col_2'])
 
  
 
 3.26浮点小数四舍五入
 
 round(x,5)#保留小数点后5位
 
 3.27常用时间处理，time、datetime、timedelta
 
 Python其实内置了很多方式处理日期和时间，很方便，在我最初对时间的处理上，简单粗暴的用几位数表示，带来了后续时间间隔计算的各种麻烦，后来忽然发现python已经内置了时间的处理的库。。。
 
 Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
 
 时间间隔是以秒为单位的浮点小数。
 
 每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
 
 Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
 
 #!/usr/bin/python# -*- coding: UTF-8 -*-
 
 import time;  # 引入time模块
 
  
 
 ticks = time.time()print "当前时间戳为:", ticks
 
 以上实例输出结果：
 
 当前时间戳为: 1459994552.51
 
 时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
 
  
 
  
 
 什么是时间元组？很多Python函数用一个元组装起来的9组数字处理时间:
 
 
序号
 
 
字段
 
 
值
 
 
0
 
 
4位数年
 
 
2008
 
 
1
 
 
月
 
 
1 到 12
 
 
2
 
 
日
 
 
1到31
 
 
3
 
 
小时
 
 
0到23
 
 
4
 
 
分钟
 
 
0到59
 
 
5
 
 
秒
 
 
0到61 (60或61 是闰秒)
 
 
6
 
 
一周的第几日
 
 
0到6 (0是周一)
 
 
7
 
 
一年的第几日
 
 
1到366 (儒略历)
 
 
8
 
 
夏令时
 
 
-1, 0, 1, -1是决定是否为夏令时的旗帜
 
 
 
序号
 
 
属性
 
 
值
 
 
0
 
 
tm_year
 
 
2008
 
 
1
 
 
tm_mon
 
 
1 到 12
 
 
2
 
 
tm_mday
 
 
1 到 31
 
 
3
 
 
tm_hour
 
 
0 到 23
 
 
4
 
 
tm_min
 
 
0 到 59
 
 
5
 
 
tm_sec
 
 
0 到 61 (60或61 是闰秒)
 
 
6
 
 
tm_wday
 
 
0到6 (0是周一)
 
 
7
 
 
tm_yday
 
 
1 到 366(儒略历)
 
 
8
 
 
tm_isdst
 
 
-1, 0, 1, -1是决定是否为夏令时的旗帜
 
 
 上述也就是struct_time元组。这种结构具有如下属性：
 
  
 
  
 


 
 获取当前时间
 
 从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
 
 #!/usr/bin/python# -*- coding: UTF-8 -*-
 
 import time
 
  
 
 localtime = time.localtime(time.time())print "本地时间为 :", localtime
 
 以上实例输出结果：
 
 本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
 
  
 
  
 


 
 获取格式化的时间
 
 你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
 
 #!/usr/bin/python# -*- coding: UTF-8 -*-
 
 import time
 
  
 
 localtime = time.asctime( time.localtime(time.time()) )print "本地时间为 :", localtime
 
 以上实例输出结果：
 
 本地时间为 : Thu Apr  7 10:05:21 2016
 
  
 


 
 格式化日期
 
 我们可以使用 time 模块的 strftime 方法来格式化日期，：
 
 time.strftime(format[, t])
 
 #!/usr/bin/python# -*- coding: UTF-8 -*-
 
 import time
 
 # 格式化成2016-03-20 11:45:39形式print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
 # 格式化成Sat Mar 28 22:24:24 2016形式print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
 
   # 将格式字符串转换为时间戳
 
 a = "Sat Mar 28 22:24:24 2016"print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
 
 以上实例输出结果：
 
 2016-04-07 10:25:09Thu Apr 07 10:25:09 20161459175064.0
 
 python中时间日期格式化符号：
 
 · %y 两位数的年份表示（00-99）
 
 · %Y 四位数的年份表示（000-9999）
 
 · %m 月份（01-12）
 
 · %d 月内中的一天（0-31）
 
 · %H 24小时制小时数（0-23）
 
 · %I 12小时制小时数（01-12）
 
 · %M 分钟数（00=59）
 
 · %S 秒（00-59）
 
 · %a 本地简化星期名称
 
 · %A 本地完整星期名称
 
 · %b 本地简化的月份名称
 
 · %B 本地完整的月份名称
 
 · %c 本地相应的日期表示和时间表示
 
 · %j 年内的一天（001-366）
 
 · %p 本地A.M.或P.M.的等价符
 
 · %U 一年中的星期数（00-53）星期天为星期的开始
 
 · %w 星期（0-6），星期天为星期的开始
 
 · %W 一年中的星期数（00-53）星期一为星期的开始
 
 · %x 本地相应的日期表示
 
 · %X 本地相应的时间表示
 
 · %Z 当前时区的名称
 
 · %% %号本身
 
  
 


 
 获取某月日历
 
 Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
 
 #!/usr/bin/python# -*- coding: UTF-8 -*-
 
 import calendar
 
  
 
 cal = calendar.month(2016, 1)print "以下输出2016年1月份的日历:"print cal;
 
 以上实例输出结果：
 
 以下输出2016年1月份的日历:
 
     January 2016Mo Tu We Th Fr Sa Su
 
              1  2  3
 
  4  5  6  7  8  9 1011 12 13 14 15 16 1718 19 20 21 22 23 2425 26 27 28 29 30 31
 
  
 
  
 


 
 Time 模块
 
 
序号
 
 
函数及描述
 
 
1
 
 
time.altzone
 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
 
 
2
 
 
time.asctime([tupletime])
 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
 
 
3
 
 
time.clock( )
 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
 
 
4
 
 
time.ctime([secs])
 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
 
 
5
 
 
time.gmtime([secs])
 接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
 
 
6
 
 
time.localtime([secs])
 接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
 
 
7
 
 
time.mktime(tupletime)
 接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。
 
 
8
 
 
time.sleep(secs)
 推迟调用线程的运行，secs指秒数。
 
 
9
 
 
time.strftime(fmt[,tupletime])
 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
 
 
10
 
 
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
 根据fmt的格式把一个时间字符串解析为时间元组。
 
 
11
 
 
time.time( )
 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
 
 
12
 
 
time.tzset()
 根据环境变量TZ重新初始化时间相关设置。
 
 
 Time 模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：
 
 Time模块包含了以下2个非常重要的属性：
 
 
序号
 
 
属性及描述
 
 
1
 
 
time.timezone
 属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
 
 
2
 
 
time.tzname
 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
 
 
  
 
  
 


 
 日历（Calendar）模块
 
 此模块的函数都是日历相关的，例如打印某月的字符月历。
 
 
序号
 
 
函数及描述
 
 
1
 
 
calendar.calendar(year,w=2,l=1,c=6)
 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
 
 
2
 
 
calendar.firstweekday( )
 返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
 
 
3
 
 
calendar.isleap(year)
 是闰年返回True，否则为false。
 
 
4
 
 
calendar.leapdays(y1,y2)
 返回在Y1，Y2两年之间的闰年总数。
 
 
5
 
 
calendar.month(year,month,w=2,l=1)
 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
 
 
6
 
 
calendar.monthcalendar(year,month)
 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
 
 
7
 
 
calendar.monthrange(year,month)
 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
 
 
8
 
 
calendar.prcal(year,w=2,l=1,c=6)
 相当于 print calendar.calendar(year,w,l,c).
 
 
9
 
 
calendar.prmonth(year,month,w=2,l=1)
 相当于 print calendar.calendar（year，w，l，c）。
 
 
10
 
 
calendar.setfirstweekday(weekday)
 设置每周的起始日期码。0（星期一）到6（星期日）。
 
 
11
 
 
calendar.timegm(tupletime)
 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间辍（1970纪元后经过的浮点秒数）。
 
 
12
 
 
calendar.weekday(year,month,day)
 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。
 
 
 星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：
 
  
 
  
 


 
 其他相关模块和函数
 
 在Python中，其他处理日期和时间的模块还有：
 
 · datetime模块
 
 · pytz模块
 
 · dateutil模块
 
  
 
 欢迎各位童鞋交流和指教！

数据处理的方法
 
在数据分析建模和数据挖掘中，大部分的时间主要都花费在数据处理和分析中。数据的质量直接影响到模型的准确度。下面主要针对数据预处理方面入手整理一些常用的方法。数据预处理分为四步，数据清理、数据变换和变量筛选。
 
一、数据清理
 
主要根据探索性分析后得到的一些结论入手，然后主要对四类异常数据进行处理；分别是缺失值(missing value)，异常值(离群点),去重处理(Duplicate Data)处理。
 1、缺失值
 处理缺失值时，最好事先了解下缺失值得缺失的原因，在某些条件下，缺失值并不是意味着数据有错误。例如：客户征信报告空白，可能不是代表没有抓取过数据，而是客户本来就是白户（即没有发生过借贷和信用卡办理等业务）。了解了数据缺失的原因可以更好的进行数据处理。
 处理缺失值得方法主要有一下几个方法：
 (1)直接删除：当一个变量缺失大于95%以上，且对于因变量重要程度较低时，可以采用直接删除。
 (2)使用特定值填充：当一个属性是类别数据，缺失本身就代表着一种信息，可以采用特定值填充。尽管该方法比较简单，但是并不十分可靠。
 (3)使用中心度量（如均值或中位数）填充。对于正常的对称分布而言，均值填充较好；当数据有偏是用中位数填充。
 (4)使用可能的填充方法（回归模型，决策树，贝叶斯模型法和插补法）。从理论上看这种方法最严谨，但是成本较高。是否采用应该取决于数据挖掘的业务背景和数据资源质量等确定。
 插补法：
 主要的插补法引用大神的讲解方法：
 1>随机插补法–从总体中随机抽取某几个样本代替缺失样本
 2>多重插补法–通过变量之间的关系对缺失数据进行预测，利用蒙特卡洛方法生成多个完整的数据集，在对这些数据集进行分析，最后对分析结果进行汇总处理
 3>热平台插补----指在非缺失数据集中找到一个与缺失值所在样本相似的样本（匹配样本），利用其中的观测值对缺失值进行插补。
 　　优点：简单易行，准确率较高
 　　缺点：变量数量较多时，通常很难找到与需要插补样本完全相同的样本。但我们可以按照某些变量将数据分层，在层中对缺失值实用均值插补
 4>拉格朗日差值法和牛顿插值法
 
2、异常值得判断和处理
 数据样本的异常值是指一个类别变量中某个类别值出现的次数太少，或者一个区间型变量里的某些取值太大等。通常情况下，如果不把异常值处理掉，对于数据分析结论或挖掘模型的效果负面影响较大。
 异常值主要有以下几点
 （1）对于类别变量来说，个别类型出现次数频率太小，太稀少，就可能是异常值。通常情况下占比不到1%或更少的情况下就可能是异常值。但是具体要按照业务情况来定。
 （2）区间变量，对观察的变量进行从小到大的排列，从大的数开始倒推1%查看情况，如果这个和数据中点相距较远，可能就是异常值了。
 在一些场景下，异常值可能就是我们研究的目标，例如欺诈事件等。
 
3、去除重复数据
 通常情况下，我们在分数据需要去除重复的数据，重复的数据会对我们样本的数据结构有影响。但某些情况下不能去重，例如在样本数据不足的情况下，我们采用了重复抽样等。
 
二、数据变换
 
对于数据建模来讲，数据转换时最常见最重要，也是最有效的一种数据处理技术。经过适当的数据转换后，模型型效果常常有比较明显的提升。主要由于原始数据，分布不光滑，不对称。
 常用的转换方法有4类：
 1、产生衍生变量
 所谓的衍生变量是指根据原始变量进行联合变换，例如一段时间的均值，几个变量的比值等。一般这些和业务背景相关性较大。
 2、改善变量分布特征转化
 数据区间分布状态偏差较大，而且严格不对称。常常会干扰模型的弥合，最终影响模型的效果。一般可以通过以下方法进行处理。
 （1）取对数
 （2）开平方根
 （3）取倒数
 （4）平方
 （5）取指数
 3、区间型变量分箱转化
 分箱转换，就是把区间变量转换成次序变量，主要目的是降低变量复杂性，过滤噪音；提高变量的预测能力（分箱恰当可以有效提高自变量和因变量的相关度，尤其是变量和因变量不成现象关系时）
 4、针对区间变量进行标准化处理
 数据标准化将数据按比例缩放，落入一个较小区间，是的变量有可比的基础（去量刚等）。常见的方法有最大最小标准化。方差标准化。
 
三、变量筛选
 
筛选变量可以提高模型稳定性、提高模型的预测能力和提高运算速度和运算效率。
 1、直接删除的变量：
 （1） 常数变量或只有一个值得变量。
 （2）缺失比例较高，如缺失率95%以上等。
 （3）取值太广泛的值，序号等。
 2、结合业务进行筛选
 3、相关性筛选
 |r|<0.3 表示低度相关
 0.3≤|r|<0.5 中低度相关
 0.5≤|r|<0.8 中度相关
 0.8≤|r|<1.0 高度相关
 在建模前的变量筛选过程，如果变量数据0.6 以上的相关，只需保留重要度较高的变量即可。
 4、R平方
 R^2 该方法借鉴多元线性回归分析算法来判断和选择目标变量对预测意义和价值的自变量。表示变量在多大程度上可以解释目标变量的可变性。
 5、卡方检验
 主要来衡量类别变量，包括次序变量等定性变量之间的关联性以及比较两个或以上的样本率。
 6、IV和WOE
 当目标是二元变量是，自变量是区间变量是，可以用IV和woe来对自变量判断和取舍。
 7、算法模型自身的筛选功能
 8、降维方法
 
数据的主要清洗方法如上，部分记录较为简单和疏漏的地方，进一步改进。

 
数据挖掘中数据预处理方法
 
In the previous article, we have discussed the Data Exploration with which we have started a detailed journey towards data mining. We have learnt about Data Exploration, Statistical Description of Data, Concept of Data Visualization & Various technique of Data Visualization.
 
 
 在上一篇文章中，我们讨论了数据探索，并由此开始了详细的数据挖掘之旅。 我们已经了解了数据探索 ，数据统计描述，数据可视化的概念以及各种数据可视化技术。 
 
 
In this article we will be discussing,
 
 
 在本文中，我们将讨论 
 
 
Need of Data Preprocessing
 需要数据预处理 
Data Cleaning Process
 数据清理流程 
Data Integration Process
 数据整合流程 
Data Reduction Process
 数据缩减流程 
Data Transformation Process
 数据转换过程 
 
 1)需要数据预处理 (1) Need of Data Preprocessing)
 
 
Data preprocessing refers to the set of techniques implemented on the databases to remove noisy, missing, and inconsistent data. Different Data preprocessing techniques involved in data mining are data cleaning, data integration, data reduction, and data transformation.
 
 
 数据预处理是指在数据库上实施的用于消除噪声，丢失和不一致数据的技术集。 数据挖掘中涉及的不同数据预处理技术是数据清理，数据集成，数据缩减和数据转换。 
 
 
The need for data preprocessing arises from the fact that the real-time data and many times the data of the database is often incomplete and inconsistent which may result in improper and inaccurate data mining results. Thus to improve the quality of data on which the observation and analysis are to be done, it is treated with these four steps of data preprocessing. More the improved data, More will be the accurate observation and prediction.
 
 
 数据预处理的需求源于以下事实：实时数据以及很多时候数据库的数据通常不完整且不一致，这可能导致数据挖掘结果不正确和不准确。 因此，为了提高要进行观察和分析的数据的质量，可以通过数据预处理的这四个步骤对其进行处理。 改进的数据越多，准确的观察和预测就越多。 
 
 
  

   
  
  
 
  

  
Fig 1: Steps of Data Preprocessing
 
  
 图1：数据预处理步骤 
 
 
 
 2)数据清理流程 (2) Data Cleaning Process)
 
 
Data in the real world is usually incomplete, incomplete and noisy. The data cleaning process includes the procedure which aims at filling the missing values, smoothing out the noise which determines the outliers and rectifies the inconsistencies in data. Let us discuss the basic methods of data cleaning,
 
 
 现实世界中的数据通常不完整，不完整且嘈杂。 数据清除过程包括旨在填补缺失值，消除噪声的过程，该噪声确定了异常值并纠正了数据中的不一致之处。 让我们讨论数据清理的基本方法， 
 
 
2.1. Missing Values
 
 
 2.1。 缺失值 
 
 
Assume that you are dealing with any data like sales and customer data and you observe that there are several attributes from which the data is missing. One cannot compute data with missing values. In this case, there are some methods which sort out this problem. Let us go through them one by one,
 
 
 假设您正在处理任何数据(例如销售和客户数据)，并且发现缺少一些属性。 不能计算缺少值的数据。 在这种情况下，有一些方法可以解决此问题。 让我们一一讲解 
 
 
2.1.1. Ignore the tuple:
 
 
 2.1.1。 忽略元组： 
 
 
If there is no class label specified then we could go for this method. It is not effective in the case if the percentage of missing values per attribute changes considerably.
 
 
 如果未指定类标签，则可以使用此方法。 如果每个属性的缺失值百分比发生很大变化，则此方法无效。 
 
 
2.1.2. Enter the missing value manually or fill it with global constant:
 
 
 2.1.2。 手动输入缺少的值或用全局常数填充它： 
 
 
When the database contains large missing values, then filling manually method is not feasible. Meanwhile, this method is time-consuming. Another method is to fill it with some global constant.
 
 
 当数据库包含较大的缺失值时，手动填充方法不可行。 同时，此方法很耗时。 另一种方法是用一些全局常数填充它。 
 
 
2.1.3. Filling the missing value with attribute mean or by using the most probable value:
 
 
 2.1.3。 使用属性均值或使用最可能的值来填充缺失值： 
 
 
Filling the missing value with attribute value can be the other option. Filling with the most probable value uses regression, Bayesian formulation or decision tree.
 
 
 用属性值填充缺失值可以是另一种选择。 用回归，贝叶斯公式或决策树填充最可能的值。 
 
 
2.2. Noisy Data
 
 
 2.2。 噪音数据 
 
 
Noise refers to any error in a measured variable. If a numerical attribute is given you need to smooth out the data by eliminating noise. Some data smoothing techniques are as follows,
 
 
 噪声是指测量变量中的任何误差。 如果给定了数字属性，则需要通过消除噪声来平滑数据。 一些数据平滑技术如下， 
 
 
2.2.1. Binning:
 
 
 2.2.1。 装箱： 
 
 
Smoothing by bin means: In smoothing by bin means, each value in a bin is replaced by the mean value of the bin.
 按bin方式进行平滑：在按bin方式进行平滑处理中，将bin中的每个值替换为bin的平均值。 
Smoothing by bin median: In this method, each bin value is replaced by its bin median value.
 按bin中值进行平滑 ：在这种方法中，每个bin值都将替换为其bin中值。 
Smoothing by bin boundary: In smoothing by bin boundaries, the minimum and maximum values in a given bin are identified as the bin boundaries. Every value of bin is then replaced with the closest boundary value.
 按bin边界进行平滑：在按bin边界进行平滑处理中，将给定bin中的最小值和最大值标识为bin边界。 然后将bin的每个值替换为最接近的边界值。 
 
Let us understand with an example,
 
 
 让我们以一个例子来理解， 
 
 
Sorted data for price (in dollars): 4, 8, 9, 15, 21, 21, 24, 25, 26, 28, 29, 34
 
 
 价格排序数据(美元)：4、8、9、15、21、21、24、25、26、28、29、34 
 
 
    Smoothing by bin means:
          - Bin 1: 9, 9, 9, 9
          - Bin 2: 23, 23, 23, 23
          - Bin 3: 29, 29, 29, 29

    Smoothing by bin boundaries:
          - Bin 1: 4, 4, 4, 15
          - Bin 2: 21, 21, 25, 25
          - Bin 3: 26, 26, 26, 34

    Smoothing by bin median:
          - Bin 1: 9 9, 9, 9
          - Bin 2: 24, 24, 24, 24
          - Bin 3: 29, 29, 29, 29


 
2.2.2. Regression:
 
 
 2.2.2。 回归： 
 
 
Regression is used to predict the value. Linear regression uses the formula of a straight line which predicts the value of y on the specified value of x whereas multiple linear regression is used to predict the value of a variable is predicted by using given values of two or more variables.
 
 
 回归用于预测值。 线性回归使用直线公式来预测y在x的指定值上的值，而多元线性回归用于预测变量的值是通过使用两个或多个变量的给定值来预测的。 
 
 
 3)数据整合过程 (3) Data Integration Process)
 
 
Data Integration is a data preprocessing technique that involves combining data from multiple heterogeneous data sources into a coherent data store and supply a unified view of the info. These sources may include multiple data cubes, databases or flat files.
 
 
 数据集成是一种数据预处理技术，涉及将来自多个异构数据源的数据组合到一个一致的数据存储中，并提供信息的统一视图。 这些源可能包括多个数据多维数据集，数据库或平面文件。 
 
 
3.1. Approaches
 
 
 3.1。 方法 
 
 
There are mainly 2 major approaches for data integration – one is "tight coupling approach" and another is the "loose coupling approach".
 
 
 数据集成主要有2种主要方法-一种是“紧密耦合方法” ，另一种是“松散耦合方法” 。 
 
 
Tight Coupling:
 
 
 紧耦合： 
 
 
Here, a knowledge warehouse is treated as an information retrieval component.
 
 
 在这里，知识仓库被视为信息检索组件。 
 
 
In this coupling, data is combined from different sources into one physical location through the method of ETL – Extraction, Transformation, and Loading.
 
 
 在这种耦合中，通过ETL(提取，转换和加载)方法将数据从不同源组合到一个物理位置。 
 
 
Loose Coupling:
 
 
 松耦合： 
 
 
Here, an interface is as long as it takes the query from the user, transforms it during away the source database can understand then sends the query on to the source databases to get the result. And the data only remains within the actual source databases.
 
 
 在这里，接口只要它从用户那里获取查询，并在源数据库可以理解的时间内对其进行转换，然后将查询发送到源数据库以获取结果。 并且数据仅保留在实际的源数据库中。 
 
 
3.2. Issues in Data Integration
 
 
 3.2。 数据集成中的问题 
 
 
There are not any issues to think about during data integration: Schema Integration, Redundancy, Detection and determination of knowledge value conflicts. These are explained in short as below,
 
 
 数据集成期间没有任何问题可考虑：架构集成，冗余，知识值冲突的检测和确定。 这些简述如下： 
 
 
3.1.1. Schema Integration:
 
 
 3.1.1。 模式集成： 
 
 
Integrate metadata from different sources.
 
 
 集成来自不同来源的元数据。 
 
 
The real-world entities from multiple sources are matched mentioned because of the entity identification problem.
 
 
 由于实体标识问题，提到了来自多个来源的真实实体。 
 
 
For example, How can the info analyst and computer make certain that customer id in one database and customer number in another regard to an equivalent attribute.
 
 
 例如，信息分析师和计算机如何才能确定一个数据库中的客户ID和其他方面的客户编号是否具有等效属性。 
 
 
3.2.2. Redundancy:
 
 
 3.2.2。 冗余： 
 
 
An attribute could also be redundant if it is often derived or obtaining from another attribute or set of the attribute.
 
 
 如果某个属性通常是从另一个属性或该属性的集合派生或获取的，则它也可能是多余的。 
 
 
Inconsistencies in attribute also can cause redundancies within the resulting data set.
 
 
 属性不一致还会导致结果数据集内的冗余。 
 
 
Some redundancies are often detected by correlation analysis.
 
 
 经常通过相关分析来检测一些冗余。 
 
 
3.3.3. Detection and determination of data value conflicts:
 
 
 3.3.3。 检测和确定数据值冲突： 
 
 
This is the third important issues in data integration. Attribute values from another different source may differ for an equivalent world entity. An attribute in one system could also be recorded at a lower level abstraction than the "same" attribute in another.
 
 
 这是数据集成中的第三个重要问题。 对于等效的世界实体，来自另一个不同来源的属性值可能有所不同。 与另一个系统中的“ same”属性相比，一个系统中的属性也可以以较低的抽象级别记录。 
 
 
 4)数据缩减流程 (4) Data Reduction Process)
 
 
Data warehouses usually store large amounts of data the data mining operation takes a long time to process this data. The data reduction technique helps to minimize the size of the dataset without affecting the result. The following are the methods that are commonly used for data reduction,
 
 
 数据仓库通常存储大量数据，数据挖掘操​​作需要很长时间才能处理此数据。 数据缩减技术有助于在不影响结果的情况下最小化数据集的大小。 以下是通常用于数据缩减的方法， 
 
 
Data cube aggregation
 数据立方体聚合 
 
Refers to a method where aggregation operations are performed on data to create a data cube, which helps to analyze business trends and performance.
 指对数据执行聚合操作以创建数据多维数据集的方法，该方法有助于分析业务趋势和性能。 
 
Attribute subset selection
 属性子集选择 
 
Refers to a method where redundant attributes or dimensions or irrelevant data may be identified and removed.
 指可以识别和删除冗余属性或尺寸或不相关数据的方法。 
 
Dimensionality reduction
 降维 
 
Refers to a method where encoding techniques are used to minimize the size of the data set.
 指的是一种使用编码技术来最小化数据集大小的方法。 
 
Numerosity reduction
 减少雾度 
 
Refers to a method where smaller data representation replaces the data.
 指的是较小的数据表示替换数据的方法。 
 
Discretization and concept hierarchy generation
 离散化和概念层次生成 
 
Refers to methods where higher conceptual values replace raw data values for attributes. Data discretization is a type of numerosity reduction for the automatic generation of concept hierarchies.
 指的是较高的概念值替换属性的原始数据值的方法。 数据离散化是一种用于自动生成概念层次结构的数量减少方法。 
 
 
 5)数据整合流程 (5) Data Integration Process)
 
 
In data transformation process data are transformed from one format to a different format, that's more appropriate for data processing.
 
 
 在数据转换过程中，数据从一种格式转换为另一种格式，这更适合数据处理。 
 
 
Some Data Transformation Strategies,
 
 
 一些数据转换策略， 
 
 
Smoothing
 平滑处理 
 
Smoothing may be a process of removing noise from the info.
 平滑可能是从信息中消除噪音的过程。 
 
Aggregation
 聚合 
 
Aggregation may be a process where summary or aggregation operations are applied to the info.
 汇总可以是将摘要或汇总操作应用于信息的过程。 
 
Generalization
 概括 
 
In generalization, low-level data are replaced with high-level data by using concept hierarchies climbing.
 一般而言，通过使用概念层次爬升将低层数据替换为高层数据。 
 
Normalization
 正常化 
 
Normalization scaled attribute data so on fall within a little specified range, such as 0.0 to 1.0.
 归一化缩放属性数据等等都落在一个较小的指定范围内，例如0.0到1.0。 
 
Attribute Construction
 属性构造 
 
In Attribute construction, new attributes are constructed from the given set of attributes.
 在属性构造中，从给定的属性集中构造新的属性。 
 
 

  
翻译自: https://www.includehelp.com/basics/data-preprocessing-in-data-mining.aspx
 
 
数据挖掘中数据预处理方法

以下是基于Python_sklearn来实现的：
 
No1.标准化（Standardization or Mean Removal and Variance Scaling） 
 变换后各维特征有0均值，单位方差。也叫z-score规范化（零均值规范化）。计算方式是将特征值减去均值，除以标准差。
 
>>> from sklearn import preprocessing 
>>> X=[[1.,-1.,2.],
       [2.,0.,0.],
       [0.,1.,-1.]]
>>> X_scaled = preprocessing.scale(X)
>>> X_scaled
array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])     
 
scale处理之后为零均值和单位方差：
 
>>> X_scaled.mean(axis=0)
array([ 0.,  0.,  0.])
>>> X_scaled.std(axis=0)
array([ 1.,  1.,  1.])  
 
同样我们也可以通过preprocessing模块提供的StandardScaler 工具类来实现这个功能： 
 
>>> scaler = preprocessing.StandardScaler().fit(X)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)
>>> scaler.mean_
array([ 1.        ,  0.        ,  0.33333333])
>>> scaler.std_
array([ 0.81649658,  0.81649658,  1.24721913])
>>> scaler.transform(X)
array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])
 
简单来说，我们一般会把train和test集放在一起做标准化，或者在train集上做标准化后，用同样的标准化器去标准化test集，此时可以用scaler :
 
>>> scaler = sklearn.preprocessing.StandardScaler().fit(train)
>>> scaler.transform(train)
>>> scaler.transform(test)
 
No2.最小-最大规范化（Scaling features to a range） 
 最小-最大规范化对原始数据进行线性变换，变换到[0,1]区间（也可以是其他固定最小最大值的区间）。通过MinMaxScaler or MaxAbsScaler来实现。
 
>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[ 0.5       ,  0.        ,  1.        ],
       [ 1.        ,  0.5       ,  0.33333333],
       [ 0.        ,  1.        ,  0.        ]])
 
简单来说：
 

>>> min_max_scaler = sklearn.preprocessing.MinMaxScaler()
>>> min_max_scaler.fit_transform(X_train)
 
No3.Scaling data with outliers 
 当特征中含异常值时：
 
>>> sklearn.preprocessing.robust_scale
 
Scaling sparse data
 
No4.规范化（Normalization） 
 规范化是将不同变化范围的值映射到相同的固定范围，常见的是[0,1]，此时也称为归一化。Normalize 有L1和L2两个标准。
 
>>> X = [[ 1., -1., 2.],
     [ 2., 0., 0.],
     [ 0., 1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')
>>> X_normalized
array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
>>> normalizer = preprocessing.Normalizer().fit(X) # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')
>>> normalizer.transform(X)
array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
>>> normalizer.transform([[-1., 1., 0.]])
array([[-0.70710678,  0.70710678,  0.        ]])
 
简单来说，将每个样本变换成unit norm:
 
>>> X = [[ 1, -1, 2],[ 2, 0, 0], [ 0, 1, -1]]
>>> sklearn.preprocessing.normalize(X, norm='l2')
 
得到：
 
array([[ 0.40, -0.40, 0.81], [ 1, 0, 0], [ 0, 0.70, -0.70]])
 
可以发现对于每一个样本都有，0.4^2+0.4^2+0.81^2=1,这就是L2 norm，变换后每个样本的各维特征的平方和为1。类似地，L1 norm则是变换后每个样本的各维特征的绝对值和为1。还有max norm，则是将每个样本的各维特征除以该样本各维特征的最大值。 
 在度量样本之间相似性时，如果使用的是二次型kernel，需要做Normalization。而且，normalize and Normalizer接受scipy密集的数组类和稀疏矩阵。
 
No5.特征二值化（Binarization） 
 特征二值化阈值的过程即将数值型数据转化为布尔型的二值数据，可以设置一个阈值（threshold）。即给定阈值，将特征转换为0/1。
 
>>> X = [[ 1., -1., 2.],
     [ 2., 0., 0.],
     [ 0., 1., -1.]]
>>> binarizer = preprocessing.Binarizer().fit(X) # fit does nothing
>>> binarizer
Binarizer(copy=True, threshold=0.0) # 默认阈值为0.0
>>> binarizer.transform(X)
array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])
>>> binarizer = preprocessing.Binarizer(threshold=1.1) # 设定阈值为1.1
>>> binarizer.transform(X)
array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])
 
简单来说：
 
>>> binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
 
normalize and Normalizer接受scipy密集的数组类和稀疏矩阵。
 
No6.类别特征编码（Encoding categorical features） 
 有时候特征是类别型的，而一些算法的输入必须是数值型，此时需要对其编码。
 
>>> enc = preprocessing.OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])  
OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
       handle_unknown='error', n_values='auto', sparse=True)
>>> enc.transform([[0, 1, 3]]).toarray()
array([[ 1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  1.]])
 
简单来说：
 
>>> enc = preprocessing.OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
>>> enc.transform([[0, 1, 3]]).toarray()  #array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])
 
其实可以通过从字典加载特征来实现上面的思想：
 
>>>measurements = [
    {'city': 'Dubai', 'temperature': 33.},
    {'city': 'London', 'temperature': 12.},
    {'city': 'San Fransisco', 'temperature': 18.},
    ]
>>> from sklearn.feature_extraction import DictVectorizer
array([[  1.,   0.,   0.,  33.],       [  0.,   1.,   0.,  12.],       [  0.,   0.,   1.,  18.]])
>>> vec.get_feature_names()
['city=Dubai', 'city=London', 'city=San Fransisco', 'temperature']
 
No7.标签编码（Label encoding）
 
>>> le = sklearn.preprocessing.LabelEncoder()  
>>> le.fit([1, 2, 2, 6]) 
>>> le.transform([1, 1, 2, 6])  #array([0, 0, 1, 2]) 
>>> #非数值型转化为数值型
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
>>> le.transform(["tokyo", "tokyo", "paris"])  #array([2, 2, 1])
 
No8.标签二值化（Label binarization） 
 LabelBinarizer通常通过一个多类标签（label）列表，创建一个label指示器矩阵
 
>>> lb = preprocessing.LabelBinarizer()
>>> lb.fit([1, 2, 6, 4, 2])
LabelBinarizer(neg_label=0, pos_label=1)
>>> lb.classes_
array([1, 2, 4, 6])
>>> lb.transform([1, 6])
array([[1, 0, 0, 0],
       [0, 0, 0, 1]])
 
LabelBinarizer也支持每个实例数据显示多个标签（label）
 
>>> lb.fit_transform([(1, 2), (3,)]) #(1,2)实例中就包含两个label
array([[1, 1, 0],
       [0, 0, 1]])
>>> lb.classes_
array([1, 2, 3])
 
No9.生成多项式特征（Generating polynomial features） 
 这个其实涉及到特征工程了，多项式特征/交叉特征。
 
>>> poly = sklearn.preprocessing.PolynomialFeatures(2)
>>> poly.fit_transform(X)
 
原始特征： 
 转化后为：
 
References： 
 [1]http://scikit-learn.org/stable/modules/preprocessing.html#scaling-sparse-data 
 [2]http://2hwp.com/2016/02/03/data-preprocessing/