首页 文章

为什么“False,True]中的”not(True)“返回False?

提问于
浏览
463

如果我这样做:

>>> False in [False, True]
True

返回 True . 只是因为 False 在列表中 .

但如果我这样做:

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

返回 False . 而 not(True) 等于 False

>>> not(True)
False

为什么?

8 回答

  • 710

    Operator precedence 2.x,3.x . not 的优先级低于 in 的优先级 . 所以它相当于:

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

    这就是你想要的:

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

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

  • 33

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

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

  • 6

    这都是关于operator precedencein 强于 not ) . 但是可以通过在正确的位置添加括号来轻松纠正:

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

    写作:

    not(True) in [False, True]
    

    是这样的:

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

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

  • 6

    它正在评估为 not True in [False, True] ,它返回 False 因为 True[False, True]

    如果你试试

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

    你得到了预期的结果 .

  • 13

    除了提到 not 的优先级的其他答案低于 in ,实际上您的语句相当于:

    not (True in [False, True])
    

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

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

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

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

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

    示例:

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

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

    7<x<20
    

    这相当于:

    7<x and x<20
    
  • 14

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

  • 35

    为了澄清其他一些答案,在一元运算符后添加括号不会改变其优先级 . 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) 完全一样 .

相关问题