Pourquoi l’expression 0 < 0 == 0 return False en Python ?

Question

Regardant dans Queue.py en Python 2.6, j’ai trouvé cette construction que j’ai trouvé un peu étrange :

Si `` est 0, la file d’attente n’est jamais complète.

Ma question est comment ça fonctionne dans ce cas ? Comment `` est considéré comme faux ?

Answer 1

Je crois que Python a des cas de manipulation de séquences d'opérateurs relationnels pour faire des comparaisons de plage facile à exprimer. C'est beaucoup plus agréable d'être en mesure de dire 0 < x <= 5 que de dire (0 < x) and (x <= 5).

Ceux-ci sont appelés enchaîné les comparaisons. Et c'est un lien vers la documentation pour eux.

Avec les autres cas vous parler, la parenthèse de la force d'un opérateur relationnel pour être appliqué avant les autres, et donc ils ne sont plus enchaînés à des comparaisons. Et depuis True et False ont des valeurs que des entiers, vous obtenez les réponses que vous faites de la mise entre parenthèses des versions.

Answer 2

Parce que

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

est - False. Vous pouvez enchaîner les opérateurs de comparaison et ils sont automatiquement développés dans les comparaisons par paires.

---

EDIT -- des précisions sur le Vrai et le Faux en Python

En Python True et False sont juste des instances de bool, qui est une sous-classe de int. En d'autres termes, True est vraiment juste 1.

Le but de cela est que vous pouvez utiliser le résultat d'un booléen comparaison exactement comme un entier. Cela conduit à la confusion des choses comme

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

Mais ce ne sera possible que si vous parenthesise les comparaisons de sorte qu'ils sont évalués en premier. Sinon, Python va étendre les opérateurs de comparaison.

Answer 3

Le comportement étrange de que votre expérience provient de pythons capacité aux conditions de la chaîne. Car il trouve 0 n’est pas inférieure à 0, il décide de que l’expression entière a la valeur false. Dès que vous cela se défassent en conditions distinctes, vous modifiez la fonctionnalité. Il est stable au départ essentiellement qui votre relevé original de .

Un autre exemple :

Answer 4

<pre><code></code><p><code></code></p><pre><code></code></pre><p><code></code>qui prend la valeur True.</p><pre><code></code></pre><p><code></code>qui prend la valeur True.</p><pre><code></code></pre><p><code></code>comme indiqué ci-dessus, la valeur True.</p></pre>

Answer 5

En regardant le démontage (les octets de codes), il est évident pourquoi 0 < 0 == 0 est False.

Voici une analyse de cette expression:

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

Avis des lignes de 0-8: Ces lignes de vérifier si 0 < 0 qui renvoie évidemment False sur la pile de python.

Maintenant, remarquez la ligne 11: JUMP_IF_FALSE_OR_POP 23 Cela signifie que si 0 < 0 retours False d'exécuter un saut à la ligne 23.

Maintenant, 0 < 0 est False, de sorte que le saut est pris, ce qui laisse la pile avec un False qui est la valeur de retour de l'ensemble de l'expression 0 < 0 == 0, même si l' == 0 n'est même pas vérifié.

Donc, pour conclure, la réponse est, comme dit dans d'autres réponses à cette question. 0 < 0 == 0 a une signification particulière. Le compilateur évalue à deux conditions: 0 < 0 et 0 == 0. Comme avec n'importe quel des expressions booléennes complexes avec and entre eux, si le premier tombe en panne, le deuxième n'est même pas vérifié.

Espérant que cela vous éclaire un peu les choses, et j'espère vraiment que la méthode que j'ai utilisé pour analyser ce comportement inattendu va encourager les autres à essayer la même chose dans l'avenir.