Question

pandas中的大多数操作都可以通过操作员链接（groupby，aggregate，apply等来完成，但这是我发现过滤行的唯一方法是通过正常的括号索引

df_filtered = df[df['column'] == value]

这没有吸引力，因为它需要我先将df分配给变量，然后才能过滤其值。是否有更像以下内容？

df_filtered = df.mask(lambda x: x['column'] == value)

Answer 1

我不完全确定你想要什么，你的最后一行代码也无济于事，但无论如何：

“链式”过滤是通过“链接”布尔索引中的条件来完成的。

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [99]: df[(df.A == 1) & (df.D == 6)]
Out[99]:
   A  B  C  D
d  1  3  9  6

如果要链接方法，可以添加自己的掩码方法并使用该方法。

In [90]: def mask(df, key, value):
   ....:     return df[df[key] == value]
   ....:

In [92]: pandas.DataFrame.mask = mask

In [93]: df = pandas.DataFrame(np.random.randint(0, 10, (4,4)), index=list('abcd'), columns=list('ABCD'))

In [95]: df.ix['d','A'] = df.ix['a', 'A']

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [97]: df.mask('A', 1)
Out[97]:
   A  B  C  D
a  1  4  9  1
d  1  3  9  6

In [98]: df.mask('A', 1).mask('D', 6)
Out[98]:
   A  B  C  D
d  1  3  9  6

Answer 2

可以使用Pandas query链接过滤器：

df = pd.DataFrame( np.random.randn(30,3), columns = ['a','b','c'])
df_filtered = df.query('a>0').query('0<b<2')

过滤器也可以组合在一个查询中：

df_filtered = df.query('a>0 and 0<b<2')

Answer 3

@lodagro的答案很棒。我会通过将掩码函数概括为：

来扩展它

def mask(df, f):
  return df[f(df)]

然后你可以做类似的事情：

df.mask(lambda x: x[0] < 0).mask(lambda x: x[1] > 0)

Answer 4

由于version 0.18.1 scanf()方法接受可调用的选择。与lambda函数一起，您可以创建非常灵活的可链接过滤器：

.loc

如果你所做的只是过滤，你也可以省略import numpy as np import pandas as pd df = pd.DataFrame(np.random.randint(0,100,size=(100, 4)), columns=list('ABCD')) df.loc[lambda df: df.A == 80] # equivalent to df[df.A == 80] but chainable df.sort_values('A').loc[lambda df: df.A > 80].loc[lambda df: df.B > df.A]。

Answer 5

我提供此附加示例。这与https://stackoverflow.com/a/28159296/

的答案相同

我会添加其他修改以使这篇文章更有用。

pandas.DataFrame.query
query就是出于这个目的。考虑数据框df

import pandas as pd
import numpy as np

np.random.seed([3,1415])
df = pd.DataFrame(
    np.random.randint(10, size=(10, 5)),
    columns=list('ABCDE')
)

df

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
6  8  7  6  4  7
7  6  2  6  6  5
8  2  8  7  5  8
9  4  7  6  1  5

让我们使用query过滤D > B

所有的行

df.query('D > B')

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
7  6  2  6  6  5

我们链接

df.query('D > B').query('C > B')
# equivalent to
# df.query('D > B and C > B')
# but defeats the purpose of demonstrating chaining

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
4  3  6  7  7  4
5  5  3  7  5  9
7  6  2  6  6  5

Answer 6

我有同样的问题，除了我想将标准组合成OR条件。 Wouter Overmeire给出的格式将标准组合成AND条件，使得两者都必须满足：

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [99]: df[(df.A == 1) & (df.D == 6)]
Out[99]:
   A  B  C  D
d  1  3  9  6

但是我发现，如果你在(... == True)中包装每个条件并用管道连接标准，则条件在OR条件下组合，只要其中任何一个为真，就满足：

df[((df.A==1) == True) | ((df.D==6) == True)]

Answer 7

我的回答与其他人类似。如果您不想创建新功能，您可以使用熊猫为您定义的内容。使用管道方法。

df.pipe(lambda d: d[d['column'] == value])

Answer 8

如果您想应用所有常见的布尔掩码以及通用掩码，您可以将以下内容放入文件中，然后只需将它们全部分配如下：

pd.DataFrame = apply_masks()

用法：

