¿qué métodos realmente invocan `foo <bar <baz`?

Question

en Python podemos decir:

if foo < bar < baz: 
    do something. 

y de manera similar, podemos sobrecargar los operadores COMPARACIÓN como:

class Bar: 
    def __lt__(self, other): 
     do something else 

pero lo que los métodos de los tipos de los operandos de las comparaciones de intervalo se llama en realidad? es equivalente a la anterior

if foo.__lt__(bar) and bar.__lt__(baz): 
    do something. 

Edición: Re S. Lott, He aquí alguna salida que ayuda a ilustrar lo que realmente sucede.

>>> class Bar: 
    def __init__(self, name): 
     self.name = name 
     print('__init__', self.name) 
    def __lt__(self, other): 
     print('__lt__', self.name, other.name) 
     return self.name < other.name 

>>> Bar('a') < Bar('b') < Bar('c') 
('__init__', 'a') 
('__init__', 'b') 
('__lt__', 'a', 'b') 
('__init__', 'c') 
('__lt__', 'b', 'c') 
True 
>>> Bar('b') < Bar('a') < Bar('c') 
('__init__', 'b') 
('__init__', 'a') 
('__lt__', 'b', 'a') 
False 
>>> 

Answer 1

Estás en lo correcto:

class Bar: 
    def __init__(self, name): 
     self.name = name 
    def __lt__(self, other): 
     print('__lt__', self.name, other.name) 
     return True 

a,b,c = Bar('a'), Bar('b'), Bar('c') 

a < b < c 

salida :

('__lt__', 'a', 'b') 
('__lt__', 'b', 'c') 
True 

Answer 2

if foo < bar < baz: 

es equivalente a

if foo < bar and bar < baz: 

con una diferencia importante: si la barra es un mutante, que se almacenan en caché. Es decir:

if foo < bar() < baz: 

es equivalente a

tmp = bar() 
if foo < tmp and tmp < baz: 

Pero para responder a su pregunta, que va a terminar siendo:

if foo.__lt__(bar) and bar.__lt__(baz): 

Answer 3

llama al método especial __lt__(), y si es necesario se llamará __nonzero__() para coaccionar el resultado de __lt__() a un valor lógico. Sorprendentemente (para mí al menos), no hay un método __and__() para anular el operador and.

Aquí es un programa de prueba:

#!/usr/bin/env python 

class Bar: 
    def __init__(self, value): 
     self.value = value 

    def __lt__(self, other): 
     print "%s.__lt__(%s)" % (self, other) 
     return Bar("%s.__lt__(%s)" % (self, other)) 

    def __nonzero__(self): 
     print "%s.__nonzero__()" % (self) 
     return True 

    def __str__(self): 
     return self.value 

foo = Bar("foo") 
bar = Bar("bar") 
baz = Bar("baz") 

if foo < bar < baz: 
    pass 

Salida:

foo.__lt__(bar) 
foo.__lt__(bar).__nonzero__() 
bar.__lt__(baz) 
bar.__lt__(baz).__nonzero__() 

Answer 4

Utiliza sucesivas llamadas al operador menos que la comparación:

>>> import dis 
>>> def foo(a,b,c): 
...  return a < b < c 
... 
>>> dis.dis(foo) 
    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   8 (to 22) 
      14 POP_TOP    
      15 LOAD_FAST    2 (c) 
      18 COMPARE_OP    0 (<) 
      21 RETURN_VALUE   
     >> 22 ROT_TWO    
      23 POP_TOP    
      24 RETURN_VALUE