I believe attached script demonstrates a bug in Python 3000.  As far as
I can tell, it should print four times 'True'.

Odd. I'll look into it.

Additional prints make it easy to understand what happens here:

>>> class Anything:
...     def __eq__(self, other):
...         print("eq")
...         return True
...     def __ne__(self, other):
...         print("ne")
...         return False
...
>>> x = lambda: None
>>> print(x == Anything())
False
>>> print(Anything() == x)
eq
True
>>> y = object()
>>> print(y == Anything())
eq
True
>>> print(Anything() == y)
eq
True

x == Anything() doesn't invoke Anything.__eq__(). It's using
function.__eq__().

It's still odd though.  Why does object() == Anything() pass control to
the right hand side, while (lambda: None) == Anything() doesn't? 
There's no definition of equality in PyFunction_Type, so it would seem
to fall back on the definition in PyBaseObject_Type, which I would
expect to return False from the code in object_richcompare()...

[...gdb...]

OK, here's the solution of the mystery.  do_richcompare() ends up taking
the swapped code path for object() == Anything(), but not for function
objects.  This is because Anything() is a subclass of object, but not of
<function>.

Perhaps the solution is to change object_richcompare() to return
NotImplemented instead of returning False?  Or perhaps even remove
object_richcompare() altogether, since it doesn't do anything that
do_richcompare() doesn't know how to do...

I'd like to ping this issue as I think it is important enough (core is
affected).

That solution (return NotImplemented instead of False) appears to work.
Committed revision 59761.

Thanks for bringing up this regression w.r.t. 2.5!