【转】Python for Data Analysis第二版【中文版】-第八章

第08章 数据规整：聚合、归并和重塑

在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也倒霉于分析。本章关注可以聚合、归并、重塑数据的方法。
首先，我会介绍pandas的条理化索引，它广泛用于以上操作。然后，我深入介绍了一些特殊的数据操作。在第14章，你可以看到这些工具的多种应用。
8.1 条理化索引

条理化索引（hierarchical indexing）是pandas的一项紧张功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理惩罚高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：

1. In [9]: data = pd.Series(np.random.randn(9),
2.    ...:                  index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],
3.    ...:                         [1, 2, 3, 1, 3, 1, 2, 2, 3]])
5. In [10]: data
6. Out[10]:
7. a  1   -0.204708
8.    2    0.478943
9.    3   -0.519439
10. b  1   -0.555730
11.    3    1.965781
12. c  1    1.393406
13.    2    0.092908
14. d  2    0.281746
15.    3    0.769023
16. dtype: float64

复制代码

看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表现“直接利用上面的标签”：

1. In [11]: data.index
2. Out[11]:
3. MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],
4.            labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])

复制代码

对于一个条理化索引的对象，可以利用所谓的部门索引，利用它选取数据子集的操作更简单：

1. In [12]: data['b']
2. Out[12]:
3. 1   -0.555730
4. 3    1.965781
5. dtype: float64
7. In [13]: data['b':'c']
8. Out[13]:
9. b  1   -0.555730
10.    3    1.965781
11. c  1    1.393406
12.    2    0.092908
13. dtype: float64
15. In [14]: data.loc[['b', 'd']]
16. Out[14]:
17. b  1   -0.555730
18.    3    1.965781
19. d  2    0.281746
20.    3    0.769023
21. dtype: float64

复制代码

偶然乃至还可以在“内层”中进行选取：

1. In [15]: data.loc[:, 2]
2. Out[15]:
3. a    0.478943
4. c    0.092908
5. d    0.281746
6. dtype: float64

复制代码

条理化索引在数据重塑和基于分组的操作（如透视表生成）中扮演侧紧张的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：

1. In [16]: data.unstack()
2. Out[16]:
3.           1         2         3
4. a -0.204708  0.478943 -0.519439
5. b -0.555730       NaN  1.965781
6. c  1.393406  0.092908       NaN
7. d       NaN  0.281746  0.769023

复制代码

unstack的逆运算是stack：

1. In [17]: data.unstack().stack()
2. Out[17]:
3. a  1   -0.204708
4.    2    0.478943
5.    3   -0.519439
6. b  1   -0.555730
7.    3    1.965781
8. c  1    1.393406
9.    2    0.092908
10. d  2    0.281746
11.    3    0.769023
12. dtype: float64

复制代码

stack和unstack将在本章后面详细讲解。
对于一个DataFrame，每条轴都可以有分层索引：

1. In [18]: frame = pd.DataFrame(np.arange(12).reshape((4, 3)),
2.    ....:                      index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
3.    ....:                      columns=[['Ohio', 'Ohio', 'Colorado'],
4.    ....:                               ['Green', 'Red', 'Green']])
6. In [19]: frame
7. Out[19]:
8.      Ohio     Colorado
9.     Green Red    Green
10. a 1     0   1        2
11.   2     3   4        5
12. b 1     6   7        8
13.   2     9  10       11

复制代码

各层都可以闻名字（可以是字符串，也可以是别的Python对象）。假如指定了名称，它们就会显示在控制台输出中：

1. In [20]: frame.index.names = ['key1', 'key2']
3. In [21]: frame.columns.names = ['state', 'color']
5. In [22]: frame
6. Out[22]:
7. state      Ohio     Colorado
8. color     Green Red    Green
9. key1 key2                  
10. a    1        0   1        2
11.      2        3   4        5
12. b    1        6   7        8
13.      2        9  10       11

复制代码

  注意：小心区分索引名state、color与行标签。
  有了部门列索引，因此可以轻松选取列分组：

1. In [23]: frame['Ohio']
2. Out[23]:
3. color      Green  Red
4. key1 key2            
5. a    1         0    1
6.      2         3    4
7. b    1         6    7
8.      2         9   10

复制代码

可以单独创建MultiIndex然后复用。上面谁人DataFrame中的（带有分级名称）列可以这样创建：

1. MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
2.                        names=['state', 'color'])

复制代码

重排与分级排序

偶然，你需要重新调整某条轴上各级别的次序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个交换了级别的新对象（但数据不会发生变化）：

1. In [24]: frame.swaplevel('key1', 'key2')
2. Out[24]:
3. state      Ohio     Colorado
4. color     Green Red    Green
5. key2 key1                  
6. 1    a        0   1        2
7. 2    a        3   4        5
8. 1    b        6   7        8
9. 2    b        9  10       11

复制代码

而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最闭幕果就是按照指定次序进行字母排序了：

1. In [25]: frame.sort_index(level=1)
2. Out[25]:
3. state      Ohio     Colorado
4. color     Green Red    Green
5. key1 key2                  
6. a    1        0   1        2
7. b    1        6   7        8
8. a    2        3   4        5
9. b    2        9  10       11
11. In [26]: frame.swaplevel(0, 1).sort_index(level=0)
12. Out[26]:
13. state      Ohio     Colorado
14. color     Green Red    Green
15. key2 key1                  
16. 1    a        0   1        2
17.      b        6   7        8
18. 2    a        3   4        5
19.      b        9  10       11

复制代码

根据级别汇总统计

许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面谁人DataFrame为例，我们可以根据行或列上的级别来进行求和：

