Select 行在 pandas MultiIndex DataFrame

Question

选择/过滤索引为 MultiIndex的 dataframe 行的最常见 pandas 方法是什么？

• 基于单个值/标签的切片
• 基于来自一个或多个级别的多个标签进行切片
• 过滤 boolean 条件和表达式
• 什么情况下适用哪些方法

为简单起见的假设：

1. 输入 dataframe 没有重复的索引键
2. 下面输入dataframe只有两级。 （此处显示的大多数解决方案都概括为 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 at 0 u 1 v 2 w 3 bt 4 u 5 v 6 w 7 t 8 c u 9 v 10 dw 11 t 12 u 13 v 14 w 15

问题一：选择单品

我如何在“一级”中包含“a”的 select 行？

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

此外，我怎样才能在 output 中删除级别“一”？

     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：在一个级别中选择多个值

我怎样才能 select 行对应于级别“一”中的项目“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), ...]

我如何 select 对应于('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

问题六：任意切片

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

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

问题 7 将使用由数字级别组成的独特设置：

 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

---

注意：这篇文章不会go 通过如何创建 MultiIndexes，如何对它们执行赋值操作，或任何与性能相关的讨论（这些是另一个时间的单独主题）。

Answer 1

多索引/高级索引

笔记
这篇文章将按以下方式组织：

1. OP中提出的问题将一一解决
2. 对于每个问题，将演示一种或多种适用于解决该问题并获得预期结果的方法。

将包含注释（很像这个），供有兴趣了解附加功能、实现细节和其他与手头主题相关的信息的读者使用。 这些笔记是通过搜索文档和发现各种晦涩的功能以及我自己（公认的有限）经验编写的。

所有代码示例都在pandas v0.23.4, python3.7上创建和测试。 如果有什么不清楚，或事实上不正确，或者如果您没有找到适用于您的用例的解决方案，请随时提出编辑建议，在评论中要求澄清，或提出新问题，....如适用.

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

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

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

3. DataFrame.query - 动态指定切片和/或过滤操作（即，作为动态评估的表达式。比其他场景更适用于某些场景。另请参阅文档的这一部分以查询多索引。

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

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

---

问题 1

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

 col one two at 0 u 1 v 2 w 3

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

df.loc[['a']]

此时，如果你得到

TypeError: Expected tuple, got str

这意味着您使用的是旧版本的熊猫。 考虑升级！ 否则，使用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在结果中删除级别“1”（我们切片的级别）。

这里的另一个选择是使用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']

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

 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 ）。

笔记
您可能会注意到过滤后的 DataFrame 可能仍然具有所有级别，即使它们在打印 DataFrame 时没有显示。 例如，

 v = df.loc[['a']] print(v) col one two at 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'])

您可以使用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'])

---

问题 1b

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

 col one two at 0 bt 4 t 8 dt 12

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

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

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

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

这要干净得多。

笔记
为什么需要尾随切片:跨列？ 这是因为， loc可用于沿两个轴（ axis=0或axis=1 ）选择和切片。 如果没有明确说明要在哪个轴上进行切片，操作就会变得模棱两可。 请参阅有关切片的文档中的大红框。

如果您想消除任何歧义， loc接受axis参数：

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

如果没有axis参数（即，仅通过执行df.loc[pd.IndexSlice[:, 't']] ），则假定切片在列上，并且在这种情况下将引发KeyError 。

这在slicers 中有记录。 但是，出于本文的目的，我们将明确指定所有轴。

与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']

都是一样的效果。

---

问题2

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

 col one two bt 4 u 5 v 6 w 7 t 8 dw 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')

笔记
是的，默认解析器是'pandas' ，但重要的是要强调这种语法不是传统的 python。 Pandas 解析器生成的解析树与表达式略有不同。 这样做是为了让一些操作更直观地指定。 有关更多信息，请阅读我关于使用 pd.eval() 在 Pandas 中进行动态表达式评估的文章。

并且，使用get_level_values + Index.isin ：

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

---

问题 2b

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

 col one two at 0 w 3 bt 4 w 7 t 8 dw 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'])]

---

问题 3

如何从df检索横截面，即具有特定索引值的单行？ 具体来说，我如何检索('c', 'u')的横截面，由

 col one two cu 9

通过指定一组键来使用loc ：

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

或者，

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

笔记
此时，您可能会遇到如下所示的PerformanceWarning ：

 PerformanceWarning: indexing past lexsort depth may impact performance.

这只是意味着您的索引未排序。 pandas 依赖于被排序的索引（在这种情况下，按字典顺序排列，因为我们正在处理字符串值）以获得最佳搜索和检索。 一个快速的解决方法是使用DataFrame.sort_index提前对您的 DataFrame 进行排序。 如果您计划同时执行多个此类查询，那么从性能的角度来看，这是特别需要的：

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

您还可以使用MultiIndex.is_lexsorted()来检查索引是否已排序。 此函数相应地返回True或False 。 您可以调用此函数来确定是否需要额外的排序步骤。

使用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]

---

问题 4

如何选择对应于('c', 'u')和('a', 'w')的两行？

 col one two cu 9 aw 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测试成员资格，然后使用布尔索引对最终结果进行测试。

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

---

问题 5

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

 col one two at 0 u 1 v 2 w 3 bt 4 t 8 dt 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] 

---

问题 6

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

 col one two au 1 v 2 bu 5 v 6 dw 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'))因为被索引的相同子级别对于每个级别都是相同的。

---

问题 7

如何获取级别“二”中的值大于 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]

笔记
与此示例类似，我们可以使用这些构造基于任意条件进行过滤。 通常，记住loc和xs专门用于基于标签的索引很有用，而query和get_level_values有助于构建用于过滤的通用条件掩码。

---

奖金问题

如果我需要切片MultiIndex列怎么办？

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

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

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

1. 要使用loc切片，请使用

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

   或者，

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

2. 要适当地使用xs ，只需传递一个参数axis=1 。

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

    df.loc[:, {condition}]

   其中{condition}表示使用columns.get_level_values构建的一些条件。

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

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

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

Answer 2

最近我遇到了一个用例，其中我有一个 3+ 级多索引数据框，其中我无法使上述任何解决方案产生我正在寻找的结果。 很可能上述解决方案当然适用于我的用例，我尝试了几种，但是我无法在我可用的时间内让它们工作。

我远非专家，但我偶然发现了上述综合答案中未列出的解决方案。 我不保证这些解决方案在任何方面都是最佳的。

这是获得与上述问题 #6 略有不同的结果的不同方法。 （可能还有其他问题）

具体来说，我正在寻找：

1. 一种从索引的一个级别中选择两个+值和从索引的另一个级别中选择一个值的方法，以及
2. 一种在数据帧输出中保留上一操作的索引值的方法。

作为齿轮中的活动扳手（但完全可以修复）：

3. 索引未命名。

在下面的玩具数据框中：

    index = pd.MultiIndex.from_product([['a','b'],
                               ['stock1','stock2','stock3'],
                               ['price','volume','velocity']])

    df = pd.DataFrame([1,2,3,4,5,6,7,8,9,
                      10,11,12,13,14,15,16,17,18], 
                       index)

                        0
    a stock1 price      1
             volume     2
             velocity   3
      stock2 price      4
             volume     5
             velocity   6
      stock3 price      7
             volume     8
             velocity   9
    b stock1 price     10
             volume    11
             velocity  12
      stock2 price     13
             volume    14
             velocity  15
      stock3 price     16
             volume    17
             velocity  18

当然，使用以下作品：

    df.xs(('stock1', 'velocity'), level=(1,2))

        0
    a   3
    b  12

但我想要一个不同的结果，所以我得到这个结果的方法是：

   df.iloc[df.index.isin(['stock1'], level=1) & 
           df.index.isin(['velocity'], level=2)] 

                        0
    a stock1 velocity   3
    b stock1 velocity  12

如果我想要一个级别的两个+值和另一个级别的单个（或 2+）值：

    df.iloc[df.index.isin(['stock1','stock3'], level=1) & 
            df.index.isin(['velocity'], level=2)] 

                        0
    a stock1 velocity   3
      stock3 velocity   9
    b stock1 velocity  12
      stock3 velocity  18

上面的方法可能有点笨拙，但是我发现它满足了我的需求，而且对我来说更容易理解和阅读。

Answer 3

这看起来是dfsql 的一个很好的例子

df.sql(<SQL select statement>)

https://github.com/mindsdb/dfsql

关于它的完整文章在这里：

https://medium.com/riselab/why-every-data-scientist-using-pandas-needs-modin-bringing-sql-to-dataframes-3b216b29a7c0

Answer 4

我长期以来一直使用并欣赏这个问题，以及@cs95的回复，它非常彻底并且处理了所有实例。 与@ra的回答类似，我也想找到一种方法来处理包含多个级别的多个索引。

我终于找到了一种在给定级别或命名索引的情况下获得任意数量切片的方法，它能够处理上面提出的几个问题。 这里的主要改进是不必为多个索引或切片解析slice(None)或:与pd.IndexSlice 。

import pandas as pd

def slice_df_by(df_, slice_by=["Oman", "Nairobi",], slice_idx='country'):
    idxn = df_.index.names.index(slice_idx)
    return df_.loc[tuple([slice(None)]*idxn +[slice_by] ), :]

gender = tuple(["male", "female"]*6)
thrown = tuple(["rock", "scissors", "paper"]*4) 
country = tuple(["Nairobi", "Oman", "Djibouti", "Belize"]*3) 
names = tuple(["Chris", "Pat", "Michele", "Thomy", "Musa", "Casey"]*2)

tuples = list(zip(gender, thrown, country, names))

idx = pd.MultiIndex.from_tuples(tuples, 
                                names=["gender", "thrown", "country", "name"])

