从多索引熊猫数据框中选择索引和列的子集

Question

沿索引和列切片多索引熊猫数据框的一般方法是什么？

文档密集且完整，值得一读（https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html），并且在堆栈溢出上有很多答案，这些答案集中于“行”或“列”上，如何解决（而且答案很彻底， Select rows in pandas MultiIndex DataFrame）。但是，我想要一个更直接的答案，其中包含同时解决这两个问题的示例。

创建多索引数据框

cols_index = pd.MultiIndex.from_product([['a','b','c'],
    ['x','y','z']], names=['first','second'])
rows_index = pd.MultiIndex.from_product([['d','e','f'],
    ['u','v','w']], names=['third','fourth'])
df = pd.DataFrame(np.random.choice(10, (9,9)), index=rows_index, columns=cols_index)

df
Out[161]: 
first         a           b         
second        c     d     c     d   
third         e  f  e  f  e  f  e  f
fourth fifth                        
j      m      9  8  0  1  5  6  3  5
       n      1  2  3  3  5  5  4  2
       o      5  2  4  7  3  1  0  4
k      m      6  6  3  3  4  4  1  7
       n      0  6  0  9  2  3  7  5
       o      7  8  0  9  7  8  3  4
l      m      4  7  4  3  0  5  6  3
       n      0  4  3  9  9  5  8  4
       o      0  1  8  0  8  9  4  7

我想看看将索引和列中的各个级别进行切片的示例。

Answer 1

  

这是我的通用解决方案...

使用loc和索引切片器切片索引和列级别

idx = pd.IndexSlice

选择所有内容-请注意，“：”对应于索引和列中的级别数

df.loc [idx [：，：]，idx [：，:::]]

def check_if_close(a, b):
    if (abs(b-a) < 0.1):
        return True
    else:
        return False

print(check_if_close(9.1, 9.15)) #true
print(check_if_close(8.1, 9.15)) #false
print(check_if_close(7.06, 8.0)) #false
print(check_if_close(7.06, 7.1)) #true

选择特定的“单元格”

df.loc [idx ['j'，'m']，idx ['a'，'c'，'f']]

Out[251]: 
first         a           b         
second        c     d     c     d   
third         e  f  e  f  e  f  e  f
fourth fifth                        
j      m      2  9  4  5  6  7  7  5
       n      1  4  2  6  8  0  6  3
       o      2  4  0  2  1  9  9  4
k      m      6  5  0  0  9  3  4  0
       n      3  1  6  4  2  3  0  4
       o      0  7  1  6  9  7  5  7
l      m      2  8  0  8  5  1  8  3
       n      7  3  2  6  9  4  1  7
       o      6  4  7  9  1  3  3  3

从索引中选择一级，从列中选择一级

df.loc [idx [：，'m']，idx [：，'c'，：]]

Out[252]: 9

子集是列级别的唯一组合

df.loc [:, idx ['b'，'d'，'f']]

Out[253]: 
first         a     b   
second        c     c   
third         e  f  e  f
fourth fifth            
j      m      2  9  6  7
k      m      6  5  9  3
l      m      2  8  5  1

子集是索引级别的唯一组合

df.loc [idx ['k'，'o']，：]

Out[254]: 
fourth  fifth
j       m        5
        n        3
        o        4
k       m        0
        n        4
        o        7
l       m        3
        n        7
        o        3
Name: (b, d, f), dtype: int32