1. In [27]: frame.sum(level='key2')
2. Out[27]:
3. state  Ohio     Colorado
4. color Green Red    Green
5. key2                    
6. 1         6   8       10
7. 2        12  14       16
9. In [28]: frame.sum(level='color', axis=1)
10. Out[28]:
11. color      Green  Red
12. key1 key2            
13. a    1         2    1
14.      2         8    4
15. b    1        14    7
16.      2        20   10

复制代码

这实在是利用了pandas的groupby功能，本书稍后将对其进行详细讲解。
利用DataFrame的列进行索引

人们常常想要将DataFrame的一个或多个列当做行索引来用，大概可能希望将行索引酿成DataFrame的列。以下面这个DataFrame为例：

1. In [29]: frame = pd.DataFrame({'a': range(7), 'b': range(7, 0, -1),
2.    ....:                       'c': ['one', 'one', 'one', 'two', 'two',
3.    ....:                             'two', 'two'],
4.    ....:                       'd': [0, 1, 2, 0, 1, 2, 3]})
6. In [30]: frame
7. Out[30]:
8.    a  b    c  d
9. 0  0  7  one  0
10. 1  1  6  one  1
11. 2  2  5  one  2
12. 3  3  4  two  0
13. 4  4  3  two  1
14. 5  5  2  two  2
15. 6  6  1  two  3

复制代码

DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：

1. In [31]: frame2 = frame.set_index(['c', 'd'])
3. In [32]: frame2
4. Out[32]:
5.        a  b
6. c   d      
7. one 0  0  7
8.     1  1  6
9.     2  2  5
10. two 0  3  4
11.     1  4  3
12.     2  5  2
13.     3  6  1

复制代码

默认情况下，那些列会从DataFrame中移除，但也可以将其保存下来：

1. In [33]: frame.set_index(['c', 'd'], drop=False)
2. Out[33]:
3.        a  b    c  d
4. c   d              
5. one 0  0  7  one  0
6.     1  1  6  one  1
7.     2  2  5  one  2
8. two 0  3  4  two  0
9.     1  4  3  two  1
10.     2  5  2  two  2
11.     3  6  1  two  3

复制代码

reset_index的功能跟set_index刚好相反，条理化索引的级别会被转移到列内里：

1. In [34]: frame2.reset_index()
2. Out[34]:
3. c  d  a  b
4. 0  one  0  0  7
5. 1  one  1  1  6
6. 2  one  2  2  5
7. 3  two  0  3  4
8. 4  two  1  4  3
9. 5  two  2  5  2
10. 6  two  3  6  1

复制代码

8.2 归并数据集

pandas对象中的数据可以通过一些方式进行归并：

• pandas.merge可根据一个或多个键将差异DataFrame中的行毗连起来。SQL或其他关系型数据库的用户对此应该会比较熟悉，由于它实现的就是数据库的join操作。
  
• pandas.concat可以沿着一条轴将多个对象堆叠到一起。
  
• 实例方法combine_first可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。
  

我将分别对它们进行讲解，并给出一些例子。本书剩余部门的示例中将常常用到它们。
##数据库风格的DataFrame归并
数据集的归并（merge）或毗连（join）运算是通过一个或多个键将行毗连起来的。这些运算是关系型数据库（基于SQL）的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
以一个简单的例子开始：

1. In [35]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
2.    ....:                     'data1': range(7)})
4. In [36]: df2 = pd.DataFrame({'key': ['a', 'b', 'd'],
5.    ....:                     'data2': range(3)})
7. In [37]: df1
8. Out[37]:
9.    data1 key
10. 0      0   b
11. 1      1   b
12. 2      2   a
13. 3      3   c
14. 4      4   a
15. 5      5   a
16. 6      6   b
18. In [38]: df2
19. Out[38]:
20.    data2 key
21. 0      0   a
22. 1      1   b
23. 2      2   d

复制代码

这是一种多对一的归并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到：

1. In [39]: pd.merge(df1, df2)
2. Out[39]:
3.    data1 key  data2
4. 0      0   b      1
5. 1      1   b      1
6. 2      6   b      1
7. 3      2   a      0
8. 4      4   a      0
9. 5      5   a      0

复制代码

注意，我并没有指明要用哪个列进行毗连。假如没有指定，merge就会将重叠列的列名当做键。不外，最好明确指定一下：

1. In [40]: pd.merge(df1, df2, on='key')
2. Out[40]:
3.    data1 key  data2
4. 0      0   b      1
5. 1      1   b      1
6. 2      6   b      1
7. 3      2   a      0
8. 4      4   a      0
9. 5      5   a      0

复制代码

假如两个对象的列名差异，也可以分别进行指定：

1. In [41]: df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
2.    ....:                     'data1': range(7)})
4. In [42]: df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],
5.    ....:                     'data2': range(3)})
7. In [43]: pd.merge(df3, df4, left_on='lkey', right_on='rkey')
8. Out[43]:
9.    data1 lkey  data2 rkey
10. 0      0    b      1    b
11. 1      1    b      1    b
12. 2      6    b      1    b
13. 3      2    a      0    a
14. 4      4    a      0    a
15. 5      5    a      0    a

复制代码

可能你已经注意到了，结果内里c和d以及与之相关的数据消失了。默认情况下，merge做的是“内毗连”；结果中的键是交集。其他方式还有"left"、“right"以及"outer”。外毗连求取的是键的并集，组合了左毗连和右毗连的效果：

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

复制代码

表8-1对这些选项进行了总结。

多对多的归并有些不直观。看下面的例子：

