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)
等等。
布尔索引：常见的操作是通过逻辑条件来计算布尔掩码，以过滤数据。熊猫提供了三种运算符：&用于逻辑与，|逻辑或，以及~逻辑非。
请考虑以下设置：
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的所有行。这是通过分别计算每个条件的掩码并将它们与与完成的。
重载的按位&运算符
在继续之前，请注意文档的此特定摘录，其中指出
另一个常见的操作是使用布尔向量来过滤数据。运算符是：|for or，&for and和~for not。这些必须通过使用括号来分组，由于由默认的Python将评估的表达式如df.A > 2 & df.B < 3如df.A > (2 &
df.B) < 3，而所期望的评价顺序是(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文档中的“ 运算符优先级 ”部分。
如果不使用括号，则表达式的计算不正确。例如，如果您不小心尝试了诸如
df['A'] < 5 & df['B'] > 5
它被解析为
df['A'] < (5 & df['B']) > 5
变成
df['A'] < something_you_dont_want > 5
变成了（请参阅有关链接运算符比较的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().
所以，不要犯那个错误！1个
避免括号分组
该修补程序实际上非常简单。大多数运算符都有对应的DataFrame绑定方法。如果使用函数而不是条件运算符来构建单个掩码，则不再需要按括号分组以指定评估顺序：
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
请参阅“ 灵活比较 ”部分。。总而言之，我们有
╒════╤════════════╤════════════╕
│ │ Operator │ Function │
╞════╪════════════╪════════════╡
│ 0 │ > │ gt │
├────┼────────────┼────────────┤
│ 1 │ >= │ ge │
├────┼────────────┼────────────┤
│ 2 │ < │ lt │
├────┼────────────┼────────────┤
│ 3 │ <= │ le │
├────┼────────────┼────────────┤
│ 4 │ == │ eq │
├────┼────────────┼────────────┤
│ 5 │ != │ ne │
╘════╧════════════╧════════════╛
避免括号的另一种方法是使用DataFrame.query（或eval）：
df.query('A < 5 and B > 5')
A B C
1 3 7 9
3 4 7 6
我已经广泛地记录query和eval在使用pd.eval动态表达评价大熊猫（） 。
operator.and_
允许您以功能方式执行此操作。内部调用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
您通常不需要此功能，但了解它很有用。
概括：（np.logical_and和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 （通用函数），大多数ufunc都有一个reduce方法。这意味着logical_and如果对AND有多个掩码，则更容易一概而论。例如，对于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
1-我知道我在这一点上很困难，但是请耐心等待。这是一个非常，非常常见的初学者的错误，必须非常有详尽的解释。
逻辑或
对于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
operator.or_
在后台调用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
np.logical_or
对于两个条件，请使用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
这是numpy的变体。
np.logical_not(mask)
0 False
1 False
2 True
dtype: bool
注意，np.logical_and可以代替np.bitwise_and，logical_or同bitwise_or，并logical_not用invert。