A = pd.DataFrame(np.random.randn(4, 4), columns=["A", "B", "C", "D"])
A.le_mask("A", 0.7).ge_mask("B", 0.2)... (May be repeated as necessary

它有点像hacky但是如果你根据过滤器不断切割和更改数据集，它可以使事情变得更清洁。在gen_mask函数中还有一个改编自Daniel Velkov的通用过滤器，您可以将其与lambda函数一起使用，或者在需要时使用。

要保存的文件（我使用masks.py）：

import pandas as pd

def eq_mask(df, key, value):
    return df[df[key] == value]

def ge_mask(df, key, value):
    return df[df[key] >= value]

def gt_mask(df, key, value):
    return df[df[key] > value]

def le_mask(df, key, value):
    return df[df[key] <= value]

def lt_mask(df, key, value):
    return df[df[key] < value]

def ne_mask(df, key, value):
    return df[df[key] != value]

def gen_mask(df, f):
    return df[f(df)]

def apply_masks():

    pd.DataFrame.eq_mask = eq_mask
    pd.DataFrame.ge_mask = ge_mask
    pd.DataFrame.gt_mask = gt_mask
    pd.DataFrame.le_mask = le_mask
    pd.DataFrame.lt_mask = lt_mask
    pd.DataFrame.ne_mask = ne_mask
    pd.DataFrame.gen_mask = gen_mask

    return pd.DataFrame

if __name__ == '__main__':
    pass

Answer 9

pandas为Wouter Overmeire的答案提供了两种选择，不需要任何覆盖。一个是.loc[.]，可调用，如

df_filtered = df.loc[lambda x: x['column'] == value]

另一个是.pipe()，如

df_filtered = df.pipe(lambda x: x['column'] == value)

Answer 10

只想使用loc添加演示，不仅可以按行进行过滤，还可以按列进行过滤，并对链接操作进行一些优点。

下面的代码可以按值过滤行。

df_filtered = df.loc[df['column'] == value]

通过稍微修改它，您也可以过滤列。

df_filtered = df.loc[df['column'] == value, ['year', 'column']]

那么为什么我们想要一个链式方法呢？答案是，如果你有很多操作，它很容易阅读。例如，

res =  df\
    .loc[df['station']=='USA', ['TEMP', 'RF']]\
    .groupby('year')\
    .agg(np.nanmean)

Answer 11

这没有吸引力，因为它需要我先将df分配给变量，然后才能过滤其值。

df[df["column_name"] != 5].groupby("other_column_name")

似乎有效：您也可以链接[]运算符。也许他们在你问这个问题之后加了它。

Answer 12

如果您将列设置为搜索索引，则可以使用DataFrame.xs()来截取横截面。这不像query答案那样通用，但在某些情况下它可能很有用。

import pandas as pd
import numpy as np

np.random.seed([3,1415])
df = pd.DataFrame(
    np.random.randint(3, size=(10, 5)),
    columns=list('ABCDE')
)

df
# Out[55]: 
#    A  B  C  D  E
# 0  0  2  2  2  2
# 1  1  1  2  0  2
# 2  0  2  0  0  2
# 3  0  2  2  0  1
# 4  0  1  1  2  0
# 5  0  0  0  1  2
# 6  1  0  1  1  1
# 7  0  0  2  0  2
# 8  2  2  2  2  2
# 9  1  2  0  2  1

df.set_index(['A', 'D']).xs([0, 2]).reset_index()
# Out[57]: 
#    A  D  B  C  E
# 0  0  2  2  2  2
# 1  0  2  1  1  0

Answer 13

您还可以利用 numpy 库进行逻辑操作。它非常快。

df[np.logical_and(df['A'] == 1 ,df['B'] == 6)]

Answer 14

现在熊猫也有一个 filter method。您可以自然地将其用于运算符链接。

<块引用>

根据指定的索引对数据框的行或列进行子集标签。

df = pd.DataFrame(np.array(([1, 2, 3], [4, 5, 6])),
                  index=['mouse', 'rabbit'],
                  columns=['one', 'two', 'three'])

>>>
        one  two  three
mouse     1    2      3
rabbit    4    5      6


# select columns by name
df.filter(items=['one', 'three'])
>>>
         one  three
mouse     1      3
rabbit    4      6

它还具有使用 in 和正则表达式的参数。

pandas：使用运算符链接过滤DataFrame行

14 个答案: