Associativité de «in» en Python?

Je crée un analyseur Python, et cela me déroute vraiment :

>>>  1 in  []  in 'a'
False

>>> (1 in  []) in 'a'
TypeError: 'in <string>' requires string as left operand, not bool

>>>  1 in ([] in 'a')
TypeError: 'in <string>' requires string as left operand, not list

Comment fonctionne exactement "in" en Python, en ce qui concerne l'associativité, etc.?

Pourquoi deux de ces expressions ne se comportent-elles pas de la même manière?

1 in [] in 'a'est évalué comme (1 in []) and ([] in 'a').

Puisque la première condition ( 1 in []) est False, la condition entière est évaluée comme False; ([] in 'a')n'est jamais réellement évalué, donc aucune erreur n'est générée.

Voici les définitions des instructions:

In [121]: def func():
   .....:     return 1 in [] in 'a'
   .....: 

In [122]: dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              3 BUILD_LIST               0
              6 DUP_TOP             
              7 ROT_THREE           
              8 COMPARE_OP               6 (in)
             11 JUMP_IF_FALSE            8 (to 22)  #if first comparison is wrong 
                                                    #then jump to 22, 
             14 POP_TOP             
             15 LOAD_CONST               2 ('a')
             18 COMPARE_OP               6 (in)     #this is never executed, so no Error
             21 RETURN_VALUE         
        >>   22 ROT_TWO             
             23 POP_TOP             
             24 RETURN_VALUE        

In [150]: def func1():
   .....:     return (1 in  []) in 'a'
   .....: 

In [151]: dis.dis(func1)
  2           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               3 (())
              6 COMPARE_OP               6 (in)   # perform 1 in []
              9 LOAD_CONST               2 ('a')  # now load 'a'
             12 COMPARE_OP               6 (in)   # compare result of (1 in []) with 'a'
                                                  # throws Error coz (False in 'a') is
                                                  # TypeError
             15 RETURN_VALUE   



In [153]: def func2():
   .....:     return 1 in ([] in 'a')
   .....: 

In [154]: dis.dis(func2)
  2           0 LOAD_CONST               1 (1)
              3 BUILD_LIST               0
              6 LOAD_CONST               2 ('a') 
              9 COMPARE_OP               6 (in)  # perform ([] in 'a'), which is 
                                                 # Incorrect, so it throws TypeError
             12 COMPARE_OP               6 (in)  # if no Error then 
                                                 # compare 1 with the result of ([] in 'a')
             15 RETURN_VALUE        

Python fait des choses spéciales avec des comparaisons chaînées.

Les éléments suivants sont évalués différemment:

x > y > z   # in this case, if x > y evaluates to true, then
            # the value of y is being used to compare, again,
            # to z

(x > y) > z # the parenth form, on the other hand, will first
            # evaluate x > y. And, compare the evaluated result
            # with z, which can be "True > z" or "False > z"

Dans les deux cas cependant, si la première comparaison est False, le reste de l'instruction ne sera pas examiné.

Pour votre cas particulier,

1 in [] in 'a'   # this is false because 1 is not in []

(1 in []) in a   # this gives an error because we are
                 # essentially doing this: False in 'a'

1 in ([] in 'a') # this fails because you cannot do
                 # [] in 'a'

Également pour illustrer la première règle ci-dessus, ce sont des instructions qui évaluent à True.

1 in [1,2] in [4,[1,2]] # But "1 in [4,[1,2]]" is False

2 < 4 > 1               # and note "2 < 1" is also not true

Préséance des opérateurs python: http://docs.python.org/reference/expressions.html#summary

De la documentation:

Les comparaisons peuvent être chaînées arbitrairement, par exemple, x <y <= z équivaut à x <y et y <= z, sauf que y est évalué une seule fois (mais dans les deux cas z n'est pas évalué du tout lorsque x <y est trouvé être faux).

Ce que cela signifie, c'est qu'il n'y a pas d'associativité x in y in z!

Les éléments suivants sont équivalents:

1 in  []  in 'a'
# <=>
middle = []
#            False          not evaluated
result = (1 in middle) and (middle in 'a')


(1 in  []) in 'a'
# <=>
lhs = (1 in []) # False
result = lhs in 'a' # False in 'a' - TypeError


1 in  ([] in 'a')
# <=>
rhs = ([] in 'a') # TypeError
result = 1 in rhs

La réponse courte, puisque la longue est déjà donnée plusieurs fois ici et d'excellente manière, est que l'expression booléenne est court-circuitée , c'est a arrêté l'évaluation quand un changement de vrai en faux ou vice versa ne peut pas se produire par une évaluation plus poussée.

(voir http://en.wikipedia.org/wiki/Short-circuit_evaluation )

Cela peut être un peu court (sans jeu de mots) comme réponse, mais comme mentionné, toutes les autres explications sont déjà assez bien faites ici, mais je pensais que le terme méritait d'être mentionné.