重拾Python(4):Pandas之DataFrame对象的使用

Pandas有两大数据结构：Series和DataFrame，之前已对Series对象进行了介绍（链接），本文主要对DataFrame对象的常用用法进行总结梳理。

约定：

import pandas as pd

1、什么是DataFrame对象？

一个二维表，有行索引（index）和列索引（columns），列的数据类型可以不同。

2、DataFrame对象的创建

DataFrame对象的创建主要是使用pd.DataFrame方法。主要包括以下三种：

（1）方法1：通过等长列表组成的字典创建

df1 = pd.DataFrame({'a':[1,2,3,4],'b':['w','x','y','z']})
df1
Out[205]:
   a  b
0  1  w
1  2  x
2  3  y
3  4  z

（2）方法2：通过嵌套字典创建

外层字典的键作为列索引，内层字典的键作为行索引。

df2 = pd.DataFrame({'a':{1:11,2:22,3:33},'b':{1:111,2:222,3:333,4:444}})
df2
Out[206]:
      a    b
1  11.0  111
2  22.0  222
3  33.0  333
4   NaN  444

（3）方法3：通过numpy数组创建

注意传入DataFrame对象的形状。

df3 = pd.DataFrame(np.arange(12).reshape(4,3))
df3
Out[211]:
   0   1   2
0  0   1   2
1  3   4   5
2  6   7   8
3  9  10  11

##3、DataFrame对象的五个主要属性
DataFrame对象的五个主要属性：索引、值、名称、数据类型、形状。
###（1）索引
**a. 索引的查看**
**行**索引使用**index属性**，**列**索引使用**columns属性**，返回Index对象。

df1.index
Out[212]: RangeIndex(start=0, stop=4, step=1)
df1.columns
Out[213]: Index([u'a', u'b'], dtype='object')

索引可以有重复的，判断是否有重复索引，使用Index对象的is_unique属性判断。

df1.index.is_unique
Out[215]: True

b. 索引的修改

索引对象是一个不可变数组，不能修改其中的值。

df1.index[1]=5
Traceback (most recent call last):
  File "<ipython-input-217-360108374774>", line 1, in <module>
    df1.index[1]=5
  File "/usr/local/share/anaconda2/lib/python2.7/site-packages/pandas/indexes/base.py", line 1404, in __setitem__
    raise TypeError("Index does not support mutable operations")
TypeError: Index does not support mutable operations

如果想修改索引，只能将其重定向到一个新的索引对象。

df1.index=[5,6,7,8]
df1
Out[221]:
   a  b
5  1  w
6  2  x
7  3  y
8  4  z

c. 索引的重排

使用reindex方法进行索引重排。通过index参数或者columns参数来区分是对行索引重排还是对列索引重排。重排产生一个新DataFrame对象。

df1.reindex(index=[6,8,5,7])
Out[222]:
   a  b
6  2  x
8  4  z
5  1  w
7  3  y
df1.reindex(columns=['b','a'])
Out[223]:
   b  a
5  w  1
6  x  2
7  y  3
8  z  4

可同时进行行、列索引的重排。

df1.reindex(index=[6,8,5,7],columns=['b','a'])
Out[224]:
   b  a
6  x  2
8  z  4
5  w  1
7  y  3

索引重排可实现3个目的：

① 对现有索引进行顺序指定，即重新排列原来的元素顺序；

② 删除某个旧索引，即删除对应元素；

df1.reindex(index=[6,8,7])
Out[225]:
   a  b
6  2  x
8  4  z
7  3  y

③ 增加某个新索引，即增加新元素，值为NaN。

df1.reindex(index=[6,8,5,7,9])
Out[226]:
     a    b
6  2.0    x
8  4.0    z
5  1.0    w
7  3.0    y
9  NaN  NaN

d. 索引的排序

使用sort_index方法根据索引进行升序、降序排列。

axis参数指定排序的方向：行内排序\列内排序。默认axis=0，列内排序；axis=1，行内排序。

df4 = pd.DataFrame({'c':[11,33,22,44],'b':['w','x','y','z'],'a':[1,2,3,4]},index=[3,5,2,1],columns=['b','c','a'])
df4
Out[229]:
   b   c  a
3  w  11  1
5  x  33  2
2  y  22  3
1  z  44  4
df4.sort_index()
Out[231]:
   b   c  a
1  z  44  4
2  y  22  3
3  w  11  1
5  x  33  2
df4.sort_index(axis=1)
Out[232]:
   a  b   c