1. In [45]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
2.    ....:                     'data1': range(6)})
4. In [46]: df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],
5.    ....:                     'data2': range(5)})
7. In [47]: df1
8. Out[47]:
9.    data1 key
10. 0      0   b
11. 1      1   b
12. 2      2   a
13. 3      3   c
14. 4      4   a
15. 5      5   b
17. In [48]: df2
18. Out[48]:
19.    data2 key
20. 0      0   a
21. 1      1   b
22. 2      2   a
23. 3      3   b
24. 4      4   d
26. In [49]: pd.merge(df1, df2, on='key', how='left')
27. Out[49]:
28.     data1 key  data2
29. 0       0   b    1.0
30. 1       0   b    3.0
31. 2       1   b    1.0
32. 3       1   b    3.0
33. 4       2   a    0.0
34. 5       2   a    2.0
35. 6       3   c    NaN
36. 7       4   a    0.0
37. 8       4   a    2.0
38. 9       5   b    1.0
39. 10      5   b    3.0

复制代码

多对多毗连产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最闭幕果中就有6个"b"行。毗连方式只影响出如今结果中的差异的键的值：

1. In [50]: pd.merge(df1, df2, how='inner')
2. Out[50]:
3.    data1 key  data2
4. 0      0   b      1
5. 1      0   b      3
6. 2      1   b      1
7. 3      1   b      3
8. 4      5   b      1
9. 5      5   b      3
10. 6      2   a      0
11. 7      2   a      2
12. 8      4   a      0
13. 9      4   a      2

复制代码

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

1. In [51]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
2.    ....:                      'key2': ['one', 'two', 'one'],
3.    ....:                      'lval': [1, 2, 3]})
5. In [52]: right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
6.    ....:                       'key2': ['one', 'one', 'one', 'two'],
7.    ....:                       'rval': [4, 5, 6, 7]})
9. In [53]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
10. Out[53]:
11.   key1 key2  lval  rval
12. 0  foo  one   1.0   4.0
13. 1  foo  one   1.0   5.0
14. 2  foo  two   2.0   NaN
15. 3  bar  one   3.0   6.0
16. 4  bar  two   NaN   7.0

复制代码

结果中会出现哪些键组合取决于所选的归并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个毗连键（固然，现实上并不是这么回事）。
   注意：在进行列－列毗连时，DataFrame对象中的索引会被丢弃。
  对于归并运算需要考虑的最后一个问题是对重复列名的处理惩罚。虽然你可以手工处理惩罚列名重叠的问题（检察前面介绍的重命名轴标签），但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：

1. In [54]: pd.merge(left, right, on='key1')
2. Out[54]:
3.   key1 key2_x  lval key2_y  rval
4. 0  foo    one     1    one     4
5. 1  foo    one     1    one     5
6. 2  foo    two     2    one     4
7. 3  foo    two     2    one     5
8. 4  bar    one     3    one     6
9. 5  bar    one     3    two     7
11. In [55]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
12. Out[55]:
13.   key1 key2_left  lval key2_right  rval
14. 0  foo       one     1        one     4
15. 1  foo       one     1        one     5
16. 2  foo       two     2        one     4
17. 3  foo       two     2        one     5
18. 4  bar       one     3        one     6
19. 5  bar       one     3        two     7

复制代码

merge的参数请拜见表8-2。利用DataFrame的行索引归并是下一节的主题。
表8-2 merge函数的参数

indicator 添加特殊的列_merge，它可以指明每个行的泉源，它的值有left_only、right_only或both，根据每行的归并数据的泉源。
索引上的归并

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

1. In [56]: left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
2.    ....:                       'value': range(6)})
4. In [57]: right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
6. In [58]: left1
7. Out[58]:
9.   key  value
10. 0   a      0
11. 1   b      1
12. 2   a      2
13. 3   a      3
14. 4   b      4
15. 5   c      5
17. In [59]: right1
18. Out[59]:
19.    group_val
20. a        3.5
21. b        7.0
23. In [60]: pd.merge(left1, right1, left_on='key', right_index=True)
24. Out[60]:
25.   key  value  group_val
26. 0   a      0        3.5
27. 2   a      2        3.5
28. 3   a      3        3.5
29. 1   b      1        7.0
30. 4   b      4        7.0

复制代码

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

1. In [61]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
2. Out[61]:
3.   key  value  group_val
4. 0   a      0        3.5
5. 2   a      2        3.5
6. 3   a      3        3.5
7. 1   b      1        7.0
8. 4   b      4        7.0
9. 5   c      5        NaN

复制代码

对于条理化索引的数据，事变就有点复杂了，由于索引的归并默认是多键归并：

1. In [62]: lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio',
2.    ....:                                'Nevada', 'Nevada'],
3.    ....:                       'key2': [2000, 2001, 2002, 2001, 2002],
4.    ....:                       'data': np.arange(5.)})
6. In [63]: righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
7.    ....:                       index=[['Nevada', 'Nevada', 'Ohio', 'Ohio',
8.    ....:                               'Ohio', 'Ohio'],
9.    ....:                              [2001, 2000, 2000, 2000, 2001, 2002]],
10.    ....:                       columns=['event1', 'event2'])
12. In [64]: lefth
13. Out[64]:
14.    data    key1  key2
15. 0   0.0    Ohio  2000
16. 1   1.0    Ohio  2001
17. 2   2.0    Ohio  2002
18. 3   3.0  Nevada  2001
19. 4   4.0  Nevada  2002
21. In [65]: righth
22. Out[65]:
23.              event1  event2
24. Nevada 2001       0       1
25.        2000       2       3
26. Ohio   2000       4       5
27.        2000       6       7
28.        2001       8       9
29.        2002      10      11

复制代码

这种情况下，你必须以列表的形式指明用作归并键的多个列（注意用how='outer’对重复索引值的处理惩罚）：

1. In [66]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
2. Out[66]:
3.    data    key1  key2  event1  event2
4. 0   0.0    Ohio  2000       4       5
5. 0   0.0    Ohio  2000       6       7
6. 1   1.0    Ohio  2001       8       9
7. 2   2.0    Ohio  2002      10      11
8. 3   3.0  Nevada  2001       0       1
10. In [67]: pd.merge(lefth, righth, left_on=['key1', 'key2'],
11.    ....:          right_index=True, how='outer')
12. Out[67]:
13.    data    key1  key2  event1  event2
14. 0   0.0    Ohio  2000     4.0     5.0
15. 0   0.0    Ohio  2000     6.0     7.0
16. 1   1.0    Ohio  2001     8.0     9.0
17. 2   2.0    Ohio  2002    10.0    11.0
18. 3   3.0  Nevada  2001     0.0     1.0
19. 4   4.0  Nevada  2002     NaN     NaN
20. 4   NaN  Nevada  2000     2.0     3.0

复制代码

同时利用归并两边的索引也没问题：

1. In [68]: left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
2.    ....:                      index=['a', 'c', 'e'],
3.    ....:                      columns=['Ohio', 'Nevada'])
5. In [69]: right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
6.    ....:                       index=['b', 'c', 'd', 'e'],
7.    ....:                       columns=['Missouri', 'Alabama'])
9. In [70]: left2
10. Out[70]:
11.    Ohio  Nevada
12. a   1.0     2.0
13. c   3.0     4.0
14. e   5.0     6.0
16. In [71]: right2
17. Out[71]:
18.    Missouri  Alabama
19. b       7.0      8.0
20. c       9.0     10.0
21. d      11.0     12.0
22. e      13.0     14.0
24. In [72]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
25. Out[72]:
26.    Ohio  Nevada  Missouri  Alabama
27. a   1.0     2.0       NaN      NaN
28. b   NaN     NaN       7.0      8.0
29. c   3.0     4.0       9.0     10.0
30. d   NaN     NaN      11.0     12.0
31. e   5.0     6.0      13.0     14.0

复制代码

DataFrame还有一个便捷的join实例方法，它能更为方便地实现按索引归并。它还可用于归并多个带有雷同或相似索引的DataFrame对象，但要求没有重叠的列。在上面谁人例子中，我们可以编写：

1. In [73]: left2.join(right2, how='outer')
2. Out[73]:
3.    Ohio  Nevada  Missouri  Alabama
4. a   1.0     2.0       NaN      NaN
5. b   NaN     NaN       7.0      8.0
6. c   3.0     4.0       9.0     10.0
7. d   NaN     NaN      11.0     12.0
8. e   5.0     6.0      13.0     14.0

复制代码

由于一些汗青版本的遗留原因，DataFrame的join方法默认利用的是左毗连，保存左边表的行索引。它还支持在调用的DataFrame的列上，毗连通报的DataFrame索引：

1. In [74]: left1.join(right1, on='key')
2. Out[74]:
3.   key  value  group_val
4. 0   a      0        3.5
5. 1   b      1        7.0
6. 2   a      2        3.5
7. 3   a      3        3.5
8. 4   b      4        7.0
9. 5   c      5        NaN

复制代码

最后，对于简单的索引归并，你还可以向join传入一组DataFrame，下一节会介绍更为通用的concat函数，也能实现此功能：

1. In [75]: another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
2.    ....:                        index=['a', 'c', 'e', 'f'],
3.    ....:                        columns=['New York',
4. 'Oregon'])
6. In [76]: another
7. Out[76]:
8.    New York  Oregon
9. a       7.0     8.0
10. c       9.0    10.0
11. e      11.0    12.0
12. f      16.0    17.0
14. In [77]: left2.join([right2, another])
15. Out[77]:
16.    Ohio  Nevada  Missouri  Alabama  New York  Oregon
17. a   1.0     2.0       NaN      NaN       7.0     8.0
18. c   3.0     4.0       9.0     10.0       9.0    10.0
19. e   5.0     6.0      13.0     14.0      11.0    12.0
21. In [78]: left2.join([right2, another], how='outer')
22. Out[78]:
23.    Ohio  Nevada  Missouri  Alabama  New York  Oregon
24. a   1.0     2.0       NaN      NaN       7.0     8.0
25. b   NaN     NaN       7.0      8.0       NaN     NaN
26. c   3.0     4.0       9.0     10.0       9.0    10.0
27. d   NaN     NaN      11.0     12.0       NaN     NaN
28. e   5.0     6.0      13.0     14.0      11.0    12.0
29. f   NaN     NaN       NaN      NaN      16.0    17.0

复制代码

轴向毗连

另一种数据归并运算也被称作毗连（concatenation）、绑定（binding）或堆叠（stacking）。NumPy的concatenation函数可以用NumPy数组来做：

1. In [79]: arr = np.arange(12).reshape((3, 4))
3. In [80]: arr
4. Out[80]:
5. array([[ 0,  1,  2,  3],
6.        [ 4,  5,  6,  7],
7.        [ 8,  9, 10, 11]])
9. In [81]: np.concatenate([arr, arr], axis=1)
10. Out[81]:
11. array([[ 0,  1,  2,  3,  0,  1,  2,  3],
12.        [ 4,  5,  6,  7,  4,  5,  6,  7],
13.        [ 8,  9, 10, 11,  8,  9, 10, 11]])

复制代码

对于pandas对象（如Series和DataFrame），带有标签的轴使你可以大概进一步推广数组的毗连运算。具体点说，你还需要考虑以下这些东西：

• 假如对象在别的轴上的索引差异，我们应该归并这些轴的差异元素还是只利用交集？
  
• 毗连的数据集是否需要在结果对象中可识别？
  
• 毗连轴中保存的数据是否需要保存？许多情况下，DataFrame默认的整数标签最好在毗连时删掉。
  

pandas的concat函数提供了一种可以大概办理这些问题的可靠方式。我将给出一些例子来讲解其利用方式。假设有三个没有重叠索引的Series：

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

复制代码

对这些对象调用concat可以将值和索引粘合在一起：

1. In [85]: pd.concat([s1, s2, s3])
2. Out[85]:
3. a    0
4. b    1
5. c    2
6. d    3
7. e    4
8. f    5
9. g    6
10. dtype: int64

复制代码

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

1. In [86]: pd.concat([s1, s2, s3], axis=1)
2. Out[86]:
3.      0    1    2
4. a  0.0  NaN  NaN
5. b  1.0  NaN  NaN
6. c  NaN  2.0  NaN
7. d  NaN  3.0  NaN
8. e  NaN  4.0  NaN
9. f  NaN  NaN  5.0
10. g  NaN  NaN  6.0

复制代码

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

1. In [87]: s4 = pd.concat([s1, s3])
3. In [88]: s4
4. Out[88]:
5. a    0
6. b    1
7. f    5
8. g    6
9. dtype: int64
11. In [89]: pd.concat([s1, s4], axis=1)
12. Out[89]:
13.      0  1
14. a  0.0  0
15. b  1.0  1
16. f  NaN  5
17. g  NaN  6
19. In [90]: pd.concat([s1, s4], axis=1, join='inner')
20. Out[90]:
21.    0  1
22. a  0  0
23. b  1  1

复制代码

在这个例子中，f和g标签消失了，是由于利用的是join='inner’选项。
你可以通过join_axes指定要在别的轴上利用的索引：

1. In [91]: pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])
2. Out[91]:
3.      0    1
4. a  0.0  0.0
5. c  NaN  NaN
6. b  1.0  1.0
7. e  NaN  NaN

复制代码

不外有个问题，到场毗连的片断在结果中区分不开。假设你想要在毗连轴上创建一个条理化索引。利用keys参数即可到达这个目标：

1. In [92]: result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
3. In [93]: result
4. Out[93]:
5. one    a    0
6.        b    1
7. two    a    0
8.        b    1
9. three  f    5
10.        g    6
11. dtype: int64
13. In [94]: result.unstack()
14. Out[94]:
15.          a    b    f    g
16. one    0.0  1.0  NaN  NaN
17. two    0.0  1.0  NaN  NaN
18. three  NaN  NaN  5.0  6.0

复制代码

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

1. In [95]: pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
2. Out[95]:
3.    one  two  three
4. a  0.0  NaN    NaN
5. b  1.0  NaN    NaN
6. c  NaN  2.0    NaN
7. d  NaN  3.0    NaN
8. e  NaN  4.0    NaN
9. f  NaN  NaN    5.0
10. g  NaN  NaN    6.0

复制代码

同样的逻辑也适用于DataFrame对象：

1. In [96]: df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
2.    ....:                    columns=['one', 'two'])
4. In [97]: df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
5.    ....:                    columns=['three', 'four'])
7. In [98]: df1
8. Out[98]:
9.    one  two
10. a    0    1
11. b    2    3
12. c    4    5
14. In [99]: df2
15. Out[99]:
16.    three  four
17. a      5     6
18. c      7     8
20. In [100]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
21. Out[100]:
22.   level1     level2     
23.      one two  three four
24. a      0   1    5.0  6.0
25. b      2   3    NaN  NaN
26. c      4   5    7.0  8.0

复制代码

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

1. In [101]: pd.concat({'level1': df1, 'level2': df2}, axis=1)
3. Out[101]:
4.   level1     level2     
5.      one two  three four
6. a      0   1    5.0  6.0
7. b      2   3    NaN  NaN
8. c      4   5    7.0  8.0

复制代码

别的还有两个用于管理条理化索引创建方式的参数（拜见表8-3）。举个例子，我们可以用names参数命名创建的轴级别：

1. In [102]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],
2.    .....:           names=['upper', 'lower'])
3. Out[102]:
4. upper level1     level2     
5. lower    one two  three four
6. a          0   1    5.0  6.0
7. b          2   3    NaN  NaN
8. c          4   5    7.0  8.0

复制代码

最后一个关于DataFrame的问题是，DataFrame的行索引不包罗任何相关数据：

1. In [103]: df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
3. In [104]: df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
5. In [105]: df1
6. Out[105]:
7.           a         b         c         d
8. 0  1.246435  1.007189 -1.296221  0.274992
9. 1  0.228913  1.352917  0.886429 -2.001637
10. 2 -0.371843  1.669025 -0.438570 -0.539741
12. In [106]: df2
13. Out[106]:
14.           b         d         a
15. 0  0.476985  3.248944 -1.021228
16. 1 -0.577087  0.124121  0.302614

复制代码

在这种情况下，传入ignore_index=True即可：

1. In [107]: pd.concat([df1, df2], ignore_index=True)
2. Out[107]:
3.           a         b         c         d
4. 0  1.246435  1.007189 -1.296221  0.274992
5. 1  0.228913  1.352917  0.886429 -2.001637
6. 2 -0.371843  1.669025 -0.438570 -0.539741
7. 3 -1.021228  0.476985       NaN  3.248944
8. 4  0.302614 -0.577087       NaN  0.124121

复制代码

归并重叠数据

还有一种数据组合问题不能用简单的归并（merge）或毗连（concatenation）运算来处理惩罚。比如说，你可能有索引全部或部门重叠的两个数据集。举个有启发性的例子，我们利用NumPy的where函数，它表现一种等价于面向数组的if-else：

