学机器学习，不会数据处理怎么行？—— 二、Pandas详解

在上篇文章学机器学习，不会数据处理怎么行？—— 一、NumPy详解中，介绍了NumPy的一些基本内容，以及使用方法，在这篇文章中，将接着介绍另一模块——Pandas。（本文所用代码在这里）

Pandas数据结构介绍

大家应该都听过表结构，但是，如果让你自己来实现这么一个结构，并且能对其进行数据处理，能实现吗？我相信，大部分人都能做出来，但是不一定能做的很好。而Python中的一个模块pandas给我们提供了一个很好的数据结构，它包括了序列Series和数据框DataFrame。pandas是基于NumPy数组构建的，特别是基于数组的函数和不使用for循环的数据处理，让以Numpy为中心的应用变得更加简单。

Series

创建方式

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成，其创建主要有三种方式

1）通过一维数组创建序列

import numpy as np
import pandas as pd
arr1 = np.arange(10)
s1 = pd.Series(arr1)

通过type函数可查看arr1与s1的类型分别为，numpy.ndarray 和 pandas.core.series.Series。

3）通过字典的方式创建

dic1 = {'a': 1,'b': 2,'c': 3,'d': 4,'e': 50}
s2 = pd.Series(dic1)

通过type函数可查看dic1与s2的类型分别为，dict 和 pandas.core.series.Series。

3）通过DataFrame中的某一行或者某一列创建序列

这一步将在下面讲DataFrame的时候再补充

Series索引

我们上面在创建Series序列时，可以输出查看我们创建的Series长什么样，发现有两列，第二列的数据跟我们输入的是一样的，那第一列是什么呢？那就是索引。Series的字符串表现形式为：索引在左边，值在右边。如果我们没有为数据指定索引，就会自动创建一个0到N-1（N为数据的长度）的整数型索引。

我们可以通过 Series 的 values 和 index 属性获取其数组表示形式和索引对象。

obj = pd.Series([6, 9, -8, 1])
obj.values
obj.index

我们也能修改其索引

obj.index = ['a','b','c','d']

讲了那么多，知道这是索引了，但它有什么用呢?

1.我们可以通过索引值或索引标签进行数据的获取

obj['a']
obj[3]
obj[[0,2,3]]
obj[0:2]
obj['a':'c']

注：若通过索引标签获取数据的话，末端标签对应的值也将返回！！！

2.自动化对齐

如果有两个序列，需要对这两个序列进行算术运算，这时索引的存在就体现的它的价值了—自动化对齐.

obj1 = pd.Series(np.array([10,15,20,30,55,80]),index = ['a','b','c','d','e','f'])
obj2 = pd.Series(np.array([12,11,13,15,14,16]),index = ['a','c','g','b','d','f'])
obj1+obj2
obj1*obj2

我们会发现，计算后的序列号中，g和e对应的值为NaN，这是因为obj1中没有g索引，obj2中没有e索引，所以数据的运算会产生两个缺失值NaN。

DataFrame

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典。

创建方式

1）通过二维数组创建

arr2 = np.array(np.arange(12).reshape(4,3))
df1 = pd.DataFrame(arr2)

2）通过字典的方式创建

该方式可通过字典列表和嵌套字典实现，如果将嵌套字典传给DataFrame，pandas就会被解释为：外层字典的键作为列，内层键则作为行索引

#字典列表
dic2 = {'a': [1, 2, 3, 4],'b': [5, 6, 7, 8],'c': [9, 10, 11, 12],'d': [13, 14, 15, 16]}
df2 = pd.DataFrame(dic2)
 
#嵌套字典
dic3 = {'one': {'a': 1,'b': 2,'c': 3,'d':4},
        'two': {'a': 5,'b': 6,'c': 7,'d': 8},
        'three':{'a': 9,'b': 10,'c': 11,'d':12}}
df3 = pd.DataFrame(dic3)

3）通过数据框的方式创建

df4 = df3[['one','three']]
 
