python - 在 Pandas MultiIndex DataFrame 中选择行

Question

选择/过滤 dataframe whose index is a MultiIndex 的行的最常见的 Pandas 方法是什么？ ?

基于单个值/标签的切片

基于来自一个或多个级别的多个标签进行切片

过滤 bool 条件和表达式

哪些方法适用于哪些情况

为简单起见的假设:

输入数据框没有重复的索引键

下面的输入数据框只有两个级别。 (此处显示的大多数解决方案都适用于 N 级)

示例输入:

mux = pd.MultiIndex.from_arrays([
    list('aaaabbbbbccddddd'),
    list('tuvwtuvwtuvwtuvw')
], names=['one', 'two'])

df = pd.DataFrame({'col': np.arange(len(mux))}, mux)

         col
one two     
a   t      0
    u      1
    v      2
    w      3
b   t      4
    u      5
    v      6
    w      7
    t      8
c   u      9
    v     10
d   w     11
    t     12
    u     13
    v     14
    w     15

问题 1:选择单个项目

如何选择级别“一”中具有“a”的行？

         col
one two     
a   t      0
    u      1
    v      2
    w      3

此外，我如何才能在输出中降低“一”级？

     col
two     
t      0
u      1
v      2
w      3

问题 1b
如何在级别“二”上切片所有值为“t”的行？

         col
one two     
a   t      0
b   t      4
    t      8
d   t     12

问题 2:在一个级别中选择多个值

如何在级别“一”中选择与项目“b”和“d”相对应的行？

         col
one two     
b   t      4
    u      5
    v      6
    w      7
    t      8
d   w     11
    t     12
    u     13
    v     14
    w     15

问题 2b
我如何获得“二”级中“t”和“w”对应的所有值？

         col
one two     
a   t      0
    w      3
b   t      4
    w      7
    t      8
d   w     11
    t     12
    w     15

问题 3:切片单个横截面 (x, y)
如何从 df 检索横截面，即具有特定索引值的单行?具体来说，我如何检索 ('c', 'u') 的横截面，由

         col
one two     
c   u      9

问题 4:切片多个横截面 [(a, b), (c, d), ...]
如何选择 ('c', 'u') 对应的两行, 和 ('a', 'w') ?

         col
one two     
c   u      9
a   w      3

问题 5:每层切片一件物品

如何检索与级别“一”中的“a”或级别“二”中的“t”对应的所有行？

         col
one two     
a   t      0
    u      1
    v      2
    w      3
b   t      4
    t      8
d   t     12

问题 6:任意切片

如何切片特定的横截面？对于“a”和“b”，我想选择子级别为“u”和“v”的所有行，对于“d”，我想选择子级别为“w”的行。

         col
one two     
a   u      1
    v      2
b   u      5
    v      6
d   w     11
    w     15

Question 7 will use a unique setup consisting of a numeric level:

np.random.seed(0)
mux2 = pd.MultiIndex.from_arrays([
    list('aaaabbbbbccddddd'),
    np.random.choice(10, size=16)
], names=['one', 'two'])

df2 = pd.DataFrame({'col': np.arange(len(mux2))}, mux2)

         col
one two     
a   5      0
    0      1
    3      2
    3      3
b   7      4
    9      5
    3      6
    5      7
    2      8
c   4      9
    7     10
d   6     11
    8     12
    8     13
    1     14
    6     15

问题 7:按多重指数的各个级别上的数字不等式进行过滤

如何获取级别“二”中的值大于 5 的所有行？

         col
one two     
b   7      4
    9      5
c   7     10
d   6     11
    8     12
    8     13
    6     15

注意:这篇文章不会介绍如何创建多索引、如何对它们执行赋值操作，或任何与性能相关的讨论(这些是另一次单独的主题)。

Answer 1

MultiIndex / Advanced Indexing

Note
This post will be structured in the following manner:

1. The questions put forth in the OP will be addressed, one by one
2. For each question, one or more methods applicable to solving this problem and getting the expected result will be demonstrated.

Notes (much like this one) will be included for readers interested in learning about additional functionality, implementation details,and other info cursory to the topic at hand. These notes have beencompiled through scouring the docs and uncovering various obscurefeatures, and from my own (admittedly limited) experience.

All code samples have created and tested on pandas v0.23.4, python3.7. If something is not clear, or factually incorrect, or if you did notfind a solution applicable to your use case, please feel free tosuggest an edit, request clarification in the comments, or open a newquestion, ....as applicable.

这里介绍一些我们会经常重温的常见习语(以下简称“四大习语”)

DataFrame.loc - 通过标签选择的通用解决方案(+ pd.IndexSlice 用于涉及切片的更复杂的应用程序)

