利用python进行数据分析-数据规整化1

1.合并数据集

pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来

pandas.concat可以沿着一条轴将多个对象堆叠到一起

实例方法combine_first可以将重复数据编接在一起，用一个对象的值填充另一个对象中的缺失值

2.数据库风格的DataFrame合并

df1=DataFrame({'key':['b','b','a','c','a','a','b'],
              'data1':range(7)})
df2=DataFrame({'key':['a','b','d'],
              'data2':range(3)})
print df1
print df2
print pd.merge(df1,df2)
print pd.merge(df1,df2,on='key')

结果为：

   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   a
6      6   b
   data2 key
0      0   a
1      1   b
2      2   d
   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0
   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0

这是一种多对1的合并。起初，我并没有指明要用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当做键。不过最好显式的指定下

如果两个对象的列名不同，也可以分别进行指定

df3=DataFrame({'lkey':['b','b','a','c','a','a','b'],
              'data1':range(7)})
df4=DataFrame({'rkey':['a','b','d'],
              'data2':range(3)})
print pd.merge(df3,df4,left_on='lkey',right_on='rkey')

结果为：

   data1 lkey  data2 rkey
0      0    b      1    b
1      1    b      1    b
2      6    b      1    b
3      2    a      0    a
4      4    a      0    a
5      5    a      0    a

默认情况下，merge做的是“inner”连接，结果中的键是交集。其它方式还有“left”，“right”以及“outer”。外连接求取的是键的并集，组合了左连接和右连接的效果

print pd.merge(df1,df2,how='outer')

结果为：

   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0
6      3   c    NaN
7    NaN   d      2

多对多的合并操作非常简单，无需额外的工作

df3=DataFrame({'key':['b','b','a','c','a','b'],
              'data1':range(6)})
df4=DataFrame({'key':['a','b','a','b','d'],
              'data2':range(5)})
print pd.merge(df3,df4,on='key',how='left')

结果为：

    data1 key  data2
0       0   b      1
1       0   b      3
2       1   b      1
3       1   b      3
4       2   a      0
5       2   a      2
6       3   c    NaN
7       4   a      0
8       4   a      2
9       5   b      1
10      5   b      3

多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个“b”行，右边的有2个，所以最终结果中就有6个“b”行

print pd.merge(df3,df4,how='inner')

结果为：

   data1 key  data2
0      0   b      1
1      0   b      3
2      1   b      1
3      1   b      3
4      5   b      1
5      5   b      3
6      2   a      0
7      2   a      2
8      4   a      0
9      4   a      2

要根据多个键进行合并，传入一个由列名组成的列表即可

left=DataFrame({'key1':['foo','foo','bar'],
                'key2':['one','two','one'],
                'lval':[1,2,3]})
right=DataFrame({'key1':['foo','foo','bar','bar'],
                'key2':['one','one','one','two'],
                'rval':[4,5,6,7]})
print pd.merge(left,right,on=['key1','key2'],how='outer')

结果为：

  key1 key2  lval  rval
0  foo  one     1     4
1  foo  one     1     5
2  foo  two     2   NaN
3  bar  one     3     6
4  bar  two   NaN     7

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠问题，但merge有一个更实用suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串

print pd.merge(left,right,on='key1')
print pd.merge(left,right,on='key1',suffixes=('_left','_right'))

结果为：

  key1 key2_x  lval key2_y  rval
0  foo    one     1    one     4
1  foo    one     1    one     5
2  foo    two     2    one     4
3  foo    two     2    one     5
4  bar    one     3    one     6
5  bar    one     3    two     7
  key1 key2_left  lval key2_right  rval
0  foo       one     1        one     4
1  foo       one     1        one     5
2  foo       two     2        one     4
3  foo       two     2        one     5
4  bar       one     3        one     6
5  bar       one     3        two     7

3.索引上的合并

有时候，DataFrame中的连接键位于其索引中。在这种情况下，你可以传入left_index=True或right_index=True（或两个都传）以说明索引应该被用作连接键

left1=DataFrame({'key':['a','b','a','a','b','c'],
                 'value':range(6)})