3  1  w  11
5  2  x  33
2  3  y  22
1  4  z  44

ascending参数指定升降序，取值为True或False，默认为True，升序排列。

e. 索引是否存在

使用in判断某索引是否存在。

2 in df1['b']
Out[292]: True

（2）值

a. 值的查看

通过DataFrame对象的values属性获取元素的值，返回一个Numpy数组。

df1.values
Out[233]:
array([[1, 'w'],
       [2, 'x'],
       [3, 'y'],
       [4, 'z']], dtype=object)

b. 值的修改

无法通过赋值对某一个元素进行取值就改。

df1.values[1][1]='a'
df1
Out[243]:
   a  b
0  1  w
1  2  x
2  3  y
3  4  z

只能对一行或者一列进行修改。

df1['a']=55
df1['b']=range(4)
df1
Out[245]:
    a  b
0  55  0
1  55  1
2  55  2
3  55  3

c. 值的排序

使用sort_values方法根据值进行升序、降序排列。

by参数指定排序的行\列索引名，可按照多个索引进行排序，传入列表即可，索引顺序即为排序优先级。

df4.sort_values(by='c')
Out[250]:
   b   c  a
3  w  11  1
2  y  22  3
5  x  33  2
1  z  44  4
df4.sort_values(by=['c','a'])
Out[251]:
   b   c  a
3  w  11  1
2  y  22  3
5  x  33  2
1  z  44  4

axis参数指定排序的方向：行内排序\列内排序，默认axis=0，列内排序，axis=1，行内排序。

df4.sort_values(by=3,axis=1)
Out[252]:
   a   c  b
3  1  11  w
5  2  33  x
2  3  22  y
1  4  44  z

ascending参数指定升降序，取值为True或False，默认为True，升序排列。

d. 值的排名

使用rank方法，对于并列排名，默认取其均值。

df4.rank()
Out[253]:
     b    c    a
3  1.0  1.0  1.0
5  2.0  3.0  2.0
2  3.0  2.0  3.0
1  4.0  4.0  4.0

可通过设置axis参数，指定排名方向，默认列内排名，即axis=0，axis=1，行内排名。

df4.rank(axis=1)
Out[254]:
     b    c    a
3  3.0  2.0  1.0
5  3.0  2.0  1.0
2  3.0  2.0  1.0
1  3.0  2.0  1.0

ascending参数指定升降序，取值为True或False，默认为True，升序排列。

e. 值是否存在

使用isin方法判断，要求传入一个列表，返回一个布尔型Series对象。

df1['b'].isin([2])
Out[294]:
0    False
1    False
2     True
3    False
4    False
Name: b, dtype: bool

（3）名称

DataFrame对象的索引对象有名称属性。

但是DataFrame对象没有名称属性。

df4.name
Traceback (most recent call last):
  File "<ipython-input-255-6af278e0d702>", line 1, in <module>
    df4.name
  File "/usr/local/share/anaconda2/lib/python2.7/site-packages/pandas/core/generic.py", line 2744, in __getattr__
    return object.__getattribute__(self, name)
AttributeError: 'DataFrame' object has no attribute 'name'

（4）数据类型

通过dtypes属性获取DataFrame对象每列的数据类型。

df4.dtypes
Out[257]:
b    object
c     int64
a     int64
dtype: object

（5）形状

通过shape属性获取DataFrame对象的形状，返回值为一个元组。

df4.shape
Out[258]: (4, 3)

##4、元素的操作
###（1）元素选取
**a. 选取行**
**选取一行：**
① 按索引名称选取：使用loc[索引名称]

df4.loc[1]
Out[261]:
b     z
c    44
a     4
Name: 1, dtype: object

② 按索引位置序号选取：使用iloc[索引位置序号]

df4.iloc[1]
Out[262]:
b     x
c    33
a     2
Name: 5, dtype: object

选取多行：

① 按索引名称（列表）选取：使用loc[索引名称列表]

df4.loc[[1,3]]
Out[263]:
   b   c  a
1  z  44  4
3  w  11  1

② 按索引位置序号（切片）选取：使用iloc[索引位置序号切片]

df4.iloc[1:3]
Out[265]:
   b   c  a
5  x  33  2
2  y  22  3

b.选取列

选取一列：

直接使用索引名称。

df4['a']
Out[267]:
3    1
5    2
2    3
1    4
Name: a, dtype: int64

选取多列：

直接使用索引名称组成的列表。