s3 = df4['one']

DataFrame索引

DataFrame的索引与Series的索引大体上是一样的，不过DataFrame有两个索引，分别是列索引和行索引，感觉看起来就跟excel差不多了。具体的实现方式可通过下面的部分来了解。

利用pandas进行数据处理

pandas可以通过布尔索引有针对的选取原数据的子集、指定行、指定列等，同时我们可以通过 pd.read_csv()来导入数据集，因为暂时找不到数据集，就从别人的代码里复制一些过来了

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)

选择数据

简单筛选

我们可以使用以下函数来查询数据的前几行或后几行（默认5行）

frame.head()
frame.tail()

也可以使用行列索引来简单地查询指定的行和列

frame['state']
frame[0:3]

loc

当然，上面的方式只是比较简单的操作，复杂些的，我们可以通过 loc 来选取数据（: 表示所有行）

frame.loc[:,['state','year']]

iloc

另外，我们也可以使用iloc，通过位置选择在不同情况下所需要的数据，可进行选取某个数据、连续或者跨行选择等操作

frame.iloc[0:2,0:2]

ix

除此之外还有一种操作方式，使用 混合选择 ix ，我这里的表可能无法很好的体现，如果将行索引改为字符就可以看出来了

frame.ix[3:5,['year']]

发现输入这行代码运行之后发出一条警告

DeprecationWarning:
.ix is deprecated. Please use
.loc for label based indexing or
.iloc for positional indexing

emmmmm。。想想以后主要还是用 loc 和 iloc 好了。

通过判断的筛选

除了上面讲的之外，我们还可以通过判断指令进行选择，即通过约束某项条件然后选择出当前所有数据。

frame[frame['year']>2001]

数据修改

讲完了数据选择，既然选择出了数据，我们可能会想去修改数据，那么，怎么修改呢？

根据位置

我们可以利用索引或者标签确定需要修改的位置

frame.iloc[0,2]=1.6
frame.loc[1,'pop']=2

根据条件

如果我们想将数据中'pop'栏小于1.7的'year'改为1999，那么我们可以进行如下操作

frame.year[frame['pop']<1.7]=1999

按行或按列设置

我们还可以对行列进行批处理

frame['pop']=2.6

添加和删除数据

上面讲的都是数据的修改，再来讲讲数据的添加和删除

#数据添加
#方法一
frame['A'] = np.nan
#方法二
frame['B'] = pd.Series([1, 2, 3, 4, 5, 6])
 
#数据删除
frame.drop('B',axis = 1)

注：

• 对于方法二，长度必须对齐，如果行索不为默认则需指定索引

