为什么"False,True]中的"not(True)"返回False？

Question

如果我这样做:

>>> False in [False, True]
True

那回来了True.只是因为False在列表中.

但如果我这样做:

>>> not(True) in [False, True]
False

那回来了False.而not(True)等于False:

>>> not(True)
False

为什么？

Answer 1

运算符优先级 ^2.x,3.x.优先级not低于in.所以它相当于:

>>> not ((True) in [False, True])
False

这就是你想要的:

>>> (not True) in [False, True]
True

正如@Ben所指出的那样:建议永远不要写not(True),更喜欢not True.前者使它看起来像一个函数调用,而它not是一个运算符,而不是一个函数.

Answer 2

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显然:

>>> 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,您可以看到原因:

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

Answer 3

运算符优先级.in绑定比紧not,所以你的表达相当于not((True) in [False, True]).

Answer 4

这都是关于运算符优先级(in强于not).但是可以通过在正确的位置添加括号来轻松纠正:

(not(True)) in [False, True]  # prints true

写作:

not(True) in [False, True]

是这样的:

not((True) in [False, True])

看起来是否True在列表中并返回结果的"not".

Answer 5

据评估为not True in [False, True],返回False是因为True在[False, True]

如果你试试

>>>(not(True)) in [False, True]
True

你得到了预期的结果.

Answer 6

除了提到优先级的其他答案not低于in,实际上你的陈述相当于:

not (True in [False, True])

但请注意,如果你不将你的条件与其他条件分开,python将使用2个角色(precedence或chaining)来分隔它,在这种情况下python使用优先级.另请注意,如果要分离条件,则需要将所有条件放在括号中,而不仅仅是对象或值:

(not True) in [False, True]

但正如前面提到的,python对链接的运算符进行了另一种修改:

基于python 文档:

请注意,比较,成员资格测试和身份测试都具有相同的优先级,并具有从"比较"部分中所述的从左到右的链接功能.

例如,以下语句的结果是False:

>>> True == False in [False, True]
False

因为python会将语句链接如下:

(True == False) and (False in [False, True])

这到底是False and True那是False.

您可以假设中心对象将在2个操作和其他对象之间共享(在本例中为False).

请注意,对于所有比较,它也适用,包括跟随操作数的成员资格测试和身份测试操作:

in, not in, is, is not, <, <=, >, >=, !=, ==

示例:

>>> 1 in [1,2] == True
False

另一个着名的例子是数字范围:

7<x<20

等于:

7<x and x<20   

Answer 7

让我们将其视为集合包含检查操作:[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包含在列表中).

Answer 8

为了澄清其他一些答案,在一元运算符后添加括号不会改变其优先级.not(True)不会使not绑定更紧密True.它只是一组冗余的括号True.它与...大致相同(True) in [True, False].括号不做任何事情.如果希望绑定更紧密,则必须将括号放在整个表达式周围,这意味着运算符和操作数,即(not True) in [True, False].

为了看到另一种方式,请考虑

>>> -2**2
-4

**比-这更紧密地绑定,这就是为什么你得到两个平方的负数,而不是负二的平方(这将是正四).

如果你确实想要负二的平方怎么办？显然,你要添加括号:

>>> (-2)**2
4

但是,期望以下内容给出是不合理的 4

>>> -(2)**2
-4

因为-(2)是一样的-2.括号什么都不做.not(True)是完全一样的.