Pandas布尔索引的逻辑运算符

Question

我在熊猫中使用布尔索引。 问题是为什么声明：

a[(a['some_column']==some_number) & (a['some_other_column']==some_other_number)]

很好，但是

a[(a['some_column']==some_number) and (a['some_other_column']==some_other_number)]

错误退出？

示例：

a=pd.DataFrame({'x':[1,1],'y':[10,20]})

In: a[(a['x']==1)&(a['y']==10)]
Out:    x   y
     0  1  10

In: a[(a['x']==1) and (a['y']==10)]
Out: ValueError: The truth value of an array with more than one element is ambiguous.     Use a.any() or a.all()

Answer 1

熊猫的TLDR；_{逻辑运算符是&、|和~，括号(...)很重要！}

Python的and、or和not逻辑运算符被设计为与标量一起工作。因此，Pandas必须做得更好，并重写按位运算符，以实现此功能的矢量化版本。

因此，python中的以下表达式（exp1和exp2是求值为布尔结果的表达式）。。。

exp1 and exp2              # Logical AND
exp1 or exp2               # Logical OR
not exp1                   # Logical NOT

…将转换为。。。

exp1 & exp2                # Element-wise logical AND
exp1 | exp2                # Element-wise logical OR
~exp1                      # Element-wise logical NOT

为了熊猫。

如果在执行逻辑操作的过程中得到ValueError，则需要使用括号进行分组：

(exp1) op (exp2)

例如

(df['col1'] == x) & (df['col2'] == y) 

等等。

---

Boolean Indexing：一个常见的操作是通过逻辑条件计算布尔掩码来过滤数据。Pandas提供三个运算符：逻辑与的&，逻辑或的|，逻辑非的~。

考虑以下设置：

np.random.seed(0)
df = pd.DataFrame(np.random.choice(10, (5, 3)), columns=list('ABC'))
df

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

逻辑和

对于上面的df，假设您希望返回A<；5和B>；5所在的所有行。这是通过分别计算每个条件的掩码，并对它们进行运算来实现的。

按位重载&运算符
在继续之前，请注意文档的这一特定摘录，其中说明

Another common operation is the use of boolean vectors to filter the data. The operators are: | for or, & for and, and ~ for not. These must be grouped by using parentheses, since by default Python will evaluate an expression such as df.A > 2 & df.B < 3 as df.A > (2 & df.B) < 3, while the desired evaluation order is (df.A > 2) & (df.B < 3).

因此，考虑到这一点，可以使用按位运算符&实现元素逻辑和：

df['A'] < 5

0    False
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df['B'] > 5

0    False
1     True
2    False
3     True
4     True
Name: B, dtype: bool

(df['A'] < 5) & (df['B'] > 5)

0    False
1     True
2    False
3     True
4    False
dtype: bool

接下来的过滤步骤很简单

