Python unable to compare bound method to itself

Question

I am attempting to write a test that checks if a variable holding the bound method of a class is the same as another reference to that method. Normally this is not a problem, but it does not appear to work when done within another method of the same class. Here is a minimal example:

class TestClass:
    def sample_method(self):
        pass
    def test_method(self, method_reference):
        print(method_reference is self.sample_method)

I am really using an assert instead of print, but that is neither here nor there since the end result is the same. The test is run as follows:

instance = TestClass()
instance.test_method(instance.sample_method)

The result is False even though I am expecting it to be True. The issue manifests itself in both Python 3.5 and Python 2.7 (running under Anaconda).

I understand that bound methods are closures that are acquired by doing something like TestClass.test_method.__get__(instance, type(instance)). However, I would expect that self.sample_method is already a reference to such a closure, so that self.sample_method and instance.sample_method represent the same reference.

Part of what is confusing me here is the output of the real pytest test that I am running (working on a PR for matplotlib):

assert <bound method TestTransformFormatter.transform1 of <matplotlib.tests.test_ticker.TestTransformFormatter object at 0x7f0101077b70>> is <bound method TestTransformFormatter.transform1 of <matplotlib.tests.test_ticker.TestTransformFormatter object at 0x7f0101077b70>>
E        +  where <bound method TestTransformFormatter.transform1 of <matplotlib.tests.test_ticker.TestTransformFormatter object at 0x7f0101077b70>> = <matplotlib.ticker.TransformFormatter object at 0x7f0101077e10>.transform
E        +  and   <bound method TestTransformFormatter.transform1 of <matplotlib.tests.test_ticker.TestTransformFormatter object at 0x7f0101077b70>> = <matplotlib.tests.test_ticker.TestTransformFormatter object at 0x7f0101077b70>.transform1

If I understand the output correctly, the actual comparison (the first line) is really comparing the same objects, but somehow turning up False. The only thing I can imagine at this point is that __get__ is in fact being called twice, but I know neither why/where/how, nor how to work around it.

That's completely expected. Not all `instance.sample_method`s are the same object, just like not all `5024`s are the same object. — user2357112, Jan 27 '17 at 18:29
@user2357112. That makes some sense. My question, which I have hopefully clarified now, is where are the different objects actually being created? — Mad Physicist, Jan 27 '17 at 18:33
Once for `instance.sample_method`, and once for `self.sample_method` inside `test_method`. — user2357112, Jan 27 '17 at 18:33
That too makes sense. Does that mean that the syntax `obj.attr` automatically calls `__get__` on `attr`? — Mad Physicist, Jan 27 '17 at 18:36
Awesome. I need to reread those docs. It's starting so sound familiar now. — Mad Physicist, Jan 27 '17 at 18:39

1'' · Accepted Answer · 2017-01-27T18:41:27.903

6

They're not the same reference - the objects representing the two methods occupy different locations in memory:

>>> class TestClass:
...     def sample_method(self):
...         pass
...     def test_method(self, method_reference):
...         print(hex(id(method_reference)))
...         print(hex(id(self.sample_method)))
... 
>>> instance = TestClass()
>>> instance.test_method(instance.sample_method)
0x7fed0cc561c8
0x7fed0cc4e688

Changing to method_reference == self.sample_method will make the assert pass, though.

Edit since question was expanded: seems like a flawed test - probably the actual functionality of the code does not require the references to be the same (is), just equal (==). So your change probably didn't break anything except for the test.

edited Jan 27 '17 at 18:41

answered Jan 27 '17 at 18:33

1''

26,823
32
143
200

Thanks for pointing out that `==` will work. I was afraid to use it because I know that unbound methods implement is as `is`, but it makes sense that bound methods could actually check if they are effectively the same. – Mad Physicist Jan 27 '17 at 18:39
The test is actually being written now. I had the right idea, just didn't know how to express it properly in code. – Mad Physicist Jan 27 '17 at 18:42
2

I did some more thorough testing, and it turns out `==` for methods is [really weird](http://stackoverflow.com/questions/18216597/how-should-functions-be-tested-for-equality-or-identity/18217024#18217024) and not sufficient to determine whether two method objects represent the same method of the same object. – user2357112 Jan 27 '17 at 19:33

score 4 · Answer 2 · answered Jan 27 '17 at 19:18

4

While the accepted answer is in no way incorrect, it seems like it should be noted that methods are bound on attribute lookup. Furthermore, the behavior of unbound methods changes between Python 2.X and Python 3.X.

class A:
    def method(self):
        pass

a = A()
print(a.method is a.method) # False

print(A.method is A.method) # Python 3.X: True, Python 2.X: False

answered Jan 27 '17 at 19:18

Jared Goguen

8,772
2
18
36

Could you add something about the mechanism of descriptors that comes into play here for posterity? – Mad Physicist Jan 27 '17 at 19:29
Also, why does the unbound method example return `False` in Py2? Would it work with `==` instead? – Mad Physicist Jan 27 '17 at 19:30

Python unable to compare bound method to itself

2 Answers2

Linked