quelles sont les méthodes utilisées par `foo <bar <baz`?

Question

En python, on peut dire:

if foo < bar < baz: 
    do something. 

et de même, nous pouvons surcharger les opérateurs de comparaison comme:

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

mais les méthodes des types des opérandes de ces comparisions d'intervalle sont effectivement appelés? est l'équivalent ci-dessus à

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

Éditer: re S.Lott, Voici une sortie qui aide à illustrer ce qui se passe réellement.

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

Vous avez raison:

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 

sortie :

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

Answer 2

if foo < bar < baz: 

est équivalent à

if foo < bar and bar < baz: 

avec une distinction importante: si la barre est un mutationniste, il sera mis en mémoire cache. À savoir:

if foo < bar() < baz: 

est équivalent à

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

Mais pour répondre à votre question, il finira par être:

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

Answer 3

Il appelle la méthode spéciale __lt__() et, au besoin, il appellera __nonzero__() pour forcer le résultat de __lt__() à un booléen. Étonnamment (pour moi au moins), il n'y a pas de méthode __and__() pour remplacer l'opérateur and.

Voici un programme de test:

#!/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 

Sortie:

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

Answer 4

Il utilise des appels successifs au moins que l'opérateur de comparaison:

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