I came across a situation where it would be nice for a Python class to have a method which works for both the class and its instances, and when called in an instance context, to know on which instance it was invoked. Python does not support this directly, but as it is a very flexible language, it can be done. To make it work somewhat nicely requires just a few lines of not so obvious code.
To have Python call a method in the context of a class requires the use of the decorator @classmethod. You can call such a method for an instance as well, but the method is only passed the class as an argument, not the instance.
Here’s a an example:
|
1 2 3 4 5 6 7 |
class X: @classmethod def m(cls, *args, **kwargs): print('cls: {}'.format(cls)) print('self: {}'.format('NO SELF!')) print('args: {}'.format(args)) print('kwargs: {}'.format(kwargs)) |
The class has one classmethod which simply prints what it knows about the world around it. It knows the class and the arguments passed to it. When invoked on a class instance, it does not know which instance it was invoked on.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
In [2]: X.m('arg', kwarg='kwarg') cls: <class '__main__.X'> self: NO SELF! args: ('arg',) kwargs: {'kwarg': 'kwarg'} In [3]: x=X() In [4]: x.m('arg', kwarg='kwarg') cls: <class '__main__.X'> self: NO SELF! args: ('arg',) kwargs: {'kwarg': 'kwarg'} |
What I needed was to have self defined when invoked in an instance context. I solved it by injecting self into the classmethod when the class constructor is run at instantiation time. This requires a slight modification to the classmethod’s signature, and replacing the original classmethod with an instancemethod which takes both the class as a positional argument and the instance as a keyword argument. This is achieved nicely with a utility function called class2instancemethod:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from types import MethodType def class2instancemethod(method, self): """Converts a classmethod into an instancemethod""" def class2instance(*args, **kwargs): # Remove first positional arg which is self # and move it to kwargs return method(*(args[1:]), self=self, **kwargs) return MethodType(class2instance, self) class X: def __init__(self): self.m = class2instancemethod(self.m, self) @classmethod def m(cls, *args, self=None, **kwargs): print('cls: {}'.format(cls)) print('self: {}'.format(self)) print('args: {}'.format(args)) print('kwargs: {}'.format(kwargs)) |
There are four things to note here. The first one is the class2instancemethod utility function which takes a classmethod and a class instance as argument and returns an instancemethod which has class (“cls”) as the first positional parameter and instance (“self”) as a keyword argument.
The second interesting thing is the class constructor which calls our utility function at class instantiation time and replaces the original classmethod with our patched version.
The third interesting thing is the signature of the classmethod m:
|
1 2 |
@classmethod def m(cls, *args, self=None, **kwargs): |
Argument list now contains self as a keyword argument. When invoked in a class context, self will be None. When invoked in an instance context, self will receive the instance.
The fourth thing to note is the print line:
|
1 |
print('self: {}'.format(self)) |
We now have a self to print. Here’s what looks like now:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
In [6]: X.m('arg', kwarg='kwarg') cls: <class '__main__.X'> self: None args: ('arg',) kwargs: {'kwarg': 'kwarg'} In [7]: x=X() In [8]: x.m('arg', kwarg='kwarg') cls: <class '__main__.X'> self: <__main__.X object at 0x7f1fe54250b8> args: ('arg',) kwargs: {'kwarg': 'kwarg'} |
So now it is possible to have the classmethod know the instance when called in an instance context.
With this implementation we would have to patch every method in our constructor method, which is repetitive and error-prone.
We can improve the situation by making our own decorator for such methods, and a helper function which needs to be called just once in the constructor. Here’s the full code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
from types import MethodType def class2instancemethod(method, self): """Converts a classmethod into an instancemethod""" def class2instance(*args, **kwargs): # Remove first positional arg which is self # and move it to kwargs return method(*(args[1:]), self=self, **kwargs) return MethodType(class2instance, self) _c2im_attr = '_convert_to_instancemethod' def instancemethod(m): """Decorator for classmethods which should be converted to instancemethods in constructor. You must run make_instancemethods(self) in your constructor to actually make it happen. Eg: class X: @classmethod @instancemethod def m1(cls, *args, self=None, **kwargs): # - cls is always set # - self is set when invoked on an instance # - args & kwargs stay the same for both ways print('cls: {}'.format(cls)) print('self: {}'.format(self)) print('args: {}'.format(args)) print('kwargs: {}'.format(kwargs)) if self is not None: print('Called on instance {}'.format(self)) else: print('Called on class {}'.format(cls)) @instancemethod @classmethod def m2(cls, *args, self=None, **kwargs): print('self: {}'.format(self)) def __init__(self): # Changes all classmethods marked with # @instancemethod so that self is injected # as kwarg self.make_instancemethods(self) """ if type(m)!=classmethod: # Set flag setattr(m, _c2im_attr, True) else: # Dig out the original method and set flag there setattr(m.__func__, _c2im_attr, True) return m def make_instancemethods(self): """Takes all classmethods decorated with the @instancemethod decorator and injects self as a kwarg.""" c2im = [x for x in dir(self) if not x.startswith('__')] for m in c2im: method = getattr(self, m) if getattr(method, _c2im_attr, False): setattr(self, m, class2instancemethod(method, self)) |
And here’s an example on how to use it:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
class X: def __init__(self): make_instancemethods(self) @classmethod @instancemethod def m1(cls, *args, self=None, **kwargs): print('cls: {}'.format(cls)) print('self: {}'.format(self)) print('args: {}'.format(args)) print('kwargs: {}'.format(kwargs)) @instancemethod @classmethod def m2(cls, arg1=1, self=None): print('self: {}'.format(self)) print('arg1: {}'.format(arg1)) |
Example output:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
In [11]: X.m1('arg', kwarg='kwarg') cls: <class '__main__.X'> self: None args: ('arg',) kwargs: {'kwarg': 'kwarg'} In [12]: X.m2() self: None arg1: 1 In [13]: X.m2(2) self: None arg1: 2 In [14]: x=X() In [15]: x.m1('arg', kwarg='kwarg') cls: <class '__main__.X'> self: <__main__.X object at 0x7fcf7c9c5550> args: ('arg',) kwargs: {'kwarg': 'kwarg'} In [16]: x.m2() self: <__main__.X object at 0x7fcf7c9c5550> arg1: 1 In [17]: x.m2(2) self: <__main__.X object at 0x7fcf7c9c5550> arg1: 2 |
This makes it quite easy to have classmethods which are able to get the target object when invoked on an instance.
The only tricky thing is to have the arguments in the right order. The order should be this:
cls- any positional arguments
*args- any named keyword arguments you wish to be able to use also as positional ones (when not using *args)
self=None*kwargs
Only cls and self=None are required, the rest are optional.
As a final note I would like to point out that this has only been tested with Python 3.5.