1. In [108]: a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
2.    .....:               index=['f', 'e', 'd', 'c', 'b', 'a'])
4. In [109]: b = pd.Series(np.arange(len(a), dtype=np.float64),
5.    .....:               index=['f', 'e', 'd', 'c', 'b', 'a'])
7. In [110]: b[-1] = np.nan
9. In [111]: a
10. Out[111]:
11. f    NaN
12. e    2.5
13. d    NaN
14. c    3.5
15. b    4.5
16. a    NaN
17. dtype: float64
19. In [112]: b
20. Out[112]:
21. f    0.0
22. e    1.0
23. d    2.0
24. c    3.0
25. b    4.0
26. a    NaN
27. dtype: float64
29. In [113]: np.where(pd.isnull(a), b, a)
30. Out[113]: array([ 0. ,  2.5,  2. ,  3.5,  4.5,  nan])

复制代码

Series有一个combine_first方法，实现的也是一样的功能，还带有pandas的数据对齐：

1. In [114]: b[:-2].combine_first(a[2:])
2. Out[114]:
3. a    NaN
4. b    4.5
5. c    3.0
6. d    2.0
7. e    1.0
8. f    0.0
9. dtype: float64

复制代码

对于DataFrame，combine_first天然也会在列上做同样的事变，因此你可以将其看做：用通报对象中的数据为调用对象的缺失数据“打补丁”：

1. In [115]: df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
2.    .....:                     'b': [np.nan, 2., np.nan, 6.],
3.    .....:                     'c': range(2, 18, 4)})
5. In [116]: df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],
6.    .....:                     'b': [np.nan, 3., 4., 6., 8.]})
8. In [117]: df1
9. Out[117]:
10.      a    b   c
11. 0  1.0  NaN   2
12. 1  NaN  2.0   6
13. 2  5.0  NaN  10
14. 3  NaN  6.0  14
16. In [118]: df2
17. Out[118]:
18.      a    b
19. 0  5.0  NaN
20. 1  4.0  3.0
21. 2  NaN  4.0
22. 3  3.0  6.0
23. 4  7.0  8.0
25. In [119]: df1.combine_first(df2)
26. Out[119]:
27.      a    b     c
28. 0  1.0  NaN   2.0
29. 1  4.0  2.0   6.0
30. 2  5.0  4.0  10.0
31. 3  3.0  6.0  14.0
32. 4  7.0  8.0   NaN

复制代码

8.3 重塑和轴向旋转

有许多用于重新排列表格型数据的底子运算。这些函数也称作重塑（reshape）或轴向旋转（pivot）运算。
重塑条理化索引

条理化索引为DataFrame数据的重排任务提供了一种具有良好一致性的方式。主要功能有二：

• stack：将数据的列“旋转”为行。
  
• unstack：将数据的行“旋转”为列。
  

我将通过一系列的范例来讲解这些操作。接下来看一个简单的DataFrame，此中的行列索引均为字符串数组：

1. In [120]: data = pd.DataFrame(np.arange(6).reshape((2, 3)),
2.    .....:                     index=pd.Index(['Ohio','Colorado'], name='state'),
3.    .....:                     columns=pd.Index(['one', 'two', 'three'],
4.    .....:                     name='number'))
6. In [121]: data
7. Out[121]:
8. number    one  two  three
9. state                    
10. Ohio        0    1      2
11. Colorado    3    4      5

复制代码

对该数据利用stack方法即可将列转换为行，得到一个Series：

1. In [122]: result = data.stack()
3. In [123]: result
4. Out[123]:
5. state     number
6. Ohio      one       0
7.           two       1
8.           three     2
9. Colorado  one       3
10.           two       4
11.           three     5
12. dtype: int64

复制代码

对于一个条理化索引的Series，你可以用unstack将其重排为一个DataFrame：

1. In [124]: result.unstack()
2. Out[124]:
3. number    one  two  three
4. state                    
5. Ohio        0    1      2
6. Colorado    3    4      5

复制代码

默认情况下，unstack操作的是最内层（stack也是如此）。传入分层级别的编号或名称即可对别的级别进行unstack操作：

1. In [125]: result.unstack(0)
2. Out[125]:
3. state   Ohio  Colorado
4. number               
5. one        0         3
6. two        1         4
7. three      2         5
9. In [126]: result.unstack('state')
10. Out[126]:
11. state   Ohio  Colorado
12. number               
13. one        0         3
14. two        1         4
15. three      2         5

复制代码

假如不是所有的级别值都能在各分组中找到的话，则unstack操作可能会引入缺失数据：

1. In [127]: s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
3. In [128]: s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
5. In [129]: data2 = pd.concat([s1, s2], keys=['one', 'two'])
7. In [130]: data2
8. Out[130]:
9. one  a    0
10.      b    1
11.      c    2
12.      d    3
13. two  c    4
14.      d    5
15.      e    6
16. dtype: int64
18. In [131]: data2.unstack()
19. Out[131]:
20.        a    b    c    d    e
21. one  0.0  1.0  2.0  3.0  NaN
22. two  NaN  NaN  4.0  5.0  6.0

复制代码

stack默认会滤除缺失数据，因此该运算是可逆的：

1. In [132]: data2.unstack()
2. Out[132]:
3.        a    b    c    d    e
4. one  0.0  1.0  2.0  3.0  NaN
5. two  NaN  NaN  4.0  5.0  6.0
7. In [133]: data2.unstack().stack()
8. Out[133]:
9. one  a    0.0
10.      b    1.0
11.      c    2.0
12.      d    3.0
13. two  c    4.0
14.      d    5.0
15.      e    6.0
16. dtype: float64
18. In [134]: data2.unstack().stack(dropna=False)
19. Out[134]:
20. one  a    0.0
21.      b    1.0
22.      c    2.0
23.      d    3.0
24.      e    NaN
25. two  a    NaN
26.      b    NaN
27.      c    4.0
28.      d    5.0
29.      e    6.0
30. dtype: float64

