Precisione dell'operatore Python - e superiore a

Question

Ho una riga di codice nel mio script che ha entrambi questi operatori concatenati. Dalla documentazione di riferimento BOOLEAN E ha precedenza inferiore rispetto a COMPARAZIONE DI MAGGIORANZA DI. Sto ottenendo risultati inattesi qui, in questo codice:

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

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

mi aspettavo Seconda o Terza prova per accadere prima che il pugno, dal momento > operatore ha una precedenza più alta. Cosa sto facendo di sbagliato qui?

https://docs.python.org/3/reference/expressions.html#operator-precedence

Answer 1

Perché si sta guardando la cosa sbagliata. call (o chiamata di funzione) prende la precedenza più alta sia su and sia su > (maggiore di). Quindi le prime chiamate di funzione avvengono da sinistra a destra.

Python otterrà i risultati per tutte le chiamate di funzione prima che avvenga il confronto. L'unica cosa che prevale qui è il cortocircuito, quindi se test("First",10) restituisce False, si interrompe e restituisce False.

I confronti e and si verificano ancora nella stessa precendenza, cioè prima il risultato di test("Second", 15) viene confrontato con test("Third", 5) (si prega di notare solo i valori di ritorno (la chiamata di funzione già accaduto prima)). Quindi il risultato di test("Second", 15) > test("Third", 5) viene utilizzato nell'operazione and.

Dalla documentazione sulla operator precedence -

Answer 2

Un modo per vedere cosa sta succedendo è guardare esattamente come Python interpreta questo risultato:

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

Se fate lo stesso per 10 and 15 > 5, ottieni:

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