df[(df['A'] < 5) & (df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6

括号用于重写按位运算符的默认优先级顺序，这些运算符的优先级高于条件运算符<和>。请参见python文档中的Operator Precedence部分。

如果不使用括号，则表达式的计算结果不正确。例如，如果您不小心尝试了

df['A'] < 5 & df['B'] > 5

它被解析为

df['A'] < (5 & df['B']) > 5

变成了

df['A'] < something_you_dont_want > 5

它变成（参见chained operator comparison上的python文档）

(df['A'] < something_you_dont_want) and (something_you_dont_want > 5)

变成了

# Both operands are Series...
something_else_you_dont_want1 and something_else_you_dont_want2

它抛出

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

所以，不要犯那个错误！¹

避免括号分组
解决方法其实很简单。大多数运算符对数据帧都有相应的绑定方法。如果单个掩码是使用函数而不是条件运算符构建的，则不再需要按parens分组来指定求值顺序：

df['A'].lt(5)

0     True
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df['B'].gt(5)

0    False
1     True
2    False
3     True
4     True
Name: B, dtype: bool

df['A'].lt(5) & df['B'].gt(5)

0    False
1     True
2    False
3     True
4    False
dtype: bool

请参阅Flexible Comparisons.部分。总而言之，我们有

╒════╤════════════╤════════════╕
│    │ Operator   │ Function   │
╞════╪════════════╪════════════╡
│  0 │ >          │ gt         │
├────┼────────────┼────────────┤
│  1 │ >=         │ ge         │
├────┼────────────┼────────────┤
│  2 │ <          │ lt         │
├────┼────────────┼────────────┤
│  3 │ <=         │ le         │
├────┼────────────┼────────────┤
│  4 │ ==         │ eq         │
├────┼────────────┼────────────┤
│  5 │ !=         │ ne         │
╘════╧════════════╧════════════╛

避免括号的另一个选项是使用^{}（或eval）：

df.query('A < 5 and B > 5')

   A  B  C
1  3  7  9
3  4  7  6

我在Dynamic Expression Evaluation in pandas using pd.eval()中广泛地记录了query和eval。

^{}
允许您以功能方式执行此操作。内部调用对应于按位运算符的Series.__and__。

import operator 

operator.and_(df['A'] < 5, df['B'] > 5)
# Same as,
# (df['A'] < 5).__and__(df['B'] > 5) 

0    False
1     True
2    False
3     True
4    False
dtype: bool

df[operator.and_(df['A'] < 5, df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6

你通常不需要这个，但知道它是有用的。

泛化：^{}（和logical_and.reduce）
另一种方法是使用np.logical_and，它也不需要括号分组：

np.logical_and(df['A'] < 5, df['B'] > 5)

0    False
1     True
2    False
3     True
4    False
Name: A, dtype: bool

df[np.logical_and(df['A'] < 5, df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6

np.logical_and是一个ufunc (Universal Functions)，大多数ufunc都有一个^{}方法。这意味着，如果有多个到和的掩码，则更容易使用logical_and进行泛化。例如，使用&来屏蔽m1、m2和m3，则必须执行以下操作

m1 & m2 & m3

不过，更简单的选择是

np.logical_and.reduce([m1, m2, m3])

这很强大，因为它可以让您在这个基础上构建更复杂的逻辑（例如，在列表理解中动态生成掩码并添加所有掩码）：

import operator

cols = ['A', 'B']
ops = [np.less, np.greater]
values = [5, 5]

m = np.logical_and.reduce([op(df[c], v) for op, c, v in zip(ops, cols, values)])
m 
# array([False,  True, False,  True, False])

df[m]
   A  B  C
1  3  7  9
3  4  7  6

我知道我在唠叨这一点，但请容忍我。这是一个很常见的初学者错误，必须解释得非常透彻。

---

逻辑或

对于上面的df，假设您希望返回A==3或B==7的所有行。

按位重载|

df['A'] == 3

0    False
1     True
2     True
3    False
4    False
Name: A, dtype: bool

df['B'] == 7

0    False
1     True
2    False
3     True
4    False
Name: B, dtype: bool

(df['A'] == 3) | (df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
dtype: bool

df[(df['A'] == 3) | (df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6

如果您还没有，请阅读上面关于逻辑和的部分，此处适用所有警告。

或者，此操作可以指定为

df[df['A'].eq(3) | df['B'].eq(7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6

^{}
在引擎盖下调用Series.__or__。

operator.or_(df['A'] == 3, df['B'] == 7)
# Same as,
# (df['A'] == 3).__or__(df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
dtype: bool

df[operator.or_(df['A'] == 3, df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6

^{}
对于两种情况，使用logical_or：

np.logical_or(df['A'] == 3, df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df[np.logical_or(df['A'] == 3, df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6

对于多个遮罩，使用logical_or.reduce：

np.logical_or.reduce([df['A'] == 3, df['B'] == 7])
# array([False,  True,  True,  True, False])

df[np.logical_or.reduce([df['A'] == 3, df['B'] == 7])]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6

---

逻辑不

给一个面具，比如

mask = pd.Series([True, True, False])

如果需要反转每个布尔值（以便最终结果为[False, False, True]），则可以使用下面的任何方法。

按位~

~mask

0    False
1    False
2     True
dtype: bool

同样，表达式需要用括号括起来。

~(df['A'] == 3)

0     True
1    False
2    False
3     True
4     True
Name: A, dtype: bool

这在内部调用

mask.__invert__()

0    False
1    False
2     True
dtype: bool

但不要直接使用。

operator.inv
内部调用序列上的__invert__。

operator.inv(mask)

0    False
1    False
2     True
dtype: bool

^{}
这是核弹变种。

np.logical_not(mask)

0    False
1    False
2     True
dtype: bool

---

注，np.logical_and可以用bitwise_or代替np.bitwise_and，logical_or，用invert代替logical_not。