复制代码

在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别：

1. In [135]: df = pd.DataFrame({'left': result, 'right': result + 5},
2.    .....:                   columns=pd.Index(['left', 'right'], name='side'))
4. In [136]: df
5. Out[136]:
6. side             left  right
7. state    number            
8. Ohio     one        0      5
9.          two        1      6
10.          three      2      7
11. Colorado one        3      8
12.          two        4      9
13.          three      5     10
15. In [137]: df.unstack('state')
16. Out[137]:
17. side   left          right
18. state  Ohio Colorado  Ohio Colorado
19. number                             
20. one       0        3     5        8
21. two       1        4     6        9
22. three     2        5     7       10

复制代码

当调用stack，我们可以指明轴的名字：

1. In [138]: df.unstack('state').stack('side')
2. Out[138]:
3. state         Colorado  Ohio
4. number side                 
5. one    left          3     0
6.        right         8     5
7. two    left          4     1
8.        right         9     6
9. three  left          5     2
10.        right        10     7

复制代码

将“长格式”旋转为“宽格式”

多个时间序列数据通常是以所谓的“长格式”（long）或“堆叠格式”（stacked）存储在数据库和CSV中的。我们先加载一些示例数据，做一些时间序列规整和数据洗濯：

1. In [139]: data = pd.read_csv('examples/macrodata.csv')
3. In [140]: data.head()
4. Out[140]:
5.      year  quarter   realgdp  realcons  realinv  realgovt  realdpi    cpi  \
6. 0  1959.0      1.0  2710.349    1707.4  286.898   470.045   1886.9  28.98   
7. 1  1959.0      2.0  2778.801    1733.7  310.859   481.301   1919.7  29.15   
8. 2  1959.0      3.0  2775.488    1751.8  289.226   491.260   1916.4  29.35   
9. 3  1959.0      4.0  2785.204    1753.7  299.356   484.052   1931.3  29.37   
10. 4  1960.0      1.0  2847.699    1770.5  331.722   462.199   1955.5  29.54   
11.       m1  tbilrate  unemp      pop  infl  realint  
12. 0  139.7      2.82    5.8  177.146  0.00     0.00
13. 1  141.7      3.08    5.1  177.830  2.34     0.74  
14. 2  140.5      3.82    5.3  178.657  2.74     1.09  
15. 3  140.0      4.33    5.6  179.386  0.27     4.06  
16. 4  139.6      3.50    5.2  180.007  2.31     1.19  
18. In [141]: periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,
19.    .....:                          name='date')
21. In [142]: columns = pd.Index(['realgdp', 'infl', 'unemp'], name='item')
23. In [143]: data = data.reindex(columns=columns)
25. In [144]: data.index = periods.to_timestamp('D', 'end')
27. In [145]: ldata = data.stack().reset_index().rename(columns={0: 'value'})

复制代码

这就是多个时间序列（大概别的带有两个或多个键的可观察数据，这里，我们的键是date和item）的长格式。表中的每行代表一次观察。
关系型数据库（如MySQL）中的数据常常都是这样存储的，由于固定架构（即列名和数据类型）有一个利益：随着表中数据的添加，item列中的值的种类可以大概增加。在前面的例子中，date和item通常就是主键（用关系型数据库的说法），不光提供了关系完整性，而且提供了更为简单的查询支持。有的情况下，利用这样的数据会很麻烦，你可能会更喜欢DataFrame，差异的item值分别形成一列，date列中的时间戳则用作索引。DataFrame的pivot方法完全可以实现这个转换：

1. In [147]: pivoted = ldata.pivot('date', 'item', 'value')
3. In [148]: pivoted
4. Out[148]:
5. item        infl    realgdp  unemp
6. date                              
7. 1959-03-31  0.00   2710.349    5.8
8. 1959-06-30  2.34   2778.801    5.1
9. 1959-09-30  2.74   2775.488    5.3
10. 1959-12-31  0.27   2785.204    5.6
11. 1960-03-31  2.31   2847.699    5.2
12. 1960-06-30  0.14   2834.390    5.2
13. 1960-09-30  2.70   2839.022    5.6
14. 1960-12-31  1.21   2802.616    6.3
15. 1961-03-31 -0.40   2819.264    6.8
16. 1961-06-30  1.47   2872.005    7.0
17. ...          ...        ...    ...
18. 2007-06-30  2.75  13203.977    4.5
19. 2007-09-30  3.45  13321.109    4.7
20. 2007-12-31  6.38  13391.249    4.8
21. 2008-03-31  2.82  13366.865    4.9
22. 2008-06-30  8.53  13415.266    5.4
23. 2008-09-30 -3.16  13324.600    6.0
24. 2008-12-31 -8.79  13141.920    6.9
25. 2009-03-31  0.94  12925.410    8.1
26. 2009-06-30  3.37  12901.504    9.2
27. 2009-09-30  3.56  12990.341    9.6
28. [203 rows x 3 columns]

复制代码

前两个通报的值分别用作行和列索引，最后一个可选值则是用于填充DataFrame的数据列。假设有两个需要同时重塑的数据列：

1. In [149]: ldata['value2'] = np.random.randn(len(ldata))
3. In [150]: ldata[:10]
4. Out[150]:
5.         date     item     value    value2
6. 0 1959-03-31  realgdp  2710.349  0.523772
7. 1 1959-03-31     infl     0.000  0.000940
8. 2 1959-03-31    unemp     5.800  1.343810
9. 3 1959-06-30  realgdp  2778.801 -0.713544
10. 4 1959-06-30     infl     2.340 -0.831154
11. 5 1959-06-30    unemp     5.100 -2.370232
12. 6 1959-09-30  realgdp  2775.488 -1.860761
13. 7 1959-09-30     infl     2.740 -0.860757
14. 8 1959-09-30    unemp     5.300  0.560145
15. 9 1959-12-31  realgdp  2785.204 -1.265934

