Python运算符优先级-和大于

我的脚本中有一行代码，将这两个操作符链接在一起。从文档参考中，布尔值和的优先级低于比较大于。我在这段代码中得到了意想不到的结果：

>>> def test(msg, value):
...     print(msg)
...     return value

>>> test("First", 10) and test("Second", 15) > test("Third", 5)
First
Second
Third
True

我希望第二次或第三次测试在第一次测试之前进行，因为

运算符具有更高的优先级。我做错了什么

---

因为你看错了东西<代码>调用（或函数调用）比

和
以及
（大于）具有更高的优先级。因此，第一个函数调用是从左到右进行的

Python将在任何一个比较发生之前获得所有函数调用的结果。这里唯一需要注意的是短路，因此如果
test（“First”，10）
返回False，它将短路并返回False

比较和
和
仍然以相同的顺序进行，即首先将
测试的结果（“第二次”，15）
与
测试（“第三次”，5）
进行比较（请注意仅返回值（函数调用之前已经发生过））。然后在
和
操作中使用
测试的结果（“第二次”，15）>测试（“第三次”，5）

从上的文档-

了解发生了什么的一种方法是查看Python是如何解释这个结果的：

>>> x = lambda: test("First", 10) and test("Second", 15) > test("Third", 5)
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (test)
              3 LOAD_CONST               1 ('First')
              6 LOAD_CONST               2 (10)
              9 CALL_FUNCTION            2
             12 JUMP_IF_FALSE_OR_POP    42
             15 LOAD_GLOBAL              0 (test)
             18 LOAD_CONST               3 ('Second')
             21 LOAD_CONST               4 (15)
             24 CALL_FUNCTION            2
             27 LOAD_GLOBAL              0 (test)
             30 LOAD_CONST               5 ('Third')
             33 LOAD_CONST               6 (5)
             36 CALL_FUNCTION            2
             39 COMPARE_OP               4 (>)
        >>   42 RETURN_VALUE        

如果对
10和15>5执行相同的操作，则会得到：

>>> x = lambda: 10 and 15 > 5
>>> dis.dis(x)
  1           0 LOAD_CONST               1 (10)
              3 JUMP_IF_FALSE_OR_POP    15
              6 LOAD_CONST               2 (15)
              9 LOAD_CONST               3 (5)
             12 COMPARE_OP               4 (>)
        >>   15 RETURN_VALUE        

第一个值
10
的布尔解释也是正确的。因此，
10和15>5==10和（15>5）==10，True==True
但是为什么解释器在15或5之前得到10？比较不应该发生在布尔检查之前吗？
test（“First”，10）和test（“Second”，15）>test（“Third”，5）
等同于
test（“First”，10）和（test（“Second”，15）>test（“Third”，5））
Python也计算
和
优先级绝对正确<代码>0和0>-1
不同于
（0和0）>-1
。我的猜测是，虽然返回的值是按正确的顺序计算的，但由于某些原因，函数并没有按该顺序调用。有趣的是，将10,15,5替换为0,0，-1只会先打印
。也许这是一个编译器优化——因为在你的例子中，正如@Alik所指出的，两个顺序产生相同的值。这很有意义。非常感谢。因此，如果我仅用数字替换函数调用，我将得到不同的结果，对吗？对于数字，没有什么可计算的，所以我不确定您的意思是什么？Python将在比较或
和
发生之前获得所有函数调用的结果。这里唯一需要注意的就是短路