Por que a expressão 0 <0 == 0 retorna False em Python?

Olhando para Queue.py no Python 2.6, achei essa construção que achei um pouco estranha:

def full(self):
    """Return True if the queue is full, False otherwise
    (not reliable!)."""
    self.mutex.acquire()
    n = 0 < self.maxsize == self._qsize()
    self.mutex.release()
    return n

Se maxsizefor 0, a fila nunca estará cheia.

Minha pergunta é como isso funciona para este caso? Como 0 < 0 == 0é considerado falso?

>>> 0 < 0 == 0
False
>>> (0) < (0 == 0)
True
>>> (0 < 0) == 0
True
>>> 0 < (0 == 0)
True

Acredito que o Python tenha um tratamento especial de caso para sequências de operadores relacionais para facilitar a expressão de comparações de intervalo. É muito melhor poder dizer 0 < x <= 5do que dizer (0 < x) and (x <= 5).

Estes são chamados comparações encadeadas . E esse é um link para a documentação para eles.

Nos outros casos mencionados, os parênteses forçam um operador relacional a ser aplicado antes do outro e, portanto, não são mais comparações encadeadas. E desde que Truee Falsetenha valores como números inteiros, você obtém as respostas das versões entre parênteses.

Porque

(0 < 0) and (0 == 0)

é False. Você pode encadear operadores de comparação e eles são expandidos automaticamente nas comparações aos pares.

EDIT - esclarecimentos sobre True e False em Python

Em Python Truee Falsesão apenas instâncias de bool, que é uma subclasse de int. Em outras palavras, Trueé realmente apenas 1.

O ponto disso é que você pode usar o resultado de uma comparação booleana exatamente como um número inteiro. Isso leva a coisas confusas como

>>> (1==1)+(1==1)
2
>>> (2<1)<1
True

Mas isso só acontecerá se você colocar as comparações entre parênteses para que sejam avaliadas primeiro. Caso contrário, o Python expandirá os operadores de comparação.

O comportamento estranho que você experimenta vem da capacidade dos pítons de encadear condições. Como encontra 0 não é menor que 0, decide que a expressão inteira é avaliada como falsa. Assim que você separar isso em condições separadas, você estará alterando a funcionalidade. Inicialmente, ele está essencialmente testando isso a < b && b == cpara sua declaração original de a < b == c.

Outro exemplo:

>>> 1 < 5 < 3
False

>>> (1 < 5) < 3
True

>>> 0 < 0 == 0
False

Esta é uma comparação encadeada. Retorna true se cada comparação por pares for verdadeira. É o equivalente a(0 < 0) and (0 == 0)

>>> (0) < (0 == 0)
True

Isso é equivalente ao 0 < Trueque é avaliado como True.

>>> (0 < 0) == 0
True

Isso é equivalente ao False == 0que é avaliado como True.

>>> 0 < (0 == 0)
True

Equivalente ao 0 < Truequal, como acima, avalia como True.

Olhando para a desmontagem (a códigos de bytes), é óbvio porque 0 < 0 == 0é False.

Aqui está uma análise dessa expressão:

>>>import dis

>>>def f():
...    0 < 0 == 0

>>>dis.dis(f)
  2      0 LOAD_CONST               1 (0)
         3 LOAD_CONST               1 (0)
         6 DUP_TOP
         7 ROT_THREE
         8 COMPARE_OP               0 (<)
        11 JUMP_IF_FALSE_OR_POP    23
        14 LOAD_CONST               1 (0)
        17 COMPARE_OP               2 (==)
        20 JUMP_FORWARD             2 (to 25)
   >>   23 ROT_TWO
        24 POP_TOP
   >>   25 POP_TOP
        26 LOAD_CONST               0 (None)
        29 RETURN_VALUE

Observe as linhas de 0 a 8: essas linhas verificam se o 0 < 0que obviamente retorna Falseà pilha python.

Agora observe a linha 11: JUMP_IF_FALSE_OR_POP 23 Isso significa que, se 0 < 0retornos, Falseexecute um salto para a linha 23.

Agora, 0 < 0é False, então o salto é dado, o que deixa a pilha com um Falsevalor de retorno para toda a expressão 0 < 0 == 0, mesmo que a == 0parte nem seja verificada.