DataFrame.xs - 从系列/数据帧中提取特定横截面。

DataFrame.query - 动态指定切片和/或过滤操作(即作为动态评估的表达式。比其他场景更适用于某些场景。另请参阅 this section of the docs 以查询多索引。

使用 MultiIndex.get_level_values 生成掩码的 bool 索引(通常与 Index.isin 结合使用，尤其是在使用多个值进行过滤时)。这在某些情况下也非常有用。

根据四种习语来查看各种切片和过滤问题，以更好地了解可以应用于给定情况的内容，这将是有益的。了解并非所有习语在每种情况下都同样有效(如果有的话)，了解这一点非常重要。如果某个习语没有被列为以下问题的潜在解决方案，则意味着该习语不能有效地应用于该问题。

Question 1

How do I select rows having "a" in level "one"?

         col
one two     
a   t      0
    u      1
    v      2
    w      3

您可以使用 loc ，作为适用于大多数情况的通用解决方案:

df.loc[['a']]

此时，如果你得到

TypeError: Expected tuple, got str

这意味着您使用的是旧版本的 Pandas 。考虑升级!否则，使用 df.loc[('a', slice(None)), :] .
或者，您可以使用 xs在这里，因为我们正在提取单个横截面。请注意 levels和 axis参数(这里可以假设合理的默认值)。

df.xs('a', level=0, axis=0, drop_level=False)
# df.xs('a', drop_level=False)

在这里， drop_level=False需要参数来防止 xs从在结果中删除级别“一”(我们切片的级别)。
这里的另一个选择是使用 query :

df.query("one == 'a'")

如果索引没有名称，则需要将查询字符串更改为 "ilevel_0 == 'a'" .
最后，使用 get_level_values :

df[df.index.get_level_values('one') == 'a']
# If your levels are unnamed, or if you need to select by position (not label),
# df[df.index.get_level_values(0) == 'a']

Additionally, how would I be able to drop level "one" in the output?

     col
two     
t      0
u      1
v      2
w      3

这可以很容易地使用

df.loc['a'] # Notice the single string argument instead the list.

或者，

df.xs('a', level=0, axis=0, drop_level=True)
# df.xs('a')

请注意，我们可以省略 drop_level参数(默认情况下假定为 True)。

Note
You may notice that a filtered DataFrame may still have all the levels, even if they do not show when printing the DataFrame out. For example,

v = df.loc[['a']]
print(v)
         col
one two     
a   t      0
    u      1
    v      2
    w      3

print(v.index)
MultiIndex(levels=[['a', 'b', 'c', 'd'], ['t', 'u', 'v', 'w']],
           labels=[[0, 0, 0, 0], [0, 1, 2, 3]],
           names=['one', 'two'])

You can get rid of these levels using MultiIndex.remove_unused_levels:

v.index = v.index.remove_unused_levels()

print(v.index)
MultiIndex(levels=[['a'], ['t', 'u', 'v', 'w']],
           labels=[[0, 0, 0, 0], [0, 1, 2, 3]],
           names=['one', 'two'])

Question 1b

How do I slice all rows with value "t" on level "two"?

         col
one two     
a   t      0
b   t      4
    t      8
d   t     12

直觉上，你会想要一些涉及 slice() 的东西。 :

df.loc[(slice(None), 't'), :]

It Just Works!™ 但它很笨重。我们可以使用 pd.IndexSlice 促进更自然的切片语法。 API在这里。

idx = pd.IndexSlice
df.loc[idx[:, 't'], :]

这要干净得多。

Note
Why is the trailing slice : across the columns required? This is because, loc can be used to select and slice along both axes (axis=0 oraxis=1). Without explicitly making it clear which axis the slicingis to be done on, the operation becomes ambiguous. See the big red box in the documentation on slicing.

If you want to remove any shade of ambiguity, loc accepts an axisparameter:

df.loc(axis=0)[pd.IndexSlice[:, 't']]

Without the axis parameter (i.e., just by doing df.loc[pd.IndexSlice[:, 't']]), slicing is assumed to be on the columns,and a KeyError will be raised in this circumstance.

This is documented in slicers. For the purpose of this post, however, we will explicitly specify all axes.

与 xs ，它是

df.xs('t', axis=0, level=1, drop_level=False)

与 query ，它是

df.query("two == 't'")
# Or, if the first level has no name, 
# df.query("ilevel_1 == 't'") 

最后，与 get_level_values ，你可以

df[df.index.get_level_values('two') == 't']
# Or, to perform selection by position/integer,
# df[df.index.get_level_values(1) == 't']

都是一样的效果。

Question 2

How can I select rows corresponding to items "b" and "d" in level "one"?

         col
one two     
b   t      4
    u      5
    v      6
    w      7
    t      8
d   w     11
    t     12
    u     13
    v     14
    w     15

使用 loc，这是通过指定一个列表以类似的方式完成的。

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

要解决上面选择“b”和“d”的问题，还可以使用 query :

items = ['b', 'd']
df.query("one in @items")
# df.query("one == @items", parser='pandas')
# df.query("one in ['b', 'd']")
# df.query("one == ['b', 'd']", parser='pandas')

Note
Yes, the default parser is 'pandas', but it is important to highlight this syntax isn't conventionally python. ThePandas parser generates a slightly different parse tree from theexpression. This is done to make some operations more intuitive tospecify. For more information, please read my post onDynamic Expression Evaluation in pandas using pd.eval().

并且，与 get_level_values + Index.isin :

df[df.index.get_level_values("one").isin(['b', 'd'])]

Question 2b

How would I get all values corresponding to "t" and "w" in level "two"?

         col
one two     
a   t      0
    w      3
b   t      4
    w      7
    t      8
d   w     11
    t     12
    w     15

与 loc ，这只能与 pd.IndexSlice 结合使用.

df.loc[pd.IndexSlice[:, ['t', 'w']], :] 

第一个冒号 :在 pd.IndexSlice[:, ['t', 'w']]意味着切开第一层。随着被查询级别的深度增加，您将需要指定更多切片，每个切片一个切片。但是，除了被切片的级别之外，您不需要指定更多级别。
与 query ，这是

items = ['t', 'w']
df.query("two in @items")
# df.query("two == @items", parser='pandas') 
# df.query("two in ['t', 'w']")
# df.query("two == ['t', 'w']", parser='pandas')

与 get_level_values和 Index.isin (与上面类似):

df[df.index.get_level_values('two').isin(['t', 'w'])]

Question 3

How do I retrieve a cross section, i.e., a single row having a specific valuesfor the index from df? Specifically, how do I retrieve the crosssection of ('c', 'u'), given by

         col
one two     
c   u      9

使用 loc通过指定一个键元组:

df.loc[('c', 'u'), :]

或者，

df.loc[pd.IndexSlice[('c', 'u')]]

Note
At this point, you may run into a PerformanceWarning that looks like this:

PerformanceWarning: indexing past lexsort depth may impact performance.

This just means that your index is not sorted. pandas depends on the index being sorted (in this case, lexicographically, since we are dealing with string values) for optimal search and retrieval. A quick fix would be to sort yourDataFrame in advance using DataFrame.sort_index. This is especially desirable from a performance standpoint if you plan on doingmultiple such queries in tandem:

df_sort = df.sort_index()
df_sort.loc[('c', 'u')]

You can also use MultiIndex.is_lexsorted() to check whether the indexis sorted or not. This function returns True or False accordingly.You can call this function to determine whether an additional sortingstep is required or not.

与 xs ，这再次简单地传递一个元组作为第一个参数，所有其他参数设置为其适当的默认值:

df.xs(('c', 'u'))

与 query ，事情变得有点笨拙:

df.query("one == 'c' and two == 'u'")

现在您可以看到，这将相对难以概括。但是对于这个特定问题仍然可以。
访问跨越多个级别， get_level_values仍然可以使用，但不推荐:

m1 = (df.index.get_level_values('one') == 'c')
m2 = (df.index.get_level_values('two') == 'u')
df[m1 & m2]

Question 4

How do I select the two rows corresponding to ('c', 'u'), and ('a', 'w')?

         col
one two     
c   u      9
a   w      3

与 loc ，这仍然很简单:

df.loc[[('c', 'u'), ('a', 'w')]]
# df.loc[pd.IndexSlice[[('c', 'u'), ('a', 'w')]]]

与 query ，您将需要通过迭代您的横截面和级别来动态生成查询字符串:

cses = [('c', 'u'), ('a', 'w')]
levels = ['one', 'two']
# This is a useful check to make in advance.
assert all(len(levels) == len(cs) for cs in cses) 

query = '(' + ') or ('.join([
    ' and '.join([f"({l} == {repr(c)})" for l, c in zip(levels, cs)]) 
    for cs in cses
]) + ')'

print(query)
# ((one == 'c') and (two == 'u')) or ((one == 'a') and (two == 'w'))

df.query(query)

100% 不推荐!但这是可能的。
如果我有多个级别怎么办？
这种情况下的一种选择是使用 droplevel 删除您没有检查的级别，然后使用 isin 测试成员资格，然后对最终结果进行 bool 索引。

df[df.index.droplevel(unused_level).isin([('c', 'u'), ('a', 'w')])]

Question 5

How can I retrieve all rows corresponding to "a" in level "one" or"t" in level "two"?

         col
one two     
a   t      0
    u      1
    v      2
    w      3
b   t      4
    t      8
d   t     12

这实际上很难用 loc 做到。同时确保正确性并仍然保持代码清晰。 df.loc[pd.IndexSlice['a', 't']]不正确，解释为 df.loc[pd.IndexSlice[('a', 't')]] (即，选择横截面)。您可能会想到 pd.concat 的解决方案分别处理每个标签:

pd.concat([
    df.loc[['a'],:], df.loc[pd.IndexSlice[:, 't'],:]
])

         col
one two     
a   t      0
    u      1
    v      2
    w      3
    t      0   # Does this look right to you? No, it isn't!
b   t      4
    t      8
d   t     12

但是您会注意到其中一行是重复的。这是因为该行满足两个切片条件，因此出现了两次。你将需要做

v = pd.concat([
        df.loc[['a'],:], df.loc[pd.IndexSlice[:, 't'],:]
])
v[~v.index.duplicated()]

但是，如果您的 DataFrame 固有地包含重复的索引(您想要的)，那么这将不会保留它们。 谨慎使用 .
与 query ，这非常简单:

df.query("one == 'a' or two == 't'")

与 get_level_values ，这仍然很简单，但没有那么优雅:

m1 = (df.index.get_level_values('one') == 'a')
m2 = (df.index.get_level_values('two') == 't')
df[m1 | m2] 

Question 6

How can I slice specific cross sections? For "a" and "b", I would like to select all rows with sub-levels "u" and "v", andfor "d", I would like to select rows with sub-level "w".

         col
one two     
a   u      1
    v      2
b   u      5
    v      6
d   w     11
    w     15

这是我添加的一个特殊情况，以帮助理解四种习语的适用性——这是一种它们都不会有效工作的情况，因为切片非常具体，并且不遵循任何实际模式。
通常，像这样的切片问题需要明确地将键列表传递给 loc .这样做的一种方法是:

keys = [('a', 'u'), ('a', 'v'), ('b', 'u'), ('b', 'v'), ('d', 'w')]
df.loc[keys, :]

如果你想节省一些打字，你会发现有一个模式来切片“a”，“b”及其子级别，所以我们可以将切片任务分成两部分和 concat结果:

pd.concat([
     df.loc[(('a', 'b'), ('u', 'v')), :], 
     df.loc[('d', 'w'), :]
   ], axis=0)

“a”和“b”的切片规范稍微干净一点 (('a', 'b'), ('u', 'v'))因为被索引的相同子级别对于每个级别都是相同的。

Question 7

How do I get all rows where values in level "two" are greater than 5?

         col
one two     
b   7      4
    9      5
c   7     10
d   6     11
    8     12
    8     13
    6     15

这可以使用 query 来完成,

df2.query("two > 5")

和 get_level_values .

df2[df2.index.get_level_values('two') > 5]

Note
Similar to this example, we can filter based on any arbitrary condition using these constructs. In general, it is useful to remember that loc and xs are specifically for label-based indexing, while query andget_level_values are helpful for building general conditional masksfor filtering.

Bonus Question

What if I need to slice a MultiIndex column?

实际上，这里的大多数解决方案也适用于列，只需稍作改动。考虑:

np.random.seed(0)
mux3 = pd.MultiIndex.from_product([
        list('ABCD'), list('efgh')
], names=['one','two'])

df3 = pd.DataFrame(np.random.choice(10, (3, len(mux))), columns=mux3)
print(df3)

one  A           B           C           D         
two  e  f  g  h  e  f  g  h  e  f  g  h  e  f  g  h
0    5  0  3  3  7  9  3  5  2  4  7  6  8  8  1  6
1    7  7  8  1  5  9  8  9  4  3  0  3  5  0  2  3
2    8  1  3  3  3  7  0  1  9  9  0  4  7  3  2  7

这些是您需要对四个习语进行的以下更改，以使它们与列一起使用。

用 loc 切片，使用

 df3.loc[:, ....] # Notice how we slice across the index with `:`. 

或者，

 df3.loc[:, pd.IndexSlice[...]]

使用 xs如果合适，只需传递一个参数 axis=1 .

您可以使用 df.columns.get_level_values 直接访问列级值。 .然后你需要做类似的事情

 df.loc[:, {condition}] 

哪里{condition}表示使用 columns.get_level_values 构建的一些条件.

使用 query ，您唯一的选择是转置，查询索引，然后再次转置:

 df3.T.query(...).T

不推荐，使用其他 3 个选项之一。