Warum gibt der Ausdruck 0 <0 == 0 in Python False zurück?

Beim Betrachten von Queue.py in Python 2.6 fand ich dieses Konstrukt, das ich etwas seltsam fand:

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

Wenn maxsize0 ist, ist die Warteschlange nie voll.

Meine Frage ist, wie es in diesem Fall funktioniert? Wie 0 < 0 == 0wird als falsch angesehen?

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

Ich glaube, Python hat eine spezielle Fallbehandlung für Sequenzen von Vergleichsoperatoren, um Bereichsvergleiche einfach auszudrücken. Es ist viel schöner sagen zu können 0 < x <= 5als zu sagen (0 < x) and (x <= 5).

Diese werden als verkettete Vergleiche bezeichnet . Und das ist ein Link zur Dokumentation für sie.

In den anderen Fällen, über die Sie sprechen, wird in Klammern ein Vergleichsoperator vor dem anderen angewendet, sodass es sich nicht mehr um verkettete Vergleiche handelt. Und da Trueund FalseWerte als Ganzzahlen haben, erhalten Sie die Antworten, die Sie tun, aus den in Klammern gesetzten Versionen.

weil

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

ist False. Sie können Vergleichsoperatoren verketten und sie werden automatisch zu paarweisen Vergleichen erweitert.

EDIT - Klarstellung über Richtig und Falsch in Python

In Python Trueund Falsesind nur Instanzen von bool, was eine Unterklasse von ist int. Mit anderen Worten, ist Truewirklich nur 1.

Der Punkt dabei ist, dass Sie das Ergebnis eines booleschen Vergleichs genau wie eine Ganzzahl verwenden können. Dies führt zu verwirrenden Dingen wie

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

Dies geschieht jedoch nur, wenn Sie die Vergleiche in Klammern setzen, damit sie zuerst ausgewertet werden. Andernfalls erweitert Python die Vergleichsoperatoren.

Das seltsame Verhalten, das Sie erleben, beruht auf der Fähigkeit von Python, Bedingungen zu verketten. Da festgestellt wird, dass 0 nicht kleiner als 0 ist, entscheidet es, dass der gesamte Ausdruck als falsch ausgewertet wird. Sobald Sie dies in separate Bedingungen zerlegen, ändern Sie die Funktionalität. Es testet zunächst im Wesentlichen das a < b && b == cfür Ihre ursprüngliche Aussage von a < b == c.

Ein anderes Beispiel:

>>> 1 < 5 < 3
False

>>> (1 < 5) < 3
True

>>> 0 < 0 == 0
False

Dies ist ein verketteter Vergleich. Es gibt true zurück, wenn jeder paarweise Vergleich der Reihe nach true ist. Es ist das Äquivalent zu(0 < 0) and (0 == 0)

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

Dies entspricht 0 < Trueder Auswertung von True.

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

Dies entspricht False == 0der Auswertung von True.

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

Entspricht 0 < Truedem, wie oben, True.

Mit Blick auf die Demontage (die Bytes - Codes) ist es offensichtlich, warum 0 < 0 == 0ist False.

Hier ist eine Analyse dieses Ausdrucks:

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

Hinweiszeilen 0-8: Diese Zeilen prüfen, ob 0 < 0diese offensichtlich Falseauf den Python-Stapel zurückkehren.

Beachten Sie nun Zeile 11: JUMP_IF_FALSE_OR_POP 23 Dies bedeutet, dass Sie bei 0 < 0Rückgabe Falseeinen Sprung zu Zeile 23 ausführen.

Jetzt 0 < 0wird Falseder Sprung ausgeführt, der den Stapel mit einem FalseRückgabewert für den gesamten Ausdruck verlässt 0 < 0 == 0, obwohl der == 0Teil nicht einmal überprüft ist.

Abschließend ist die Antwort wie in anderen Antworten auf diese Frage angegeben. 0 < 0 == 0hat eine besondere Bedeutung. Der Compiler wertet dies mit zwei Begriffen aus: 0 < 0und 0 == 0. Wie bei allen komplexen booleschen Ausdrücken andzwischen ihnen wird der zweite nicht einmal überprüft, wenn der erste fehlschlägt.