Portanto, para concluir, a resposta é como a dita em outras respostas a essa pergunta. 0 < 0 == 0tem um significado especial. O compilador avalia isso em dois termos: 0 < 0e 0 == 0. Como em qualquer expressão booleana complexa andentre elas, se a primeira falhar, a segunda nem será verificada.

Espero que isso ilumine um pouco as coisas, e realmente espero que o método que eu usei para analisar esse comportamento inesperado incentive outras pessoas a tentarem o mesmo no futuro.

Como já x comparison_operator y comparison_operator zfoi mencionado, o açúcar sintático é (x comparison_operator y) and (y comparison_operator z)o bônus que y é avaliado apenas uma vez.

Portanto, sua expressão 0 < 0 == 0é realmente (0 < 0) and (0 == 0), o que avalia False and Truequal é justo False.

talvez este trecho dos documentos possa ajudar:

Estes são os chamados métodos de "comparação rica" ​​e são chamados para operadores de comparação, de preferência __cmp__()abaixo. A correspondência entre símbolos de operadores e nomes método é o seguinte: x<yas chamadas x.__lt__(y), x<=ychamadas x.__le__(y), x==ychamadas x.__eq__(y), x!=ye x<>y chamada x.__ne__(y), x>ychamadas x.__gt__(y), e x>=ychamadas x.__ge__(y).

Um método de comparação rico pode retornar o singleton NotImplementedse ele não implementar a operação para um determinado par de argumentos. Por convenção, Falsee Truesão retornados para uma comparação bem-sucedida. No entanto, esses métodos podem retornar qualquer valor, portanto, se o operador de comparação for usado em um contexto booleano (por exemplo, na condição de uma instrução if), o Python chamará bool()o valor para determinar se o resultado é verdadeiro ou falso.

Não há relacionamentos implícitos entre os operadores de comparação. A verdade de x==ynão implica que isso x!=y seja falso. Assim, ao definir __eq__(), deve-se definir também __ne__()para que os operadores se comportem conforme o esperado. Consulte o parágrafo em __hash__()para algumas notas importantes sobre a criação de objetos hash que suportam operações de comparação personalizadas e são utilizáveis ​​como chaves de dicionário.

Não há versões de argumento trocado desses métodos (a serem usadas quando o argumento esquerdo não suporta a operação, mas o argumento correto); sim, __lt__()e __gt__() são reflexo um do outro, __le__() e __ge__()são reflexo um do outro, e __eq__()e __ne__() são a sua própria reflexão.

Argumentos para métodos de comparação sofisticados nunca são coagidos.

Essas foram comparações, mas como você está encadeando comparações, você deve saber que:

As comparações podem ser encadeadas arbitrariamente, por exemplo, x < y <= zé equivalente a x < y and y <= z, exceto que y é avaliado apenas uma vez (mas em ambos os casos, z não é avaliado quando x <y é considerado falso).

Formalmente, se a, b, c, ..., y, z são expressões e op1, op2, ..., opN são operadores de comparação, então a op1 b op2 c ... y opN z é equivalente a op1 b e b op2 c e ... y opN z, exceto que cada expressão é avaliada no máximo uma vez.

Aqui está em toda a sua glória.

>>> class showme(object):
...   def __init__(self, name, value):
...     self.name, self.value = name, value
...   def __repr__(self):
...     return "<showme %s:%s>" % (self.name, self.value)
...   def __cmp__(self, other):
...     print "cmp(%r, %r)" % (self, other)
...     if type(other) == showme:
...       return cmp(self.value, other.value)
...     else:
...       return cmp(self.value, other)
... 
>>> showme(1,0) < showme(2,0) == showme(3,0)
cmp(<showme 1:0>, <showme 2:0>)
False
>>> (showme(1,0) < showme(2,0)) == showme(3,0)
cmp(<showme 1:0>, <showme 2:0>)
cmp(<showme 3:0>, False)
True
>>> showme(1,0) < (showme(2,0) == showme(3,0))
cmp(<showme 2:0>, <showme 3:0>)
cmp(<showme 1:0>, True)
True
>>> 

Eu estou pensando que Python está fazendo isso é estranho entre magia. O mesmo que a 1 < 2 < 3média 2 está entre 1 e 3.

Nesse caso, acho que está fazendo [o meio 0] é maior que [esquerdo 0] e igual a [direito 0]. O meio 0 não é maior que o esquerdo 0, portanto, avalia como falso.