• 在許多應用中，資料可能分散在許多檔案或資料庫中，儲存的形式也不利於分析。本章關注可以聚合、合併、重塑資料的方法。

import pandas as pd
import numpy as np

8.1 層次化索引

• 層次化索引（hierarchical indexing）能在一個軸上擁有多個（兩個以上）索引級別。抽象點說，它使你能以低維度形式處理高維度資料。

data = pd.Series(np.random.randn(9), index = [['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],
                                              [
 
1, 2, 3, 1, 3, 1, 2, 2, 3]])
data

a  1    1.851062
   2    0.498509
   3    1.552038
b  1    0.839059
   3   -0.765026
c  1   -1.431162
   2   -1.587057
d  2   -1.012728
   3    1.318710
dtype: float64

data.index

MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],
           labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])
 

data['a']

1    1.851062
2    0.498509
3    1.552038
dtype: float64

data['b':'c']

b  1    0.839059
   3   -0.765026
c  1   -1.431162
   2   -1.587057
dtype: float64

data.loc[['b','d']]

b  1    0.839059
   3   -0.765026
d  2   -1.012728
   3    1.318710
dtype: float64

• 也可以進行內層選取

data[:,2]

a    0.498509
c   -1.587057
d   -1.012728
dtype: float64
 

data['a'][2]

0.4985087352895496

• 層次化索引在資料重塑和基於分組的操作（如透視表生成）中扮演著重要的角色。例如，可以通過unstack方法將這段資料重新安排到一個DataFrame中：

data.unstack()

• unstack()的逆運算是stack()

data.unstack().stack()

a  1    1.851062
   2    0.498509
   3    1.552038
b  1    0.839059
   3   -0.765026
c  1   -1.431162
   2   -1.587057
d  2   -1.012728
   3    1.318710
dtype: float64

• 對於DataFrame,每條軸都可以有分層索引

frame = pd.DataFrame(np.arange(12).reshape((4,3)),
                    index = [['a','a','b','b'],[1,2,1,2]],
                    columns = [['Ohio', 'Ohio', 'Colorado'],['Green', 'Red', 'Green']])
frame

• 各層都可以有名字（可以是字串，也可以是別的Python物件）。如果指定了名稱，它們就會顯示在控制檯輸出中：

frame.index.names = ['key1','key2']
frame.columns.names = ['state','color']
frame

frame['Ohio']

重排與分級排序

• 需要重新調整某條軸上各級別的順序，或根據指定級別上的值對資料進行排序。swaplevel接受兩個級別編號或名稱，並返回一個互換了級別的新物件（但資料不會發生變化）：

frame

frame.swaplevel('key1', 'key2')

• sort_index則根據單個級別中的值對資料進行排序。交換級別時，常常也會用到sort_index，這樣最終結果就是按照指定順序進行字母排序了：

frame.sort_index(level=1)

frame.swaplevel(0,1).sort_index(level=0)

根據級別彙總統計

• 許多對DataFrame和Series的描述和彙總統計都有一個level選項，它用於指定在某條軸上求和的級別

frame.sum(level=1)

frame.sum(level=0)

frame.sum(level=1,axis=1)

利用DataFrame的列進行索引

• 想要將DataFrame的一個或多個列當做行索引來用，或者可能希望將行索引變成DataFrame的列

frame = pd.DataFrame({'a': range(7), 'b': range(7, 0, -1),
                      'c': ['one', 'one', 'one', 'two', 'two','two', 'two'], 
                      'd': [0, 1, 2, 0, 1, 2, 3]})
frame

#set_index函式會將其一個或多個列轉換為行索引，並建立一個新的DataFrame：
frame2 = frame.set_index(['c','d'])
frame2

#預設情況下，那些列會從DataFrame中移除，但也可以將其保留下來：
frame.set_index(['c','d'],drop=False)

• reset_index()正好與set_index()相反，層次化的索引會被轉移到列裡面

frame2.reset_index()

8.2 合併資料集

pandas物件中的資料可以通過一些方式進行合併：

• pandas.merge可根據一個或多個鍵將不同DataFrame中的行連線起來。它實現的就是資料庫的join操作。
• pandas.concat可以沿著一條軸將多個物件堆疊到一起。
• 例項方法combine_first可以將重複資料拼接在一起，用一個物件中的值填充另一個物件中的缺失值。

pandas.merge()

• 資料集的合併（merge）或連線（join）運算是通過一個或多個鍵將行連線起來的。這些運算是關係型資料庫（基於SQL）的核心.

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

df2

pd.merge(df1,df2)

• 上述程式碼並沒有指明使用哪個列進行連線，這時候預設是將重疊的列名當作鍵。不過最好指明

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)})
df3

df4

pd.merge(df3,df4,left_on = 'lkey', right_on = 'rkey')

• 上述程式碼的結果裡面c和d以及與之相關的資料消失了。預設情況下，merge做的是“內連線”；結果中的鍵是交集。
• 其他方式還有"left"、“right"以及"outer”。外連線求取的是鍵的並集，組合了左連線和右連線的效果：

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

• 要根據多個鍵進行合併，傳入一個由列名組成的list 即可

left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
                     'key2': ['one', 'two', 'one'],
                     'lval': [1, 2, 3]})

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

left

right

• 對於合併運算需要考慮的對重複列名的處理。merge有一個的suffixes選項，用於指定附加到左右兩個DataFrame物件的重疊列名上的字串：

pd.merge(left, right, on = 'key1')

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

• merge的引數如下：

索引上的合併

• DataFrame中的連線鍵位於其索引中。在這種情況下，你可以傳入left_index=True或right_index=True（或兩個都傳）以說明索引應該被用作連線鍵：

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

right1

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

• 預設的merge方法是求取連線鍵的交集，因此你可以通過外連線的方式得到它們的並集：

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

• 對於層次化索引的資料，索引的合併預設是多鍵合併：

lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 
                      'key2': [2000, 2001, 2002, 2001, 2002],
                      'data': np.arange(5.)})
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'])
lefth

righth

• 這種情況下，你必須以列表的形式指明用作合併鍵的多個列（注意用how='outer’對重複索引值的處理）：

pd.merge(lefth, righth, left_on=['key1','key2'], right_index=True)

pd.merge(lefth, righth, left_on=['key1','key2'], right_index=True,how='outer')

• 也可以同時合併雙方的索引

left2 = pd.DataFrame([[1., 2.], [3., 4.