Python si non == vs si !=

Quelle est la différence entre ces deux lignes de code:

if not x == 'val':

if x != 'val':

Est un plus efficace que l'autre?

Il serait mieux d'utiliser

if x == 'val':
    pass
else:

Le mieux est celui que vous pouvez lire, je doute de votre programme de goulot d'étranglement sera ici
Cette question m'intéresse dans le "x n'est pas dans la liste" et "pas de x dans la liste des" cas
ils sont interprétés de la même manière.
référence à mon commentaire ci-dessus: stackoverflow.com/q/8738388/3001761
votre lien est sur le sous-chaînes. J'ai pensé à des collections(liste/dict/set). De toute façon - sens, merci!
c'est la même chose pour ceux qui, trop; c'est la façon dont la syntaxe est interprété, il n'a pas d'importance ce que les deux opérandes sont.
Le not x == 'val' est un peu plus lent pour être analysé que la x != 'val', mais la différence de temps est au-delà de la mesure. Le réel le temps d'exécution est égal.

InformationsquelleAutor lafferc | 2015-06-24

219

À l'aide de dis de regarder le bytecode généré pour les deux versions:

not ==
```
  4           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               2 (==)
              9 UNARY_NOT           
             10 RETURN_VALUE   
```
!=
```
  4           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               3 (!=)
              9 RETURN_VALUE   
```
Le dernier a moins d'opérations, et est donc susceptible d'être légèrement plus efficace.

Il a été souligné dans le commments (merci, @Quinconce) que si vous avez if foo != bar vs if not foo == bar le nombre d'opérations est exactement la même chose, c'est juste que le COMPARE_OP changements et POP_JUMP_IF_TRUE commutateurs à POP_JUMP_IF_FALSE:

not ==:
```
  2           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               2 (==)
              9 POP_JUMP_IF_TRUE        16
```
!=
```
  2           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               3 (!=)
              9 POP_JUMP_IF_FALSE       16
```
Dans ce cas, sauf s'il y a une différence dans la quantité de travail nécessaire pour chaque comparaison, il est peu probable que vous verriez aucune différence de performances à tous.

Cependant, noter que les deux versions ne sera pas toujours logiquement identiques, car cela dépendra de la mise en œuvre de __eq__ et __ne__ pour les objets en question. Par le modèle de données de la documentation:

Il n'y a pas implicite des relations entre les opérateurs de comparaison. L'
la vérité de x==y n'implique pas que x!=y est faux.