right1=DataFrame({'group_val':[3.5,7]},index=['a','b'])
print left1
print right1
print pd.merge(left1,right1,left_on='key',right_index=True)

结果为：

  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5
   group_val
a        3.5
b        7.0
  key  value  group_val
0   a      0        3.5
2   a      2        3.5
3   a      3        3.5
1   b      1        7.0
4   b      4        7.0

可以通过外连接的方式得到它们的并集

print pd.merge(left1,right1,left_on='key',right_index=True,how='outer')

结果为：

  key  value  group_val
0   a      0        3.5
2   a      2        3.5
3   a      3        3.5
1   b      1        7.0
4   b      4        7.0
5   c      5        NaN

对于层次化索引的数据，事情就有点复杂了。这种情况下，你必须以列表的形式指明用作合并键的多个列

lefth=DataFrame({'key1':['Ohio','Ohio','Ohio','Nevada','Nevada'],
                 'key2':[2000,2001,2002,2001,2002],
                 'data':np.arange(5)})
righth=DataFrame(np.arange(12).reshape((6,2)),
                 index=[['Nevada','Nevada','Ohio','Ohio','Ohio','Ohio'],
                        [2001,2000,2000,2000,2001,2002]],
                 columns=['event1','event2'])
print lefth
print righth
print pd.merge(lefth,righth,left_on=['key1','key2'],right_index=True)

结果为：

   data    key1  key2
0     0    Ohio  2000
1     1    Ohio  2001
2     2    Ohio  2002
3     3  Nevada  2001
4     4  Nevada  2002
             event1  event2
Nevada 2001       0       1
       2000       2       3
Ohio   2000       4       5
       2000       6       7
       2001       8       9
       2002      10      11
   data    key1  key2  event1  event2
0     0    Ohio  2000       4       5
0     0    Ohio  2000       6       7
1     1    Ohio  2001       8       9
2     2    Ohio  2002      10      11
3     3  Nevada  2001       0       1

同时使用合并双方的索引也没有问题

left2=DataFrame([[1,2],[3,4],[5,6]],index=['a','c','e'],columns=['Ohio','Nevada'])
right2=DataFrame([[7,8],[9,10],[11,12],[13,14]],index=['b','c','d','e'],columns=['Missouri','Alabama'])
print left2
print right2
print pd.merge(left2,right2,how='outer',left_index=True,right_index=True)

结果为：

   Ohio  Nevada
a     1       2
c     3       4
e     5       6
   Missouri  Alabama
b         7        8
c         9       10
d        11       12
e        13       14
   Ohio  Nevada  Missouri  Alabama
a     1       2       NaN      NaN
b   NaN     NaN         7        8
c     3       4         9       10
d   NaN     NaN        11       12
e     5       6        13       14

DataFrame还有一个join实例方法，它能够更为方便地实现按索引合并。上面的那个例子中，我们可以编写成

print left2.join(right2,how='outer')

结果为：

   Ohio  Nevada  Missouri  Alabama
a     1       2       NaN      NaN
b   NaN     NaN         7        8
c     3       4         9       10
d   NaN     NaN        11       12
e     5       6        13       14

最后，对于简单的索引合并，你还可以向join传入一组DataFrame

another=DataFrame([[7,8],[9,10],[11,12],[16,17]],index=['a','c','e','f'],columns=['New York','Oregon'])
print left2.join([right2,another])

结果为：

   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a     1       2       NaN      NaN         7       8
c     3       4         9       10         9      10
e     5       6        13       14        11      12

4.轴向连接

Numpy有一个用于合并原始Numpy数组的concatenation函数

arr=np.arange(12).reshape((3,4))
print arr
print np.concatenate([arr,arr],axis=1)

结果为：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  0  1  2  3]
 [ 4  5  6  7  4  5  6  7]
 [ 8  9 10 11  8  9 10 11]]

对于pandas对象，带有标签的轴使你能够进一步推广数组的连接对象。你还需要考虑以下东西：

a.如果各对象其它轴上的索引不同，那些轴是做并集还是交集

b.结果对象中的分组需要各不相同吗

c.用于连接的轴重要吗