df4[['a','b']]
Out[268]:
   a  b
3  1  w
5  2  x
2  3  y
1  4  z

c. 同时选取行和列

① 按索引名称选取：使用loc[行索引名称列表，列索引名称列表]。

df4.loc[[1,3],['a','b']]
Out[269]:
   a  b
1  4  z
3  1  w

② 按索引位置序号选取：使用iloc[行索引位置序号切片，列索引位置序号切片]

df4.iloc[1:3,0:1]
Out[270]:
   b
5  x
2  y

（2）元素过滤

可直接使用基于值的比较运算条件产生的布尔型数组进行过滤。

df1>2
Out[272]:
      a      b
0  True  False
1  True  False
2  True  False
3  True   True
df1[df1>2]
Out[273]:
    a    b
0  55  NaN
1  55  NaN
2  55  NaN
3  55  3.0

（3）元素新增

a. 方法1：通过赋值新增

df1['c']=20
df1
Out[275]:
    a  b   c
0  55  0  20
1  55  1  20
2  55  2  20
3  55  3  20

b. 方法2：通过索引重排新增

df1=df1.reindex(index=[0,1,2,3,4])
df1
Out[277]:
      a    b     c
0  55.0  0.0  20.0
1  55.0  1.0  20.0
2  55.0  2.0  20.0
3  55.0  3.0  20.0
4   NaN  NaN   NaN

（4）元素删除

使用drop方法通过删除指定索引来删除元素。

通过axis参数确定是删除行还是删除列，默认删除行。

a. 一次删除一行/列

df1.drop(1)
Out[280]:
      a    b     c
0  55.0  0.0  20.0
2  55.0  2.0  20.0
3  55.0  3.0  20.0
4   NaN  NaN   NaN

b. 一次删除多行/列

df1.drop(['a','c'],axis=1)
Out[281]:
     b
0  0.0
1  1.0
2  2.0
3  3.0
4  NaN

注意：传入的索引值要与选定的axis方向一致。

（5）算术运算

DataFrame对象支持直接进行算术运算。

df2+2
Out[283]:
      a    b
1  13.0  113
2  24.0  224
3  35.0  335
4   NaN  446

（6）判断是否有空值

使用isnull或者notnull方法判断是否有空值，返回一个布尔型DataFrame对象。

df1.isnull()
Out[297]:
       a      b      c
0  False  False  False
1  False  False  False
2  False  False  False
3  False  False  False
4   True   True   True
df1.notnull()
Out[298]:
       a      b      c
0   True   True   True
1   True   True   True
2   True   True   True
3   True   True   True
4  False  False  False

（7）缺失值处理

缺失值的处理主要有两种方法：填充和过滤。

a.填充

使用fillna方法进行空值填充，该方法产生新对象，不会修改原对象。

df2=df2.reindex(index=[1,2,3,4,5])
df2
Out[304]:
      a      b
1  11.0  111.0
2  22.0  222.0
3  33.0  333.0
4   NaN  444.0
5   NaN    NaN
df2.fillna(99)
Out[308]:
      a      b
1  11.0  111.0
2  22.0  222.0
3  33.0  333.0
4  99.0  444.0
5  99.0   99.0

b.过滤

使用dropna方法进行空值过滤，该方法产生新对象，不会修改原对象。

axis参数确定过滤行还是过滤列，默认axis=0过滤行，axis=1过滤列。

how参数控制过滤标准（有空值就丢弃（any）、全空值才丢弃（all）），默认过滤任何含有缺失值的行/列。

df2.dropna()
Out[305]:
      a      b
1  11.0  111.0
2  22.0  222.0
3  33.0  333.0
df2.dropna(axis=1)
Out[306]:
Empty DataFrame
Columns: []
Index: [1, 2, 3, 4, 5]
df2.dropna(how='all')
Out[307]:
      a      b
1  11.0  111.0
2  22.0  222.0
3  33.0  333.0
4   NaN  444.0

（8）过滤重复值

使用duplicated方法返回布尔型Series对象，判断哪些行是重复值。

df1
Out[317]:
      a    b     c
0  55.0  0.0  20.0
1  55.0  1.0  20.0
2  55.0  2.0  20.0
3  55.0  3.0  20.0
4   NaN  NaN   NaN
df1.duplicated()
Out[318]:
0    False
1    False
2    False
3    False
4    False
dtype: bool

使用drop_duplicates方法过滤其中的重复行，不修改原对象，而是产生一个没有重复行的新DataFrame对象。

