pandas层次化索引

Posted 2023-04-19

参考技术A 多层次索引Series的索引是MultiIndex结构

根据最外层索引取数时，可直接通过series[outer_index_m]完成

根据内层索引取数时，需要series[:, inner_index_m]完成

更内层索引，series[:, :, ..., inner_index_m]完成

sreies.unstack()可将双层索引的series转为dataframe，外层索引做行索引，内层索引做列索引

多层次索引的dataframe按最外层行/列索引取数时，返回的结果是一个新的dataframe，所以，可用dataframe的按行/列取数方法依次进行

可以直接指定索引的别名（这是轴的标签，并不是索引本身的名称）

也可以通过MlutiIndex对象复用

dataframe.stack()方法

            可将多层 列索引 的dataframe转成新的dataframe，将最内层 列 索引转为最内层 行 索引

            若是dataframe只有一层列索引，stack方法会返回一个多层行索引的series

dataframe.unstack()方法

            可将多层 行索引 的dataframe转成新的dataframe，将最内层 行 索引转为最 内 层列索引

            若是dataframe只有一层行索引，stack方法会返回一个多层行索引的series

stack方法与unstack方法一直调用都会将dataframe转为series，两种series的区别在于行索引的先后顺序

*注：stack/unstack方法可以将dataframe转为series，也可以将series转为dataframe

       在多层次索引pandas对象中，这两个方法可一直调用下去，实现索引重排

上面通过stack/unstack实现了索引重排，一直调用太麻烦，还可以通过swaplevel方法直接指定两个层次的索引对调其位置

Pandas基本功能之层次化索引及层次化汇总

层次化索引

层次化也就是在一个轴上拥有多个索引级别

Series的层次化索引

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

a  1    0.965999
   2   -0.271733
   3    0.133910
b  1   -0.806885
   2   -0.622905
   3   -0.355330
c  1   -0.659194
   2   -1.082872
d  2   -0.043984
   3   -1.125324
dtype: float64

# 选取数据子集
data[‘b‘]
1   -0.806885
2   -0.622905
3   -0.355330
dtype: float64

data[‘b‘:‘c‘] # 在pandas中顾头也顾尾

b  1   -0.806885
   2   -0.622905
   3   -0.355330
c  1   -0.659194
   2   -1.082872
dtype: float64

data.ix[[‘b‘,‘d‘]] # 按行索引名称选择
b  1   -0.806885
   2   -0.622905
   3   -0.355330
d  2   -0.043984
   3   -1.125324
dtype: float64

# 在内层中进行选取，选择所有的行索引中的2这一行
data[:,2]
a   -0.271733
b   -0.622905
c   -1.082872
d   -0.043984
dtype: float64

# 层次化索引在数据重塑和基于分组的操作中扮演着重要的角色
# 这个函数会把层次化索引转为DataFrame格式，最外层的行索引作为DataFrame的行索引，内层的索引作为列索引
data.unstack()

    1             2           3
a   0.965999    -0.271733   0.133910
b   -0.806885   -0.622905   -0.355330
c   -0.659194   -1.082872   NaN
d   NaN         -0.043984   -1.125324

# unstack()的逆运算，转回来
data.unstack().stack()

a  1    0.965999
   2   -0.271733
   3    0.133910
b  1   -0.806885
   2   -0.622905
   3   -0.355330
c  1   -0.659194
   2   -1.082872
d  2   -0.043984
   3   -1.125324
dtype: float64

DataFrame的层次化索引

frame = pd.DataFrame(np.arange(12).reshape(4,3),index=[[‘a‘,‘a‘,‘b‘,‘b‘],[1,2,1,2]],
            columns=[[‘ohio‘,‘ohio‘,‘color‘],[‘green‘,‘red‘,‘green‘]]
            )
frame

    ohio    color
   green    red green
a   1   0   1   2
    2   3   4   5
b   1   6   7   8
    2   9   10  11

# 给层级行索引加名字
frame.index.names = [‘key1‘,‘key2‘]
# 给层级列索引加名字
frame.columns.names = [‘state‘,‘color‘]
frame

   state    ohio    color
   color    green   red green
key1    key2            
a   1   0   1   2
    2   3   4   5
b   1   6   7   8
    2   9   10  11

frame[‘ohio‘]

   color    green   red
key1    key2        
a   1   0   1
    2   3   4
b   1   6   7
    2   9   10

重排分级顺序

frame

state   ohio    color
color   green   red green
key1    key2            
a   1   0   1   2
    2   3   4   5
b   1   6   7   8
    2   9   10  11

# 这里sortlevel()括号里的0指把key2和key1交换后按key2排序
frame.swaplevel(0,1).sortlevel(0)

    state   ohio    color
color   green   red green
key2    key1            
1   a   0   1   2
    b   6   7   8
2   a   3   4   5
    b   9   10  11


# 1指按key1排序
frame.swaplevel(0,1).sortlevel(1)

state   ohio    color
color   green   red green
key2    key1            
1   a   0   1   2
2   a   3   4   5
1   b   6   7   8
2   b   9   10  11

根据层次索引级别汇总统计

frame

state   ohio    color
color   green   red green
key1    key2            
a   1   0   1   2
    2   3   4   5
b   1   6   7   8
    2   9   10  11

# 以key2的1和1相加，2和2索引相加
frame.sum(level=‘key2‘)

state   ohio    color
color   green   red green
key2            
1   6   8   10
2   12  14  16

# 以行索引的green索引相加，red没有不做改变
frame.sum(level=‘color‘,axis=1)

color   green   red
key1    key2        
a   1   2   1
    2   8   4
b   1   14  7
    2   20  10

使用DataFrame的列

frame1 = 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]
                     })

frame1

   a    b   c   d
0   0   7   one 0
1   1   6   one 1
2   2   5   one 2
3   3   4   two 0
4   4   3   two 1
5   5   2   two 2
6   6   1   two 3

#把c/d设置为行索引，默认会删除这两列，如果不想删除，可以吧drop=False开启
frame1.set_index([‘c‘,‘d‘])

        a   b
c   d       
one 0   0   7
    1   1   6
    2   2   5
two 0   3   4
    1   4   3
    2   5   2
    3   6   1


# reset_index会把cd设置为列索引,了解就行
frame2.reset_index()

   index    a   b   c   d
0   0   0   7   one 0
1   1   1   6   one 1
2   2   2   5   one 2
3   3   3   4   two 0
4   4   4   3   two 1
5   5   5   2   two 2
6   6   6   1   two 3