Ich hoffe, dass dies die Dinge ein wenig aufklärt, und ich hoffe wirklich, dass die Methode, mit der ich dieses unerwartete Verhalten analysiert habe, andere dazu ermutigen wird, dies in Zukunft auch zu versuchen.

Wie bereits erwähnt, x comparison_operator y comparison_operator zhandelt es sich um syntaktischen Zucker (x comparison_operator y) and (y comparison_operator z)mit dem Bonus, dass y nur einmal bewertet wird.

Ihr Ausdruck 0 < 0 == 0ist also wirklich (0 < 0) and (0 == 0), was zu False and Truewelchem ​​gerecht wird False.

Vielleicht kann dieser Auszug aus den Dokumenten helfen:

Dies sind die sogenannten "Rich-Compare" -Methoden, die für Vergleichsoperatoren bevorzugt __cmp__()werden. Die Korrespondenz zwischen Operatorsymbole und Methodennamen ist wie folgt: x<yAnrufe x.__lt__(y), x<=yAnrufe x.__le__(y), x==yAnrufe x.__eq__(y), x!=yund x<>y Anruf x.__ne__(y), x>yAnrufe x.__gt__(y)und x>=yAnrufe x.__ge__(y).

Eine umfangreiche Vergleichsmethode kann den Singleton zurückgeben, NotImplementedwenn die Operation für ein bestimmtes Argumentpaar nicht implementiert wird. Konventionell Falseund Truewerden für einen erfolgreichen Vergleich zurückgegeben. Diese Methoden können jedoch einen beliebigen Wert zurückgeben. Wenn der Vergleichsoperator in einem booleschen Kontext verwendet wird (z. B. unter der Bedingung einer if-Anweisung), ruft Python bool()den Wert auf, um festzustellen, ob das Ergebnis wahr oder falsch ist.

Es gibt keine impliziten Beziehungen zwischen den Vergleichsoperatoren. Die Wahrheit von x==ybedeutet nicht, dass dies x!=y falsch ist. Dementsprechend sollte beim Definieren __eq__()auch definiert werden __ne__(), dass sich die Operatoren wie erwartet verhalten. Im folgenden Abschnitt finden Sie __hash__()einige wichtige Hinweise zum Erstellen von Hash-Objekten, die benutzerdefinierte Vergleichsvorgänge unterstützen und als Wörterbuchschlüssel verwendet werden können.

Es gibt keine Versionen dieser Methoden mit vertauschten Argumenten (die verwendet werden sollen, wenn das linke Argument die Operation nicht unterstützt, das rechte Argument jedoch). vielmehr __lt__()und __gt__() sind die Reflexion des anderen __le__() und __ge__()sind die Reflexion des anderen und __eq__()und __ne__() sind ihre eigene Reflexion.

Argumente für reichhaltige Vergleichsmethoden werden niemals erzwungen.

Dies waren Vergleiche, aber da Sie Vergleiche verketten , sollten Sie Folgendes wissen:

Vergleiche können willkürlich verkettet werden, z. B. x < y <= zist äquivalent zu x < y and y <= z, außer dass y nur einmal ausgewertet wird (aber in beiden Fällen wird z überhaupt nicht ausgewertet, wenn x <y als falsch befunden wird).

Wenn a, b, c, ..., y, z Ausdrücke sind und op1, op2, ..., opN Vergleichsoperatoren sind, dann ist a op1 b op2 c ... y opN z äquivalent zu op1 b und b op2 c und ... y opN z, außer dass jeder Ausdruck höchstens einmal ausgewertet wird.

Hier ist es in seiner ganzen Pracht.

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

Ich denke, Python macht es komisch zwischen Magie. Gleich wie 1 < 2 < 3Mittel 2 zwischen 1 und 3 liegt.

In diesem Fall denke ich, dass [mittlere 0] größer als [links 0] und gleich [rechts 0] ist. Die mittlere 0 ist nicht größer als die linke 0, daher wird sie als falsch ausgewertet.