复制代码

假如忽略最后一个参数，得到的DataFrame就会带有条理化的列：

1. In [151]: pivoted = ldata.pivot('date', 'item')
3. In [152]: pivoted[:5]
4. Out[152]:
5.            value                    value2                    
6. item        infl   realgdp unemp      infl   realgdp     unemp
7. date                                                         
8. 1959-03-31  0.00  2710.349   5.8  0.000940  0.523772  1.343810
9. 1959-06-30  2.34  2778.801   5.1 -0.831154 -0.713544 -2.370232
10. 1959-09-30  2.74  2775.488   5.3 -0.860757 -1.860761  0.560145
11. 1959-12-31  0.27  2785.204   5.6  0.119827 -1.265934 -1.063512
12. 1960-03-31  2.31  2847.699   5.2 -2.359419  0.332883 -0.199543
14. In [153]: pivoted['value'][:5]
15. Out[153]:
16. item        infl   realgdp  unemp
17. date                             
18. 1959-03-31  0.00  2710.349    5.8
19. 1959-06-30  2.34  2778.801    5.1
20. 1959-09-30  2.74  2775.488    5.3
21. 1959-12-31  0.27  2785.204    5.6
22. 1960-03-31  2.31  2847.699    5.2

复制代码

注意，pivot实在就是用set_index创建条理化索引，再用unstack重塑：

1. In [154]: unstacked = ldata.set_index(['date', 'item']).unstack('item')
3. In [155]: unstacked[:7]
4. Out[155]:
5.            value                    value2                    
6. item        infl   realgdp unemp      infl   realgdp     unemp
7. date                                                         
8. 1959-03-31  0.00  2710.349   5.8  0.000940  0.523772  1.343810
9. 1959-06-30  2.34  2778.801   5.1 -0.831154 -0.713544 -2.370232
10. 1959-09-30  2.74  2775.488   5.3 -0.860757 -1.860761  0.560145
11. 1959-12-31  0.27  2785.204   5.6  0.119827 -1.265934 -1.063512
12. 1960-03-31  2.31  2847.699   5.2 -2.359419  0.332883 -0.199543
13. 1960-06-30  0.14  2834.390   5.2 -0.970736 -1.541996 -1.307030
14. 1960-09-30  2.70  2839.022   5.6  0.377984  0.286350 -0.753887

复制代码

将“宽格式”旋转为“长格式”

旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame，而是归并多个列成为一个，产生一个比输入长的DataFrame。看一个例子：

1. In [157]: df = pd.DataFrame({'key': ['foo', 'bar', 'baz'],
2.    .....:                    'A': [1, 2, 3],
3.    .....:                    'B': [4, 5, 6],
4.    .....:                    'C': [7, 8, 9]})
6. In [158]: df
7. Out[158]:
8.    A  B  C  key
9. 0  1  4  7  foo
10. 1  2  5  8  bar
11. 2  3  6  9  baz

复制代码

key列可能是分组指标，别的的列是数据值。当利用pandas.melt，我们必须指明哪些列是分组指标。下面利用key作为唯一的分组指标：

1. In [159]: melted = pd.melt(df, ['key'])
3. In [160]: melted
4. Out[160]:
5.    key variable  value
6. 0  foo        A      1
7. 1  bar        A      2
8. 2  baz        A      3
9. 3  foo        B      4
10. 4  bar        B      5
11. 5  baz        B      6
12. 6  foo        C      7
13. 7  bar        C      8
14. 8  baz        C      9

复制代码

利用pivot，可以重塑回原来的样子：

1. In [161]: reshaped = melted.pivot('key', 'variable', 'value')
3. In [162]: reshaped
4. Out[162]:
5. variable  A  B  C
6. key              
7. bar       2  5  8
8. baz       3  6  9
9. foo       1  4  7

复制代码

由于pivot的结果从列创建了一个索引，用作行标签，我们可以利用reset_index将数据移回列：

1. In [163]: reshaped.reset_index()
2. Out[163]:
3. variable  key  A  B  C
4. 0         bar  2  5  8
5. 1         baz  3  6  9
6. 2         foo  1  4  7

复制代码

你还可以指定列的子集，作为值的列：

1. In [164]: pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])
2. Out[164]:
3.    key variable  value
4. 0  foo        A      1
5. 1  bar        A      2
6. 2  baz        A      3
7. 3  foo        B      4
8. 4  bar        B      5
9. 5  baz        B      6

复制代码

pandas.melt也可以不消分组指标：

1. In [165]: pd.melt(df, value_vars=['A', 'B', 'C'])
2. Out[165]:
3.   variable  value
4. 0        A      1
5. 1        A      2
6. 2        A      3
7. 3        B      4
8. 4        B      5
9. 5        B      6
10. 6        C      7
11. 7        C      8
12. 8        C      9
14. In [166]: pd.melt(df, value_vars=['key', 'A', 'B'])
15. Out[166]:
16.   variable value
17. 0      key   foo
18. 1      key   bar
19. 2      key   baz
20. 3        A     1
21. 4        A     2
22. 5        A     3
23. 6        B     4
24. 7        B     5
25. 8        B     6

复制代码

#8.4 总结
如今你已经掌握了pandas数据导入、洗濯、重塑，我们可以进一步学习matplotlib数据可视化。我们在稍后会回到pandas，学习更高级的分析。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。