在Python中编写双重不等式时的运算符优先级是什么(显式在代码中,如何为数组重写？)

Question

当我要求类似的东西时,按顺序执行的具体代码是什么

>>> 1 <= 3 >= 2
True

如果两者具有相同的优先权并且只是它们的评估顺序,为什么第二个不等式起(3 >= 2)代替(True >= 2)

考虑一下这些之间的区别

>>> (1 < 3) < 2
True

>>> 1 < 3 < 2
False

它只是一个纯粹的语法快捷方式硬编码到Python中,以扩展第二个作为and两个语句？

我可以改变一个类的这种行为,以便a <= b <= c扩展到不同的东西吗？它看起来像以下情况

a (logical operator) b (logical operator) c 
    --> (a logical operator b) and (b logical operator c)

但真正的问题是如何在代码中实现它.

我很好奇,这样我可以复制这种__lt__与__gt__行为在一些我自己的类,但我感到困惑,这是如何实现的固定中部参数不变.

这是一个具体的例子:

>>> import numpy as np

>>> tst = np.asarray([1,2,3,4,5,6])

>>> 3 <= tst
array([False, False,  True,  True,  True,  True], dtype=bool)

>>> 3 <= tst <= 5
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/home/ely/<ipython-input-135-ac909818f2b1> in <module>()
----> 1 3 <= tst <= 5

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

很高兴覆盖它,以便它"也适用于"数组,如下所示:

>>> np.logical_and(3 <= tst, tst <= 5)
array([False, False,  True,  True,  True,  False], dtype=bool)

添加澄清

在评论中表明我在解释问题方面做得不好.以下是一些澄清的评论:

1)我不是在寻找一个简单的解释,即解释器and在两个链式不等式之间弹出.我已经知道了,并且如上所述.

2)为了类比我想做的事,请考虑with语句(链接).下列:

with MyClass(some_obj) as foo:
    do_stuff()

打开包装

foo = MyClass(some_obj)
foo.__enter__()
try:
    do_stuff()
finally:
    foo.__exit__()

所以通过MyClass恰当的写作,我可以在with声明中做很多特别的事情.

我问是否有类似的代码解包链式不等式,我可以通过它来拦截它正在做的事情并将其重定向到使用数组式逻辑运算符,而不仅仅是我关心的类.

我觉得这个问题非常明确,特别是这个例子,但希望这更清楚.

Answer 1

我不完全确定你在寻找什么,但是快速反汇编显示a < b < c没有编译成与字节码相同的字节码a < b and b < c

>>> import dis
>>>
>>> def f(a, b, c):
...     return a < b < c
...
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 DUP_TOP
              7 ROT_THREE
              8 COMPARE_OP               0 (<)
             11 JUMP_IF_FALSE_OR_POP    21
             14 LOAD_FAST                2 (c)
             17 COMPARE_OP               0 (<)
             20 RETURN_VALUE
        >>   21 ROT_TWO
             22 POP_TOP
             23 RETURN_VALUE
>>>
>>> def f(a, b, c):
...     return a < b and b < c
...
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 COMPARE_OP               0 (<)
              9 JUMP_IF_FALSE_OR_POP    21
             12 LOAD_FAST                1 (b)
             15 LOAD_FAST                2 (c)
             18 COMPARE_OP               0 (<)
        >>   21 RETURN_VALUE

编辑1:进一步挖掘,我认为这是numpy的奇怪或错误.考虑一下这个示例代码,我认为它可以像您期望的那样工作.

class Object(object):
    def __init__(self, values):
        self.values = values
    def __lt__(self, other):
        return [x < other for x in self.values]
    def __gt__(self, other):
        return [x > other for x in self.values]

x = Object([1, 2, 3])
print x < 5 # [True, True, True]
print x > 5 # [False, False, False]
print 0 < x < 5 # [True, True, True]

编辑2:实际上这"不正常"......

print 1 < x # [False, True, True]
print x < 3 # [True, True, False]
print 1 < x < 3 # [True, True, False]

我认为它将布尔值与第二次比较中的数字进行比较1 < x < 3.

编辑3:我不喜欢从gt,lt,gte,lte特殊方法返回非布尔值的想法,但它实际上并没有根据Python文档进行限制.

http://docs.python.org/reference/datamodel.html#object.LT

按照惯例,返回False和True以进行成功比较.但是,这些方法可以返回任何值......

Answer 2

两者具有相同的优先级，但根据文档从左到右进行评估。形式的表达式a <= b <= c被扩展为a <= b and b <= c。