Python if not == vs if !=

What is the difference between these two lines of code:

    if not x == 'val':

and

    if x != 'val':

Is one more efficient than the other?

Would it be better to use

    if x == 'val':
        pass
    else:

Using dis to look at the bytecode generated for the two 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

The latter has fewer operations, and is therefore likely to be slightly more efficient.

It was pointed out in the commments (thanks, @Quincunx) that where you have if foo != bar vs. if not foo == bar the number of operations is exactly the same, it's just that the COMPARE_OP changes and POP_JUMP_IF_TRUE switches to 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

In this case, unless there was a difference in the amount of work required for each comparison, it's unlikely you'd see any performance difference at all.

However, note that the two versions won't always be logically identical , as it will depend on the implementations of __eq__ and __ne__ for the objects in question. Per the data model documentation:

There are no implied relationships among the comparison operators. The truth of x==y does not imply that x!=y is false.

For example:

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


    >>> not Dummy() == Dummy()
    False
    >>> Dummy() != Dummy()
    True

Finally, and perhaps most importantly: in general, where the two are logically identical, x != y is much more readable than not x == y.

From: stackoverflow.com/q/31026754