Cfrtjryk

If you execute the following statement in Python 3.7, it will (from my testing) print b:

if None.__eq__("a"):

    print("b")

However, None.__eq__("a") evaluates to NotImplemented.

Naturally, "a".__eq__("a") evaluates to True, and "b".__eq__("a") evaluates to False.

I initially discovered this when testing the return value of a function, but didn't return anything in the second case -- so, the function returned None.

What's going on here?

This is a great example of why the __dunder__ methods should not be used directly as they are quite often not appropriate replacements for their equivalent operators; in this case you should use the == operator instead. You've done

None.__eq__('a')

# NotImplemented

Which returns NotImplemented since the types being compared are different. Try comparing any two objects with different types like this (ex (1).__eq__('a')). The right way to do this would be

None == 'a'

# False

What happens here is

1. First, None.__eq__('a') is tried, which returns NotImplemented. This indicates that the operation is not supported, so


2. 
   'a'.__eq__(None) is called, which also returns the same NotImplemented. So,


3. The objects are treated as if they are not the same, and False is returned.

Here's a nice little MCVE to illustrate how this happens:

class A:

    def __eq__(self, other):

        print('A.__eq__')

        return NotImplemented



class B:

    def __eq__(self, other):

        print('B.__eq__')

        return NotImplemented



class C:

    def __eq__(self, other):

        print('C.__eq__')

        return True



a = A()

b = B()

c = C()



print(a == b)

# A.__eq__

# B.__eq__

# False



print(a == c)

# A.__eq__

# C.__eq__

# True



print(c == a)

# C.__eq__

# True

Of course, that doesn't explain why the operation returns true. This is because NotImplemented is actually a truthy value:

bool(None.__eq__("a"))

# True

Same as,

bool(NotImplemented)

# True

For more information on what values are considered truthy and falsey, see the docs section on Truth Value Testing, as well as this answer.

If you want the functional equivalent of the == operator, use operator.eq:

import operator

operator.eq(None, 'a')

# False

The result you are seeing is documented

https://docs.python.org/3/library/constants.html

Special value which should be returned by the binary special methods (e.g. eq(), lt(), add(), rsub(), etc.) to indicate that the operation is not implemented with respect to the other type; may be returned by the in-place binary special methods (e.g. imul(), iand(), etc.) for the same purpose. Its truth value is true.

If you call the __eq()__ method manually you need to be prepared to deal with the possibility it may return NotImplemented and that its truth value is true.

As you already figured None.__eq__("a") evaluates to NotImplemented however if you try something like

if NotImplemented:

    print("Yes")

else:

    print("No")

the result is

yes

this mean that NotImplemented.__bool__() returns True

Therefor the outcome of the question is obvious:

None.__eq__(something) yields NotImplemented

And bool(NotImplemented) evaluates to True

So if None.__eq__("a") is always True