pandas的concat函数提供了一种能够解决这些问题的可靠方式。假设有三个没有重叠索引的Series

s1=Series([0,1],index=['a','b'])
s2=Series([2,3,4],index=['c','d','e'])
s3=Series([5,6],index=['f','g'])
print pd.concat([s1,s2,s3])

结果为：

a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64

默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame（axis=1是列）

print pd.concat([s1,s2,s3],axis=1)

结果为：

    0   1   2
a   0 NaN NaN
b   1 NaN NaN
c NaN   2 NaN
d NaN   3 NaN
e NaN   4 NaN
f NaN NaN   5
g NaN NaN   6

这种情况下，另外一条轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入join=‘inner’即可得到它们的交集

s4=pd.concat([s1*5,s3])
print pd.concat([s1,s4],axis=1)
print pd.concat([s1,s4],axis=1,join='inner')

结果为：

    0  1
a   0  0
b   1  5
f NaN  5
g NaN  6
   0  1
a  0  0
b  1  5

你可以通过join_axes指定要在其它轴上使用的索引

print pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','e']])

结果为：

    0   1
a   0   0
c NaN NaN
b   1   5
e NaN NaN

有个问题，参与连接的片段在结果中区分不开。假设你想在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的

result=pd.concat([s1,s2,s3],keys=['one','two','three'])
print result
print result.unstack()

结果为：

one    a    0
       b    1
two    c    2
       d    3
       e    4
three  f    5
       g    6
dtype: int64
        a   b   c   d   e   f   g
one     0   1 NaN NaN NaN NaN NaN
two   NaN NaN   2   3   4 NaN NaN
three NaN NaN NaN NaN NaN   5   6

如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头

print pd.concat([s1,s2,s3],axis=1,keys=['one','two','three'])

结果为：

   one  two  three
a    0  NaN    NaN
b    1  NaN    NaN
c  NaN    2    NaN
d  NaN    3    NaN
e  NaN    4    NaN
f  NaN  NaN      5
g  NaN  NaN      6

同样的逻辑对DataFrame对象也是一样http://write.blog.youkuaiyun.com/postedit/51682305

df5=DataFrame(np.arange(6).reshape(3,2),index=['a','b','c'],columns=['one','two'])
df6=DataFrame(5+np.arange(4).reshape(2,2),index=['a','c'],columns=['three','four'])
print pd.concat([df5,df6],axis=1,keys=['level1','level2'])
结果为：

  level1     level2     
     one two  three four
a      0   1      5    6
b      2   3    NaN  NaN
c      4   5      7    8

如果传入的不是列表而是一个字典，则字典的键就会被当做keys选项的值

print pd.concat({'level1':df5,'level2':df6},axis=1)

结果为：

  level1     level2     
     one two  three four
a      0   1      5    6
b      2   3    NaN  NaN
c      4   5      7    8

此外还有两个用于管理层次化索引创建方式的参数，见下表

print pd.concat([df5,df6],axis=1,keys=['level1','level2'],names=['upper','lower'])

结果为：

upper level1     level2     
lower    one two  three four
a          0   1      5    6
b          2   3    NaN  NaN
c          4   5      7    8

最后一个需要考虑的问题就是，跟当前分析工作无关的DataFrame行索引。传入ignore_index=True即可

df7=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
df8=DataFrame(np.random.randn(2,3),columns=['b','d','a'])
print df7
print df8
print pd.concat([df7,df8],ignore_index=True)

结果为：

          a         b         c         d
0 -0.083578  0.106970 -0.534075  0.324900
1 -0.631331  0.138009  0.439823  0.440392
2  0.757486 -0.634111  0.522510 -0.687599
          b         d         a
0 -1.497807 -0.033387 -0.137402
1 -0.308111  1.935971  1.266464
          a         b         c         d
0 -0.083578  0.106970 -0.534075  0.324900
1 -0.631331  0.138009  0.439823  0.440392
2  0.757486 -0.634111  0.522510 -0.687599
3 -0.137402 -1.497807       NaN -0.033387
4  1.266464 -0.308111       NaN  1.935971