如果我这样做:
>>> False in [False, True] True
返回 True . 只是因为 False 在列表中 .
True
False
但如果我这样做:
>>> not(True) in [False, True] False
返回 False . 而 not(True) 等于 False :
not(True)
>>> not(True) False
为什么?
Operator precedence 2.x,3.x . not 的优先级低于 in 的优先级 . 所以它相当于:
not
in
>>> not (True in [False, True]) False
这就是你想要的:
>>> (not True) in [False, True] True
正如@Ben指出:建议永远不要写 not(True) ,更喜欢 not True . 前者使它看起来像一个函数调用,而 not 是一个运算符,而不是一个函数 .
not True
not x in y 被评估为 x not in y
您可以通过反汇编代码来确切了解发生了什么 . 第一种情况按预期工作:
>>> x = lambda: False in [False, True] >>> dis.dis(x) 1 0 LOAD_GLOBAL 0 (False) 3 LOAD_GLOBAL 0 (False) 6 LOAD_GLOBAL 1 (True) 9 BUILD_LIST 2 12 COMPARE_OP 6 (in) 15 RETURN_VALUE
第二种情况,评估为 True not in [False, True] ,这显然是 False :
True not in [False, True]
>>> x = lambda: not(True) in [False, True] >>> dis.dis(x) 1 0 LOAD_GLOBAL 0 (True) 3 LOAD_GLOBAL 1 (False) 6 LOAD_GLOBAL 0 (True) 9 BUILD_LIST 2 12 COMPARE_OP 7 (not in) 15 RETURN_VALUE >>>
您要表达的是 (not(True)) in [False, True] ,正如预期的那样是 True ,您可以看到原因:
(not(True)) in [False, True]
>>> x = lambda: (not(True)) in [False, True] >>> dis.dis(x) 1 0 LOAD_GLOBAL 0 (True) 3 UNARY_NOT 4 LOAD_GLOBAL 1 (False) 7 LOAD_GLOBAL 0 (True) 10 BUILD_LIST 2 13 COMPARE_OP 6 (in) 16 RETURN_VALUE
运算符优先级 . in 绑定比 not 更紧密,所以你的表达式相当于 not((True) in [False, True]) .
not((True) in [False, True])
这都是关于operator precedence( in 强于 not ) . 但是可以通过在正确的位置添加括号来轻松纠正:
(not(True)) in [False, True] # prints true
写作:
not(True) in [False, True]
是这样的:
查看 True 是否在列表中并返回结果的"not" .
它正在评估为 not True in [False, True] ,它返回 False 因为 True 在 [False, True] 中
not True in [False, True]
[False, True]
如果你试试
>>>(not(True)) in [False, True] True
你得到了预期的结果 .
除了提到 not 的优先级的其他答案低于 in ,实际上您的语句相当于:
not (True in [False, True])
但请注意,如果你不将你的条件与其他条件分开,python将使用2个角色( precedence 或 chaining )来分隔它,在这种情况下python使用优先级 . 另外,请注意,如果要分离条件,则需要将所有条件放在括号中,而不仅仅是对象或值:
precedence
chaining
(not True) in [False, True]
但如上所述,python对运算符的另一个修改是 chaining :
基于python documentation:
请注意,比较,成员资格测试和身份测试都具有相同的优先级,并具有从“比较”部分中所述的从左到右的链接功能 .
例如,以下语句的结果是 False :
>>> True == False in [False, True] False
因为python会将语句链接如下:
(True == False) and (False in [False, True])
这究竟是 False and True ,即 False .
False and True
您可以假设中心对象将在2个操作和其他对象之间共享(在本例中为False) .
请注意,对于所有比较,它也适用,包括跟随操作数的成员资格测试和身份测试操作:
in, not in, is, is not, <, <=, >, >=, !=, ==
示例:
>>> 1 in [1,2] == True False
另一个着名的例子是数字范围:
7<x<20
这相当于:
7<x and x<20
让我们将其视为集合包含检查操作: [False, True] 是包含一些元素的列表 .
表达式 True in [False, True] 返回 True ,因为 True 是列表中包含的元素 .
True in [False, True]
因此, not True in [False, True] 给出了上述表达式的"boolean opposite", not 结果(没有任何括号保留优先级,因为 in 的优先级高于 not 运算符) . 因此, not True 将导致 False .
另一方面, (not True) in [False, True] 等于 False in [False, True] ,即 True ( False 包含在列表中) .
False in [False, True]
为了澄清其他一些答案,在一元运算符后添加括号不会改变其优先级 . not(True) 不会使 not 更紧密地绑定到 True . 它只是 True 周围的一组冗余括号 . 它与 (True) in [True, False] 大致相同 . 括号不做任何事情 . 如果希望绑定更紧密,则必须将括号放在整个表达式周围,这意味着运算符和操作数,即 (not True) in [True, False] .
(True) in [True, False]
(not True) in [True, False]
为了看到另一种方式,请考虑
>>> -2**2 -4
** 比 - 更紧密地绑定,这就是为什么你得到两个平方的负数,而不是负二的平方(这将是正四) .
**
-
如果你确实想要负二的平方怎么办?显然,你要添加括号:
>>> (-2)**2 4
但是,期望以下内容给出 4 是不合理的
4
>>> -(2)**2 -4
因为 -(2) 与 -2 相同 . 括号什么都不做 . not(True) 完全一样 .
-(2)
-2
8 回答
Operator precedence 2.x,3.x .
not
的优先级低于in
的优先级 . 所以它相当于:这就是你想要的:
正如@Ben指出:建议永远不要写
not(True)
,更喜欢not True
. 前者使它看起来像一个函数调用,而not
是一个运算符,而不是一个函数 .not x in y 被评估为 x not in y
您可以通过反汇编代码来确切了解发生了什么 . 第一种情况按预期工作:
第二种情况,评估为
True not in [False, True]
,这显然是False
:您要表达的是
(not(True)) in [False, True]
,正如预期的那样是True
,您可以看到原因:运算符优先级 .
in
绑定比not
更紧密,所以你的表达式相当于not((True) in [False, True])
.这都是关于operator precedence(
in
强于not
) . 但是可以通过在正确的位置添加括号来轻松纠正:写作:
是这样的:
查看
True
是否在列表中并返回结果的"not" .它正在评估为
not True in [False, True]
,它返回False
因为True
在[False, True]
中如果你试试
你得到了预期的结果 .
除了提到
not
的优先级的其他答案低于in
,实际上您的语句相当于:但请注意,如果你不将你的条件与其他条件分开,python将使用2个角色(
precedence
或chaining
)来分隔它,在这种情况下python使用优先级 . 另外,请注意,如果要分离条件,则需要将所有条件放在括号中,而不仅仅是对象或值:但如上所述,python对运算符的另一个修改是 chaining :
基于python documentation:
例如,以下语句的结果是
False
:因为python会将语句链接如下:
这究竟是
False and True
,即False
.您可以假设中心对象将在2个操作和其他对象之间共享(在本例中为False) .
请注意,对于所有比较,它也适用,包括跟随操作数的成员资格测试和身份测试操作:
示例:
另一个着名的例子是数字范围:
这相当于:
让我们将其视为集合包含检查操作:
[False, True]
是包含一些元素的列表 .表达式
True in [False, True]
返回True
,因为True
是列表中包含的元素 .因此,
not True in [False, True]
给出了上述表达式的"boolean opposite",not
结果(没有任何括号保留优先级,因为in
的优先级高于not
运算符) . 因此,not True
将导致False
.另一方面,
(not True) in [False, True]
等于False in [False, True]
,即True
(False
包含在列表中) .为了澄清其他一些答案,在一元运算符后添加括号不会改变其优先级 .
not(True)
不会使not
更紧密地绑定到True
. 它只是True
周围的一组冗余括号 . 它与(True) in [True, False]
大致相同 . 括号不做任何事情 . 如果希望绑定更紧密,则必须将括号放在整个表达式周围,这意味着运算符和操作数,即(not True) in [True, False]
.为了看到另一种方式,请考虑
**
比-
更紧密地绑定,这就是为什么你得到两个平方的负数,而不是负二的平方(这将是正四) .如果你确实想要负二的平方怎么办?显然,你要添加括号:
但是,期望以下内容给出
4
是不合理的因为
-(2)
与-2
相同 . 括号什么都不做 .not(True)
完全一样 .