【学习】数据规整化：清理、转换、合并、重塑【pandas】

这一部分非常关键！

数据分析和建模方面的大量编程工作都是用在数据准备上的：加载、清理、转换以及重塑。

1、合并数据集

• pandas对象中的数据可以通过 一些内置的方式进行合并：
• pandas.merge可根据一个或多个健将不同DataFrame中的行连接起来。实现的就是数据库的连接操作
• pandas.concat可以沿着一条轴将多个对象堆叠到一起
• 实例方法combine_first可以将重复数据编接在一起，用一个对象中的值填充另一个对象中的缺失值（通俗来说，差不多就是数据库的全外连接，简单地说，就是先从第一个对象中选值，不行就再去第二个对象中选值）

@数据库风格的DataFrame合并

      数据集的合并（merge）或连接（join）运算是通过一个或多个键将行链接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点。

import pandas as pd

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})
Out[15]: 
   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   a
6      6   b

df2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)})
Out[16]: 
   data2 key
0      0   a
1      1   b
2      2   d


df1
df2

#这是一种多对一的合并，df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行
pd.merge(df1, df2)

Out[17]: 
   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

注意，这里并没有指明用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当作 键，不过，最好显示指定一下

#注意，这里并没有指明用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当作 键，不过，最好显示指定一下
pd.merge(df1, df2, on = 'key')

#如果两个对象的列名不同，也可以分别进行指定
df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})

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

Out[20]: 
   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

但注意到，结果里面c和d以及与之相关的数据都消失了，默认情况下，merge做的是inner连接；结果中的键是交集。

其他方式还有left 、right以及outer。外连接求取的是键的并集，组合了左连接和右连接的效果

pd.merge(df1, df2, how = 'outer')
Out[21]: 
   data1 key  data2
0    0.0   b    1.0
1    1.0   b    1.0
2    6.0   b    1.0
3    2.0   a    0.0
4    4.0   a    0.0
5    5.0   a    0.0
6    3.0   c    NaN
7    NaN   d    2.0

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

#多对多的合并操作
df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'], 'data1': range(6)})

df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'], 'data2': range(5)})
df1
df2
pd.merge(df1, df2, on = 'key', how = 'left')
Out[26]: 
    data1 key  data2
0       0   b    1.0
1       0   b    3.0
2       1   b    1.0
3       1   b    3.0
4       2   a    0.0
5       2   a    2.0
6       3   c    NaN
7       4   a    0.0
8       4   a    2.0
9       5   b    1.0
10      5   b    3.0
#多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个b行，右边有2个，所以最终结果中就有6个b行，连接方式只影响出现在结果中键
pd.merge(df1, df2, on = 'key', how = 'left')
#多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个b行，右边有2个，所以最终结果中就有6个b行，连接方式只影响出现在结果中键
pd.merge(df1, df2, how = 'inner')
pd.merge(df1, df2, on = 'key', how = 'left')
Out[26]: 
    data1 key  data2
0       0   b    1.0
1       0   b    3.0
2       1   b    1.0
3       1   b    3.0
4       2   a    0.0
5       2   a    2.0
6       3   c    NaN
7       4   a    0.0
8       4   a    2.0
9       5   b    1.0
10      5   b    3.0

pd.merge(df1, df2, how = 'inner')
Out[27]: 
   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 = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
                 'key2': ['one', 'two', 'one'],
                 'lva1': [1, 2, 3]})
right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
                 'key2': ['one', 'one', 'one', 'two'],
                 'rva1': [4, 5, 6, 7]})
pd.merge(left, right, on = ['key1', 'key2'], how = 'outer')

Out[32]: 
  key1 key2  lva1  rva1
0  foo  one   1.0   4.0
1  foo  one   1.0   5.0
2  foo  two   2.0   NaN
3  bar  one   3.0   6.0
4  bar  two   NaN   7.0

结果中会出现哪些键组合取决于所选的合并方式，可以这样理解：多个键组成一系列元组，并将其当作单个连接键

警告：在进行列-列连接时，DataFrame对象中的索引会被丢弃

left
Out[33]: 
  key1 key2  lva1
0  foo  one     1
1  foo  two     2
2  bar  one     3

right
Out[34]: 
  key1 key2  rva1
0  foo  one     4
1  foo  one     5
2  bar  one     6
3  bar  two     7
#对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题，但merge有一个更实用的suffixes选项，用于指定
#附加到左右两个DataFrame对象的重叠列名上的字符串
pd.merge(left, right, on = 'key1')
Out[35]: 
  key1 key2_x  lva1 key2_y  rva1
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
pd.merge(left, right, on = 'key1', suffixes = ('_left', '_right'))
Out[36]: 
  key1 key2_left  lva1 key2_right  rva1
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

merge函数有参数

标注：sort  根据连接键对合并后的数据进行排序，默认为True, 有时在处理大数据集时，禁用该选项可获得更好的性能

           suffixes  字符串元组，用于追加到重叠列名的末尾，默认为（’_x‘, '_y'）.

           copy   设置为False, 可以在某些特殊情况下避免将数据复制到结果数据结构中，默认总是复制

@索引上的合并

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

left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'], 'value': range(6)})
left1
Out[37]: 
  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5

right1 = pd.DataFrame({'group_val': [3.5, 7]}, index = ['a', 'b'])
right1
Out[40]: 
   group_val
a        3.5
b        7.0

pd.merge(left1, right1, left_on = 'key', right_index = True)
Out[41]: 
  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

由于默认的merge方法是求取连接键的交集，因此可以通过外连接的方式得到它们的并集

pd.merge(left1, right1, left_on = 'key', right_index = True, how = 'outer')
Out[42]: 
  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

对于层次化索引的数据

import numpy as np
lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
                 'key2': [2000, 2001, 2002, 2001, 2002],
                 'lva1': np.arange(5)})
lefth

 Out[46]: 
     key1  key2  lva1
0    Ohio  2000     0
1    Ohio  2001     1
2    Ohio  2002     2
3  Nevada  2001     3
4  Nevada  2002     4

righth =  pd.DataFrame(np.arange(12).reshape((6, 2)), 
                       index = [['Nevada', 'Nevada','Ohio', 'Ohio', 'Ohio', 'Ohio'],
                                [2001, 2000, 2000, 2000, 2001, 2002]],
                                columns = ['event1', 'event2'])
righth

Out[51]: 
             event1  event2
Nevada 2001       0       1
       2000       2       3
Ohio   2000       4       5
       2000       6       7
       2001       8       9
       2002      10      11

这种情况下，你必须以列表的形式指明用作合并键的多个列（注意对重复索引值的处理）

pd.merge(lefth, righth, left_on = ['key1', 'key2'], right_index = True)
Out[52]: 
     key1  key2  lva1  event1  event2
0    Ohio  2000     0       4       5
0    Ohio  2000     0       6       7
1    Ohio  2001     1       8       9
2    Ohio  2002     2      10      11
3  Nevada  2001     3       0       1

pd.merge(lefth, righth, left_on = ['key1', 'key2'], right_index = True, how = 'outer')
Out[53]: 
     key1  key2  lva1  event1  event2
0    Ohio  2000   0.0     4.0     5.0
0    Ohio  2000   0.0     6.0     7.0
1    Ohio  2001   1.0     8.0     9.0
2    Ohio  2002   2.0    10.0    11.0
3  Nevada  2001   3.0     0.0     1.0
4  Nevada  2002   4.0     NaN     NaN
4  Nevada  2000   NaN     2.0     3.0

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

left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]], index = ['a', 'c', 'e'], columns = ['Ohio', 'Nevada'])

left2
Out[55]: 
   Ohio  Nevada
a   1.0     2.0
c   3.0     4.0
e   5.0     6.0

right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13., 14.]], index = ['b', 'c', 'd', 'e'], columns = ['Missouri', 'Alabama'])