df1.drop_duplicates()
Out[320]:
      a    b     c
0  55.0  0.0  20.0
1  55.0  1.0  20.0
2  55.0  2.0  20.0
3  55.0  3.0  20.0
4   NaN  NaN   NaN

默认判断全部列，即所有列都相同才叫重复，也可以指定要判断的一列或者多列（通过传入一个列表）。

df1.duplicated(['a','c'])
Out[319]:
0    False
1     True
2     True
3     True
4    False
dtype: bool
df1.drop_duplicates(['a','c'])
Out[321]:
      a    b     c
0  55.0  0.0  20.0
4   NaN  NaN   NaN

（9）汇总统计

常规的统计方法：sum（求和）、mean（均值）、cumsum（累计求和）、count（非空计数），按列进行汇总。

df1.sum()
Out[322]:
a    220.0
b      6.0
c     80.0
dtype: float64
df1.mean()
Out[324]:
a    55.0
b     1.5
c    20.0
dtype: float64
df1.cumsum()
Out[325]:
       a    b     c
0   55.0  0.0  20.0
1  110.0  1.0  40.0
2  165.0  3.0  60.0
3  220.0  6.0  80.0
4    NaN  NaN   NaN
df1.count()
Out[323]:
a    4
b    4
c    4
dtype: int64

使用describe方法直接生成描述性统计结果。

a. 当元素的数据类型为数值型时，生成的结果包括：均值、最大值、最小值、标准差、元素个数、百分位数。

df1.describe()
Out[326]:
          a         b     c
count   4.0  4.000000   4.0
mean   55.0  1.500000  20.0
std     0.0  1.290994   0.0
min    55.0  0.000000  20.0
25%    55.0  0.750000  20.0
50%    55.0  1.500000  20.0
75%    55.0  2.250000  20.0
max    55.0  3.000000  20.0

b. 当元素的数据类型为类别型时，生成的结果包括：唯一值个数、最大类别、最大类别频数。

df5=pd.DataFrame({'a':['s','t','y','r'],'b':['w','x','y','z']})
df5
Out[330]:
   a  b
0  s  w
1  t  x
2  y  y
3  r  z
df5.describe()
Out[331]:
        a  b
count   4  4
unique  4  4
top     t  w
freq    1  1

（10）分组聚合

使用groupby方法产生一个GroupBy对象，然后使用聚合函数（mean、sum等）进行聚合计算。

groupby方法中传入划分组的一列或者多列。

df1.groupby('a').sum()
Out[337]:
        b     c
a
55.0  6.0  80.0

##5、DataFrame对象之间的操作
###（1）算术运算
通过+、-、*、\等运算符或者add、sub、mul、div等方法进行两个DataFrame对象之间的算术运算。
运算时，行、列索引同时对齐，对应元素进行算术运算，没有重叠的位置，运算结果为NaN。

df1
Out[338]:
      a    b     c
0  55.0  0.0  20.0
1  55.0  1.0  20.0
2  55.0  2.0  20.0
3  55.0  3.0  20.0
4   NaN  NaN   NaN
df2
Out[339]:
      a      b
1  11.0  111.0
2  22.0  222.0
3  33.0  333.0
4   NaN  444.0
5   NaN    NaN
df1+df2
Out[340]:
      a      b   c
0   NaN    NaN NaN
1  66.0  112.0 NaN
2  77.0  224.0 NaN
3  88.0  336.0 NaN
4   NaN    NaN NaN
5   NaN    NaN NaN
df1.add(df2)
Out[341]:
      a      b   c
0   NaN    NaN NaN
1  66.0  112.0 NaN
2  77.0  224.0 NaN
3  88.0  336.0 NaN
4   NaN    NaN NaN
5   NaN    NaN NaN

在使用上述方法进行算术运算时，可以使用fill_value参数进行空值填充，会先填充后进行算术运算。

df1.add(df2,fill_value=0)
Out[343]:
      a      b     c
0  55.0    0.0  20.0
1  66.0  112.0  20.0
2  77.0  224.0  20.0
3  88.0  336.0  20.0
4   NaN  444.0   NaN
5   NaN    NaN   NaN

（2）关联操作

使用pd.merge方法对两个DataFrame对象进行关联操作，本质上与两张数据库的二维表的join操作效果相同。

df6=pd.DataFrame({'a':{1:11,2:22,3:33},'b':{1:111,2:222,3:333},'c':{1:11,3:33,5:55}})
df6
Out[347]:
      a      b     c