dates = pd.date_range('', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
df['E'] = pd.Series([1, 2, 3, 4, 5, 6],index=pd.date_range('',periods=6))

• 对于数据删除，axis取值 0表示删除行索引 1表示删除列索引 默认为0

统计分析

pandas模块为我们提供了非常多的描述性统计分析的指标函数，如总和、均值、最小值、最大值等，跟对应的NumPy数组方法相比，它们都是基于没有缺失数据的假设而构建的，下图中列举了大部分函数

这里有几点需要注意

• descirbe函数只能针对序列或者数据框，一维数组是没有这个方法的。
• 使用sum时，NaN值会自动被排除，除非整个切片都是NaN，通过skipna选项可以禁用该功能。
• 调用sum时，返回的时含有列的和的Series，需要传入axis的值才会进行行运算

当我们要对一列数据进行分析时，我们可以将要分析的内容封装成一个函数，方便调用

def stats(x):
    return pd.Series([x.count(),x.min(),x.idxmin(),
    x.quantile(.25),x.median(),
    x.quantile(.75),x.mean(),
    x.max(),x.idxmax(),
    x.mad(),x.var(),
    x.std(),x.skew(),x.kurt()],
    index = ['Count','Min','Whicn_Min',
    'Q1','Median','Q3','Mean',
    'Max','Which_Max','Mad',
    'Var','Std','Skew','Kurt'])

有时或许会需要对一个数据框进行分析，那该如何操作？是一列一列不断地取出来然后调用函数吗？这个方法也不是不可行，但面对众多数据时该怎么办？一个一个调用怕不是要弄到明年，在这里我们可以使用apply函数

d1 = pd.Series(2*np.random.normal(size = 100)+3)
d2 = np.random.f(2,4,size = 100)
d3 = np.random.randint(1,100,size = 100)
df = pd.DataFrame(np.array([d1,d2,d3]).T,columns=['x1','x2','x3'])
df.head()
df.apply(stats)

就这样很简单的创建了数值型数据的统计性描述。但如果是离散型数据呢？就不能用这个统计口径了，我们需要统计离散变量的观测数、唯一值个数、众数水平及个数。你只需要使用describe方法就可以实现这样的统计了。

缺失值处理

现实生活中的数据是非常杂乱的，其中缺失值也是非常常见的，对于缺失值的存在可能会影响到后期的数据分析或挖掘工作，那么我们该如何处理这些缺失值呢？常用的有三大类方法，即删除法、填补法和插值法。

删除法：当数据中的某个变量大部分值都是缺失值，可以考虑删除改变量；当缺失值是随机分布的，且缺失的数量并不是很多是，也可以删除这些缺失的观测。
替补法：对于连续型变量，如果变量的分布近似或就是正态分布的话，可以用均值替代那些缺失值；如果变量是有偏的，可以使用中位数来代替那些缺失值；对于离散型变量，我们一般用众数去替换那些存在缺失的观测。
插补法：插补法是基于蒙特卡洛模拟法，结合线性模型、广义线性模型、决策树等方法计算出来的预测值替换缺失值。

删除法

这里仅讲述删除法和替补法，先来看删除法，先建立一个6X4的矩阵数据并且把两个位置置为空

dates = pd.date_range('', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan

我们可以结合sum函数和isnull函数来检测数据中含有多少缺失值

for i in df.columns:
    print(sum(pd.isnull(df[i])))

也可以通过any来判断是否存在缺失值

np.any(df.isnull()) == True  

删除直接dropna就行了

df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作 默认为0
    how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 默认为'any'
    ) 

填补法

简单粗暴的办法就是把所有的NaN用0代替

df.fillna(value=0)

稍微好一点的方法，使用常量填充不同的列

df.fillna({'B': 3,'C': 4})

还算好的方法，采用前项填充或后向填充

df.fillna(method = 'ffill') #用前一个观测值填充
df.fillna(method = 'bfill') #用后一个观测值填充

较好的方法，用均值或中位数填充各自的列

df.fillna(df.median())
df.fillna(df.mean())

很显然，在使用填充法时，相对于常数填充或前项、后项填充，使用各列的众数、均值或中位数填充要更加合理一点，这也是工作中常用的一个快捷手段。

注：使用fillna,dropna时，需要添加参数 inplace = True，如df.fillna(df.median()，inplace = True),以确认修改，否则实际的数据并不会有改动。

数据合并

concat

pandas 处理多组数据的时候往往会要用到数据的合并处理,使用 concat 是一种基本的合并方式.而且concat中有很多参数可以调整,合并成你想要的数据形式.

先创建数据集

df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])

concat合并

pd.concat([df1, df2, df3], axis=0) #纵向合并
pd.concat([df1, df2, df3], axis=1) #横向合并

这里观察下纵向合并的输出，会发现index的值为0,1,2,0,1,2,0,1,2,大部分情况下，这肯定不是我们想要的，我们可以通过一下方法来重置index

pd.concat([df1, df2, df3], axis=0, ignore_index=True)

pandas中的数据结构是支持类似SQL的部分操作方式的，如添加新行新列、多表连接、聚合什么的。pandas有个join参数，用来定义连接方式的，默认为outer，此方式是依照column来做纵向合并有相同的column上下合并在一起，其他的独自成列，没有的值用NaN填充

