How do you check whether a python method is bound or not?

Question

Given a reference to a method, is there a way to check whether the method is bound to an object or not? Can you also access the instance that it's bound to?

score 48 · Accepted Answer · edited Mar 27 '22 at 22:43

def isbound(method):
    return method.im_self is not None
    
def instance(bounded_method):
    return bounded_method.im_self

User-defined methods:

When a user-defined method object is created by retrieving a user-defined function object from a class, its im_self attribute is None and the method object is said to be unbound. When one is created by retrieving a user-defined function object from a class via one of its instances, its im_self attribute is the instance, and the method object is said to be bound. In either case, the new method's im_class attribute is the class from which the retrieval takes place, and its im_func attribute is the original function object.

In Python 2.6 and 3.0:

Instance method objects have new attributes for the object and function comprising the method; the new synonym for im_self is __self__, and im_func is also available as __func__. The old names are still supported in Python 2.6, but are gone in 3.0.

score 28 · Answer 2 · answered Sep 23 '13 at 09:03

28

In python 3 the __self__ attribute is only set on bound methods. It's not set to None on plain functions (or unbound methods, which are just plain functions in python 3).

Use something like this:

def is_bound(m):
    return hasattr(m, '__self__')

answered Sep 23 '13 at 09:03

Rob Agar

12,337
5
48
63

There are plain functions that have the `__self__` attribute set, e.g. the built-in function `sum`. – kadee Oct 04 '22 at 13:36

score 15 · Answer 3 · answered Apr 28 '18 at 08:39

15

The chosen answer is valid in almost all cases. However when checking if a method is bound in a decorator using chosen answer, the check will fail. Consider this example decorator and method:

def my_decorator(*decorator_args, **decorator_kwargs):
    def decorate(f):
        print(hasattr(f, '__self__'))
        @wraps(f)
        def wrap(*args, **kwargs):
            return f(*args, **kwargs)
        return wrap
    return decorate

class test_class(object):
    @my_decorator()
    def test_method(self, *some_params):
        pass

The print statement in decorator will print False. In this case I can't find any other way but to check function parameters using their argument names and look for one named self. This is also not guarantied to work flawlessly because the first argument of a method is not forced to be named self and can have any other name.

import inspect

def is_bounded(function):
    params = inspect.signature(function).parameters
    return params.get('self', None) is not None

answered Apr 28 '18 at 08:39

Klaus

2,460
1
21
23

2

Well `f` is never actually bound to `test_class` which is the complication here. Even `decorate` is not bound either (you can verify by checking test_class.test_method != decorate). A bound method is created from `decorate` and *that* is what is attached to `test_class`. What you are really trying to find is whether a bound method has been created from a specific function. I'm not sure if that is possible – Azmisov Sep 24 '20 at 15:52
I think this is the only way to know if the given function expects to receive the insance or or not. – Anr Jan 18 '22 at 10:45
1

import inspect; expectself = next(iter(inspect.signature(function))) == 'self' – Anr Jan 18 '22 at 10:59
I agree that this is impossible. I've attempted through [this method](https://stackoverflow.com/a/25959545/308451) and even [this](https://stackoverflow.com/a/54316392/308451). The latter _almost_ works, until a second (unrelated) decorator is added before your decorator. The next best thing I can come up with truly is simply checking for `"self"` (and/or `"cls"`)... – JBSnorro Aug 13 '22 at 06:25
1

What happens here is that functions in classes are normal, unbound. When creating an instance (when ``__new__`` is called), bound methods are created for those functions and populate new instance. So, there is no way that a normal function in class is bound, because it isn't and decorators are "applied" just after function creation (and therefore before class creation), so there isn't even any object that such function could be applied to. ``@classmethod`` uses a trick named "```__get__``` magic method". – oBrstisf8o Jan 17 '23 at 21:08

score 4 · Answer 4 · edited Aug 07 '17 at 18:26

4

im_self attribute (only Python 2)

edited Aug 07 '17 at 18:26

Никита Конин

135
2
9

answered Sep 10 '08 at 00:42

Mark Cidade

98,437
31
224
236

1

Link is broken. – jjmontes Jun 29 '17 at 21:27

score 0 · Answer 5 · answered Dec 13 '20 at 14:26

A solution that works for both Python 2 and 3 is tricky.

Using the package six, one solution could be:

def is_bound_method(f):
    """Whether f is a bound method"""
    try:
        return six.get_method_self(f) is not None
    except AttributeError:
        return False

In Python 2:

A regular function won't have the im_self attribute so six.get_method_self() will raise an AttributeError and this will return False
An unbound method will have the im_self attribute set to None so this will return False
An bound method will have the im_self attribute set to non-None so this will return True

In Python 3:

A regular function won't have the __self__ attribute so six.get_method_self() will raise an AttributeError and this will return False
An unbound method is the same as a regular function so this will return False
An bound method will have the __self__ attribute set (to non-None) so this will return True

How do you check whether a python method is bound or not?

5 Answers5

Linked