1  11.0  111.0  11.0
2  22.0  222.0   NaN
3  33.0  333.0  33.0
5   NaN    NaN  55.0
df7=pd.DataFrame({'b':{1:111,2:444,3:333},'c':{1:11,2:44,3:33}})
df7
Out[348]:
     b   c
1  111  11
2  444  44
3  333  33
pd.merge(df6,df7,on='b')
Out[349]:
      a      b   c_x  c_y
0  11.0  111.0  11.0   11
1  33.0  333.0  33.0   33

a. how参数决定关联方式，how='inner'相当于inner join，这是默认情况；how='left'相当于left join；how='right'相当于right join；how='outer'相当于cross join。

pd.merge(df6,df7,on='b',how='left')
Out[350]:
      a      b   c_x   c_y
0  11.0  111.0  11.0  11.0
1  22.0  222.0   NaN   NaN
2  33.0  333.0  33.0  33.0
3   NaN    NaN  55.0   NaN

b. on参数决定关联条件。当两个DataFrame对象的关联列名相同时，使用on参数指定；当两个DataFrame对象的关联列名不同时，则使用left_on和right_on参数分别指定。

pd.merge(df6,df7,left_on='a',right_on='c')
Out[352]:
      a    b_x   c_x  b_y  c_y
0  11.0  111.0  11.0  111   11
1  33.0  333.0  33.0  333   33

c. suffixes参数处理合并后相同列名的命名问题，确定合并后的后缀。

pd.merge(df6,df7,on='b',suffixes=['_left','_right'])
Out[351]:
      a      b  c_left  c_right
0  11.0  111.0    11.0       11
1  33.0  333.0    33.0       33

d. right_index参数，取值为True代表右侧DataFrame的行索引作为连接键参与连接。

e. left_index参数，取值为True代表左侧DataFrame的行索引作为连接键参与连接。

pd.merge(df6,df7,left_on='a',right_index=True,how='left')
Out[354]:
      a    b_x   c_x  b_y  c_y
1  11.0  111.0  11.0  NaN  NaN
2  22.0  222.0   NaN  NaN  NaN
3  33.0  333.0  33.0  NaN  NaN
5   NaN    NaN  55.0  NaN  NaN
pd.merge(df6,df7,left_index=True,right_index=True)
Out[355]:
      a    b_x   c_x  b_y  c_y
1  11.0  111.0  11.0  111   11
2  22.0  222.0   NaN  444   44
3  33.0  333.0  33.0  333   33

##6、DataFrame对象与Series对象之间的操作
###（1）算术运算
通过+、-、*、\等运算符或者add、sub、mul、div等方法进行DataFrame对象和Series对象之间的算术运算。
默认将Series的索引匹配DataFrame的列索引，然后沿着行一直向下传播。

df8=pd.DataFrame({'a':{1:100,2:200,3:300},'b':{1:200,2:300,3:400},'c':{1:300,2:400,3:500}})
df8
Out[360]:
     a    b    c
1  100  200  300
2  200  300  400
3  300  400  500
ser1=pd.Series([100,200,300],index=['a','b','c'])
ser1
Out[361]:
a    100
b    200
c    300
dtype: int64
df8-ser1
Out[362]:
     a    b    c
1    0    0    0
2  100  100  100
3  200  200  200
df8.sub(ser1)
Out[363]:
     a    b    c
1    0    0    0
2  100  100  100
3  200  200  200

使用上述方法时，可以使用axis参数来设定二者索引的匹配方向，是按行索引匹配（axis=0），还是按列索引匹配（axis=1，默认）。索引没有对齐的元素，运算结果为NaN。

df8.sub(ser1,axis=1)
Out[364]:
     a    b    c
1    0    0    0
2  100  100  100
3  200  200  200
df8.sub(ser1,axis=0)
Out[365]:
    a   b   c
1 NaN NaN NaN
2 NaN NaN NaN
3 NaN NaN NaN
a NaN NaN NaN
b NaN NaN NaN
c NaN NaN NaN
ser2=df8['a']
ser2
Out[368]:
1    100
2    200
3    300
Name: a, dtype: int64
df8.sub(ser2,axis=0)
Out[369]:
   a    b    c
1  0  100  200
2  0  100  200
3  0  100  200

##7.参考与感谢
\[1] [利用Python进行数据分析](https://book.douban.com/subject/25779298/)