df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
res = pd.concat([df1, df2], axis=0, join='outer')#纵向"外"合并df1与df2

参数：

• axis 表示行或列，0为行，1为列
• join 'inner':内连接，会产生NaN的列丢弃 ‘outer’：外连接，上面介绍过了

另外，还有join_axes也可以决定连接方式

pd.concat([df1, df2], axis=1, join_axes=[df1.index])
pd.concat([df1, df2], axis=1, join_axes=[df2.index])

运行上面两行代码，就会发现有所不同，第一行是以df1的index为依据，将df2中具有相同索引的行对应拼接上去，第二行同样的道理。

此外，还有append操作，该操作类似与axis=0，join='outer'时的操作，不过要注意的是append只有纵向合并。

merge

pandas中的合并操作除了concat之外，还有merge操作，主要用于两组有key column的数据,统一索引的数据. 通常也被用在Database的处理当中.

看个简单的，依据一组Key合并

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                              'C': ['C0', 'C1', 'C2', 'C3'],
                              'D': ['D0', 'D1', 'D2', 'D3']})
pd.merge(left, right, on='key')

稍微难一点就是依据两组Key合并，合并时有四种方法 how=['left','right','outer','inner'],默认为how='inner'

left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                      'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                       'key2': ['K0', 'K0', 'K0', 'K0'],
                       'C': ['C0', 'C1', 'C2', 'C3'],
                       'D': ['D0', 'D1', 'D2', 'D3']})
 
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
 
res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
 
res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
 
res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)

都试一试然后输出就知道是如何操作的了。

上面讲的是以列索引为标准进行合并，当然，我们还可以以index为标准进行合并

left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                     index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                      'D': ['D0', 'D2', 'D3']},
                     index=['K0', 'K2', 'K3'])
 
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
 
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)

聚合和分组

pandas提供了一个灵活高效的groupby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。根据一个或多个键（可以是函数、数组或DataFrame列名）拆分pandas对象。计算分组摘要统计，如计数、平均值、标准差，或用户自定义函数。

根据列索引分组

df = pd.DataFrame({'key1':['a', 'a', 'b', 'b', 'a'],
        'key2':['one', 'two', 'one', 'two', 'one'],
        'data1':np.random.randn(5),
        'data2':np.random.randn(5)})
df['data1'].groupby(df['key1']).mean()

这里我们按照key1将数据分组，然后计算分组后的data1的平均值。

我们也可以一次传入多个数组

df['data1'].groupby([df['key1'], df['key2']]).mean()

此外，还可以将列名用作分组

df.groupby('key1').mean()
df.groupby(['key1', 'key2']).mean()

注：这里在执行df.groupby('key1').mean()时，结果中没有key2列。这是因为df['key2']不是数值数据，所以被从结果中排除了。默认情况下，所有数值列都会被聚合，虽然有时可能会被过滤为一个子集。

分组后可进行迭代

for name, group in df.groupby('key1'):
    print(name)
    print(group)

对于多重键的情况

for (k1, k2), group in df.groupby(['key1', 'key2']):
     print (k1, k2)
     print (group)

上面进行的group操作返回的类型都是Series，如果我们想返回DataFrame类型的结果，那么我们可以进行如下操作

df[['data2']].groupby([df['key1']])

根据行类型进行分组

groupby默认是在axis=0上进行分组的，通过设置也可以在其他任何轴上进行分组。拿上面例子中的df来说，我们可以根据行类型(dtype)对列进行分组

dict(list(df.groupby(df.dtypes,axis = 1)))

这方面还有蛮多内容，不过都还没接触过，只能暂时讲到这里了，如果要了解更多，可以访问这篇博客 ，我在后面也会逐渐完善这些方面的内容。

结尾

讲了这么多，相信你对pandas肯定有了一定的了解了，但由于个人接触不多，就暂时介绍到这里，pandas还有很多内容如数据透视表、多层索引的使用、数据清洗等，将在后面学到时再做补充