import numpy as np
import pandas as pd

多級索引

資料集存在多個級別的索引標號是可能的，特別是在低維下處理高維資料時。

Series

obj=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]])
obj

帶有層級索引的Series可以轉換成DataFrame，反之亦然：

obj.unstack()

obj.unstack().stack
 
()

所以帶層級索引的Series可看作是普通的DataFrame：

obj.loc['a',2]

-0.9042816958522675

obj.loc['b':'c',:]

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

同樣地，帶層級索引資料的行列標籤也可以有名字(不過視覺化的時候容易看混淆)：

frame.index.names=['key1','key2']        #行索引命名
frame.columns.names=['state','color']        #列索引名字
frame

frame.loc['a','Ohio']

多級索引下的資料查詢方式存疑

索引的重排與排序

對比連結

frame.swaplevel(0,1,axis=0)        #交換行標籤的級別

frame.swaplevel(0,1,axis=1)        #交換列標籤的級別
 

frame.sort_index(axis=0,level=1)        #對第2級的行標籤排序

frame.sort_index(axis=1,level=0)        #對第1級的列標籤排序

層級統計資訊

frame.sum(axis=0,level=1)        #以二級標籤進行列求和

frame.sum(axis=1,level=0)        #以一級標籤進行行求和

資料轉索引

set_index()方法可以將DataFrame中已有的列資料轉換成行索引：

frame=pd.DataFrame({
    'a':np.arange(5),
    'b':np.random.randn(5),
    'c':['one','one','one','two','two'],
    'd':[0,1,2,0,1]
})
frame.set_index(['c','d'])        #將'c','d'列的資料轉換成行索引

reset_index()方法為逆操作：

frame.set_index(['c','d']).reset_index()

資料集的合併

以列值為參照的水平拼接

df1=pd.DataFrame({
    'key1':['b','c','a'],
    'data1':np.arange(3)
})
df2=pd.DataFrame({
    'key2':['a','d'],
    'data2':np.arange(2)
})

#在兩資料集中取'key'列的交集進行合併,共同的key值為'a','b'
pd.merge(df1,df2,left_on='key1',right_on='key2',how='inner')

#在兩資料集中取'key'列的並集進行合併,並集的key值為'a','b','c','d'
pd.merge(df1,df2,left_on='key1',right_on='key2',how='outer')

#以左邊資料集的'key1'值為參照進行合併
pd.merge(df1,df2,left_on='key1',right_on='key2',how='left')

#以右邊資料集的'key2'值為參照進行合併
pd.merge(df1,df2,left_on='key1',right_on='key2',how='right')

當兩資料集需要合併的參照列有同樣的列索引名稱時，可以進行更方便的合併：

df1=pd.DataFrame({
    'key':['b','c','a'],
    'data1':np.arange(3)
})
df2=pd.DataFrame({
    'key':['a','d'],
    'data2':np.arange(2)
})
pd.merge(df1,df2,on='key',how='inner')

注意以上兩資料集中的參照列’key’都只有一個值，df1只有一個’a’,’b’,’c’，df2也只有一個’a’,’d’，這種情況下的合併可以產生一一對映，如果兩資料集的參照列具有多個公共值，合併時的對映關係稍微複雜一點：

df1=pd.DataFrame({
    'key':['b','b','c','c'],
    'data1':np.arange(4)
})
df2=pd.DataFrame({
    'key':['a','a','b','b'],
    'data2':np.arange(4)
})

pd.merge(df1,df2,on='key',how='inner')

上述合併方法產生了4行資料，因為df1的’key’中有2個’b’，df2的’key’中也有2個’b’，且值均不相等，所以在合併時以全對映法則產生了4條資料。

當合並的參照列為多列時，直接傳遞一個列表即可：

df1=pd.DataFrame({
    'key1':['foo','foo','bar'],
    'key2':['one','two','three'],
    'data1':np.arange(3)
})
df2=pd.DataFrame({
    'key1':['foo','foo','bar','bar'],
    'key2':['one','one','one','two'],
    'data2':np.arange(4,8)
})

pd.merge(df1,df2,on=['key1','key2'],how='outer')

以行索引為參照的水平拼接

df1=pd.DataFrame(
    np.arange(6).reshape((3,2)),
    index=['a','c','e'],
    columns=['Missouri','Alabama']
)
df2=pd.DataFrame(
    np.arange(7,15).reshape((4,2)),
    index=['b','c','d','e'],
    columns=['Ohio','Nevada']
)

pd.merge(df1,df2,left_index=True,right_index=True,how='inner')

軸向拼接

matrix=np.arange(9).reshape((3,3))
np.concatenate([matrix,matrix],axis=0)        #豎直拼接

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

pd.concat([s1,s2,s3],axis=1,join='outer')        #水平拼接

在拼接的時候可以使用key引數生成層級索引：

df1=pd.DataFrame(
    np.arange(4).reshape((2,2)),
    index=['a','b'],
    columns=['one','two']
)
df2=pd.DataFrame(
    4+np.arange(4).reshape((2,2)),
    index=['a','c'],
    columns=['three','four']
)

pd.concat([df1,df2],axis=1,keys=['level_1','level_2'],join='outer')

資料重疊

當兩個資料集的部分割槽域有相同的行列索引時，可以用另一個數據集相應位置的資料來填補前一個數據集的缺失值：

df1=pd.DataFrame({
    'a':[1,None,5,None],
    'b':[None,2,None,6],
    'c':[2,4,6,8]
})
df2=pd.DataFrame({
    'a':[5,4,None,3,7],
    'b':[None,3,4,6,8]
})

df1.combine_first(df2)        #用df2來填充df1

旋轉與整形

(待補充)