Par exemple:
```
>>> class Dummy(object):
    def __eq__(self, other):
        return True
    def __ne__(self, other):
        return True


>>> not Dummy() == Dummy()
False
>>> Dummy() != Dummy()
True
```
Enfin, et peut-être le plus important: en général, où les deux sont logiquement identiques, x != y est beaucoup plus lisible que not x == y.
- Dans la pratique, toute la classe qui a __eq__ incompatible avec __ne__ est flat-out cassé.
- Veuillez noter qu'il n'est pas toujours vrai que not x == y a un plus d'instruction. Quand j'ai mis le code dans un if, il s'est avéré qu'ils ont le même nombre d'instructions, un seul avait POP_JUMP_IF_TRUE et les autres POP_JUMP_IF_FALSE (c'était la seule différence entre eux, autres que l'aide d'un autre COMPARE_OP). Lorsque j'ai compilé le code sans les ifs, j'ai obtenu ce que vous avez obtenu.
- Un autre exemple où == et != ne sont pas mutuellement exclusives est un type SQL de mise en œuvre impliquant null valeurs. Dans SQL null ne retourne pas true à != par rapport à toute autre valeur, de sorte python implémentations de SQL interfaces peuvent également avoir le même problème.
- Je commence à souhait, je n'avais pas évoqué l'éventuelle différence entre not == et !=, il semble être la partie la plus intéressante de ma réponse! Je ne pense pas que c'est le lieu de s'attarder sur si, pourquoi et quand cela a du sens (voir par exemple Pourquoi Python ont une __ne__ opérateur méthode au lieu de simplement __eq__?
InformationsquelleAutor jonrsharpe
29

@jonrsharpe a une excellente explication de ce qui se passe. Je pensais que je venais de montrer les différences de temps lors de l'exécution de chacune des 3 options 10 000 000 de fois (assez pour une légère différence à montrer).

Code utilisé:
```
def a(x):
    if x != 'val':
        pass


def b(x):
    if not x == 'val':
        pass


def c(x):
    if x == 'val':
        pass
    else:
        pass


x = 1
for i in range(10000000):
    a(x)
    b(x)
    c(x)
```
Et la cProfile profiler résultats:

Ainsi, nous pouvons voir qu'il y a une très infime différence de ~de 0,7% entre if not x == 'val': et if x != 'val':. De ces, if x != 'val': est le plus rapide.

Cependant, le plus surprenant, nous pouvons voir que
```
if x == 'val':
    pass
else:
```
est en fait la manière la plus rapide et beats if x != 'val': par ~0.3%. Ce n'est pas très lisible, mais je suppose que si vous vouliez négligeable d'amélioration de la performance, on pourrait aller dans cette voie.
- J'espère que tout le monde ne sait pas loi sur cette information! Rendre illisible les changements de 0,3% d'amélioration, ou même d'une amélioration de 10% -- est rarement une bonne idée, et cette amélioration est très susceptible d'être évanescent (et pas dans un bon moyen: très légères modifications dans l'exécution Python pourrait éliminer ou même annuler tout gain.
- En outre, il existe les différentes implémentations de Python.
InformationsquelleAutor Red Shift
6

Dans la première Python a l'exécution d'un plus grand nombre d'opérations que nécessaire(au lieu de vérifier simplement pas égale à elle a vérifier si il n'est pas vrai que c'est égal, donc encore une opération). Il serait impossible de faire la différence entre une exécution, mais si elle est exécutée plusieurs fois, la deuxième serait plus efficace. Globalement, je dirais utiliser la seconde, mais mathématiquement, ils sont de la même

InformationsquelleAutor JediPythonClone

>>> from dis import dis
>>> dis(compile('not 10 == 20', '', 'exec'))
  1           0 LOAD_CONST               0 (10)
              3 LOAD_CONST               1 (20)
              6 COMPARE_OP               2 (==)
              9 UNARY_NOT
             10 POP_TOP
             11 LOAD_CONST               2 (None)
             14 RETURN_VALUE
>>> dis(compile('10 != 20', '', 'exec'))
  1           0 LOAD_CONST               0 (10)
              3 LOAD_CONST               1 (20)
              6 COMPARE_OP               3 (!=)
              9 POP_TOP
             10 LOAD_CONST               2 (None)
             13 RETURN_VALUE

Ici, vous pouvez voir que not x == y a un plus d'instruction que x != y. Donc, la différence de performance sera très faible dans la plupart des cas, sauf si vous faites de millions de comparaisons et même alors, ce ne sera probablement pas être la cause d'un goulot d'étranglement.

InformationsquelleAutor kylie.a

5

Une note supplémentaire, puisque les autres réponses répondu à votre question, la plupart du temps correctement, c'est que si une classe ne définit __eq__() et pas __ne__(), alors votre COMPARE_OP (!=) sera exécuté __eq__() et le nier. A l'époque, la troisième option est susceptible d'être un tout petit peu plus efficace, mais doit être considérée uniquement si vous avez BESOIN de la vitesse, car il est difficile de comprendre rapidement.

InformationsquelleAutor Jacob Zimmerman
3

Il est de votre façon de lire. not opérateur est dynamique, c'est pourquoi vous êtes en mesure de l'appliquer dans
```
if not x == 'val':
```
Mais != on pouvait lire dans un meilleur contexte comme un opérateur qui fait le contraire de ce que == n'.
- Que voulez-vous dire "not opérateur est dynamique"?
- Je pense qu'il veut dire que les "x" va appeler x.__bool__() [python 3 -- python 2 utilise différente de zéro] et retourne le résultat (voir docs.python.org/3/reference/datamodel.html#object.__bool__)
InformationsquelleAutor Himanshu Mishra
1

Je veux développer mon lisibilité commentaire ci-dessus.

Encore une fois, je suis entièrement d'accord avec la lisibilité annuler les autres (performance-négligeable) des préoccupations.

Ce que je voudrais souligner est que le cerveau interprète "positif" plus vite qu'il n'est "négatif". E. g., "stop" et de "ne pas aller" (plutôt moche exemple en raison de la différence en nombre de mots).

Donc, étant donné un choix:
```
if a == b
    (do this)
else
    (do that)
```
est préférable à la fonctionnellement équivalent:
```
if a != b
    (do that)
else
    (do this)
```
Moins de lisibilité/compréhension conduit à plus de bugs. Peut-être pas dans les premières de codage, mais l' (pas aussi intelligent que vous!) l'entretien des changements...
- le cerveau interprète "positif" plus vite qu'il ne "négatif" est-ce de l'expérience ou avez-vous lu des études à ce sujet ? Je demande seulement parce que, selon le code de l'en (faire) ou (faire), j'ai trouver un != b plus facile à comprendre.
InformationsquelleAutor Alan Jay Weiner

Vous devez vous connecter pour publier un commentaire.