right2
Out[57]: 
   Missouri  Alabama
b       7.0      8.0
c       9.0     10.0
d      11.0     12.0
e      13.0     14.0

pd.merge(left2, right2, how = 'outer', left_index = True, right_index = True)
Out[58]: 
   Ohio  Nevada  Missouri  Alabama
a   1.0     2.0       NaN      NaN
b   NaN     NaN       7.0      8.0
c   3.0     4.0       9.0     10.0
d   NaN     NaN      11.0     12.0
e   5.0     6.0      13.0     14.0

DataFrame还有一个join实例方法，它能更为方便地实现按索引合并。它还还可用于合并多个带有相同或相似索引的DataFrame对象，而不管它们之间有没有重叠的列

left2.join(right2, how = 'outer')
Out[59]: 
   Ohio  Nevada  Missouri  Alabama
a   1.0     2.0       NaN      NaN
b   NaN     NaN       7.0      8.0
c   3.0     4.0       9.0     10.0
d   NaN     NaN      11.0     12.0
e   5.0     6.0      13.0     14.0

#支持参数DataFrame的索引跟调用者DataFrame的某个列之间的连接
left1.join(right1, on = 'key')
Out[60]: 
  key  value  group_val
0   a      0        3.5
1   b      1        7.0
2   a      2        3.5
3   a      3        3.5
4   b      4        7.0
5   c      5        NaN

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

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

left2
Out[66]: 
   Ohio  Nevada
a   1.0     2.0
c   3.0     4.0
e   5.0     6.0

another
Out[63]: 
   New York  Oregon
a       7.0     8.0
c       9.0    10.0
e      11.0    12.0
f      16.0    17.0

right2
Out[64]: 
   Missouri  Alabama
b       7.0      8.0
c       9.0     10.0
d      11.0     12.0
e      13.0     14.0

left2.join([right2, another])

Out[65]: In [66]: 
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a   1.0     2.0       NaN      NaN       7.0     8.0
c   3.0     4.0       9.0     10.0       9.0    10.0
e   5.0     6.0      13.0     14.0      11.0    12.0

left2.join([right2, another], how = 'outer')
Out[67]: 
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a   1.0     2.0       NaN      NaN       7.0     8.0
b   NaN     NaN       7.0      8.0       NaN     NaN
c   3.0     4.0       9.0     10.0       9.0    10.0
d   NaN     NaN      11.0     12.0       NaN     NaN
e   5.0     6.0      13.0     14.0      11.0    12.0
f   NaN     NaN       NaN      NaN      16.0    17.0

 @轴向连接

另一种数据合并运算也被称作连接、绑定或堆叠。numpy有一个用于合并原始numpy数组的concatenation函数

arr = np.arange(12).reshape((3, 4))

arr
Out[69]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