df = pd.DataFrame({'Count A': [12., 70., 30., 20.]*3, 
                   'Count B': [12., 70., 30., 20.]*3}, index=idx)

这样做的好处是您可以将这些调用的任意组合添加到 function slice_df_by以获得更复杂的切片，同时仅使用索引名称和值列表。

print(slice_df_by(df))

                                 Count A  Count B
gender thrown   country name                     
female scissors Oman    Pat         70.0     70.0
       paper    Oman    Casey       70.0     70.0
       rock     Oman    Thomy       70.0     70.0
male   rock     Nairobi Chris       12.0     12.0
       scissors Nairobi Musa        12.0     12.0
       paper    Nairobi Michele     12.0     12.0

正如@ra指出的那样，问题在于没有命名索引。 使用这里的方法有很多方法可以满足这一点，例如df.index.names = ["names", "for", "the", "indices"]或一些这样的方法：

idxz = lambda ixln=4: [chr(i) for i in np.arange(ixln)+65]
df.index.names = idxz(len(df.index.names))
print(idxz())
Out[132]: ['A', 'B', 'C', 'D']

Answer 5

一种选择是使用来自pyjanitor的select_rows ：

# pip install pyjanitor
import pandas as pd
import janitor

问题一

我如何在“一级”中包含“a”的 select 行？

df.select_rows('a') 
         col
one two     
a   t      0
    u      1
    v      2
    w      3

此外，我怎样才能在 output 中删除级别“一”？

df.select_rows('a').droplevel('one') 
     col
two     
t      0
u      1
v      2
w      3

问题 1b

如何在级别“二”上对所有值为“t”的行进行切片？

 col one two at 0 bt 4 t 8 dt 12

这里使用字典，指定级别为键，并将标签传递给 select：

df.select_rows({'two':'t'})
         col
one two     
a   t      0
b   t      4
    t      8
d   t     12

问题2

我怎样才能 select 行对应于级别“一”中的项目“b”和“d”？

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

由于选择是在单个级别上进行的，因此传递标签列表：

df.select_rows(['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 at 0 w 3 bt 4 w 7 t 8 dw 11 t 12 w 15

使用字典：

df.select_rows({'two':['t','w']})
         col
one two     
a   t      0
b   t      4
    t      8
d   t     12
a   w      3
b   w      7
d   w     11
    w     15

问题三

如何从df检索横截面，即具有特定索引值的单行？ 具体来说，我如何检索('c', 'u')的横截面，由

 col one two c u 9

我们要跨层（水平，而不是垂直），需要一个元组：

# sort required to avoid lexsort performance warning
df.sort_index().select_rows(('c','u'))
         col
one two     
c   u      9

问题四

我如何 select 对应于('c', 'u')和('a', 'w')的两行？

 col one two c u 9 aw 3

select_rows接受多个变量 arguments：

df.sort_index().select_rows(('c','u'), ('a','w'))
         col
one two     
c   u      9
a   w      3

问题 5

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

 col one two at 0 u 1 v 2 w 3 bt 4 t 8 dt 12

df.select_rows('a', {'two':'t'})
         col
one two     
a   t      0
    u      1
    v      2
    w      3
    t      0
b   t      4
    t      8
d   t     12

问题 6

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

 col one two au 1 v 2 bu 5 v 6 dw 11 w 15

df.sort_index().select_rows({'one':['a','b'], 'two':['u','v']}, ('d','w'))
         col
one two     
a   u      1
    v      2
b   u      5
    v      6
d   w     11
    w     15

问题 7

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

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

使用字典，可以传递一个 function，只要它可以在一个索引 object 上进行评估：

df2.select_rows({'two': lambda df: df > 5})
         col
one two     
b   7      4
    9      5
c   7     10
d   6     11
    8     12
    8     13
    6     15

您可以使用 select_columns function 在列上使用select。还有一个通用的select function 用于在行和列上进行选择。

这些功能是可扩展的：让我们看看它是如何与@double0darbo 一起工作的答案：

df.select_rows({'country':['Oman', 'Nairobi']})
                                 Count A  Count B
gender thrown   country name                     
female scissors Oman    Pat         70.0     70.0
       paper    Oman    Casey       70.0     70.0
       rock     Oman    Thomy       70.0     70.0
male   rock     Nairobi Chris       12.0     12.0
       scissors Nairobi Musa        12.0     12.0
       paper    Nairobi Michele     12.0     12.0

也尝试@ra回答：

df.select_rows({1:'stock1', 2:'velocity'})
                    0
a stock1 velocity   3
b stock1 velocity  12

df.select_rows({1:['stock1','stock3'], 2:'velocity'})
                    0
a stock1 velocity   3
b stock1 velocity  12
a stock3 velocity   9
b stock3 velocity  18

df.select_rows({0:slice('a',None), 1:['stock1','stock3'], 2:'velocity'})
                    0
a stock1 velocity   3
  stock3 velocity   9
b stock1 velocity  12
  stock3 velocity  18