np.concatenate([arr, arr], axis = 1)
Out[70]: 
array([[ 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对象，Series和DataFrame, 带有标签的轴使你能够进一步推广数组的连接运算。具体点说，你还需要考虑以下这些东西

• 如果各对象其他轴上的索引不同，那些轴应该是做并集还是交集
• 结果对象中的分组需要各不相同吗
• 用于连接的轴重要吗

pandas的concat函数提供了一种能够解决这些问题的可靠方式。

假设三个没有重叠索引的Series:

s1 = pd.Series([0, 1], index = ['a', 'b'])

s2 = pd.Series([2, 3, 4], index = ['c', 'd', 'e'])

s3 = pd.Series([5, 6], index = ['f', 'g'])

s1
Out[74]: 
a    0
b    1
dtype: int64

s2
Out[75]: 
c    2
d    3
e    4
dtype: int64

s3
Out[76]: 
f    5
g    6
dtype: int64

pd.concat([s1, s2, s3])
Out[77]: 
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 是列)

pd.concat([s1, s2, s3], axis =1)
Out[78]: 
     0    1    2
a  0.0  NaN  NaN
b  1.0  NaN  NaN
c  NaN  2.0  NaN
d  NaN  3.0  NaN
e  NaN  4.0  NaN
f  NaN  NaN  5.0
g  NaN  NaN  6.0

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

s4 = pd.concat([s1 * 5, s3])
s4
Out[99]: 
a    0
b    5
f    5
g    6
dtype: int64

pd.concat([s1, s4], axis = 1)
Out[100]: 
     0  1
a  0.0  0
b  1.0  5
f  NaN  5
g  NaN  6

pd.concat([s1, s4], axis = 1, join = 'inner')
Out[101]: 
   0  1
a  0  0
b  1  5

#你可以通过join_axes指定要在其他 轴上使用的索引
pd.concat([s1, s4], axis = 1, join_axes = [['a', 'c', 'b', 'e']])
Out[102]: 
     0    1
a  0.0  0.0
c  NaN  NaN
b  1.0  5.0
e  NaN  NaN

#如果你想要在连接轴上创建一个层次化索引。使用keys参数 即可达到这个目的
result = pd.concat([s1, s2, s3], keys = ['one', 'two', 'three'])
result

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

result.unstack()
Out[104]: 
         a    b    c    d    e    f    g
one    0.0  1.0  NaN  NaN  NaN  NaN  NaN
two    NaN  NaN  2.0  3.0  4.0  NaN  NaN
three  NaN  NaN  NaN  NaN  NaN  5.0  6.0

#如果沿着axis = 1 对Series进行合并，则keys就会成为DataFrame的列头
pd.concat([s1, s2, s3], axis = 1, keys = ['one', 'two', 'three'])
Out[105]: 
   one  two  three
a  0.0  NaN    NaN
b  1.0  NaN    NaN
c  NaN  2.0    NaN
d  NaN  3.0    NaN
e  NaN  4.0    NaN
f  NaN  NaN    5.0
g  NaN  NaN    6.0

#同样的逻辑对DataFrame对象也是一样
df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index = ['a', 'b', 'c'], columns = ['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index = ['a', 'c'], columns = ['three', 'four'])
pd.concat([df1, df2], axis = 1, keys = ['level1', 'level2'])

Out[106]: 
  level1     level2     
     one two  three four
a      0   1    5.0  6.0
b      2   3    NaN  NaN
c      4   5    7.0  8.0

#如果传入的不是列表而是一个字典，则字典的键就会被当作keys选项的值
pd.concat({'level1': df1, 'level2': df2}, axis =1)

Out[107]: 
  level1     level2     
     one two  three four
a      0   1    5.0  6.0
b      2   3    NaN  NaN
c      4   5    7.0  8.0

#此外还有两个管理层次化索引创建方式的参数
pd.concat([df1, df2], axis = 1, keys = ['level1', 'level2'], names = ['upper', 'lower'])
Out[108]: 
upper level1     level2     
lower    one two  three four
a          0   1    5.0  6.0
b          2   3    NaN  NaN
c          4   5    7.0  8.0

#最后需要考虑的一个问题，跟当前分析工作无关的DataFrame行索引
df1 = pd.DataFrame(np.random.randn(3, 4), columns = ['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns = ['b', 'd', 'a'])

df1
Out[110]: 
          a         b         c         d
0  0.003212 -0.342055 -0.152235 -1.848477
1 -0.357666 -1.667613 -0.499012  0.559769
2 -1.025485  0.770518 -0.203711 -0.513205

df2
Out[111]: 
          b         d         a
0  0.573107 -0.259251  0.087934
1  1.070468  1.113611 -1.062122

#在这种情况下，传入ignore_index = True 即可
pd.concat([df1, df2], ignore_index = True)

Out[112]: 
          a         b         c         d
0  0.003212 -0.342055 -0.152235 -1.848477
1 -0.357666 -1.667613 -0.499012  0.559769
2 -1.025485  0.770518 -0.203711 -0.513205
3  0.087934  0.573107       NaN -0.259251
4 -1.062122  1.070468       NaN  1.113611

concat函数的参数