Adding a Method to an Existing Object Instance
In Python, there is a difference between functions and bound methods.
def foo(): print "foo"...class A: def bar( self ): print "bar"... a = A() foo<function foo at 0x00A98D70> a.bar<bound method A.bar of <__main__.A instance at 0x00A9BC88>>>>>
Bound methods have been "bound" (how descriptive) to an instance, and that instance will be passed as the first argument whenever the method is called.
Callables that are attributes of a class (as opposed to an instance) are still unbound, though, so you can modify the class definition whenever you want:
def fooFighters( self ): print "fooFighters"... A.fooFighters = fooFighters a2 = A() a2.fooFighters<bound method A.fooFighters of <__main__.A instance at 0x00A9BEB8>> a2.fooFighters()fooFighters
Previously defined instances are updated as well (as long as they haven't overridden the attribute themselves):
The problem comes when you want to attach a method to a single instance:
def barFighters( self ): print "barFighters"... a.barFighters = barFighters a.barFighters()Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: barFighters() takes exactly 1 argument (0 given)
The function is not automatically bound when it's attached directly to an instance:
0x00A98EF0>a.barFighters<function barFighters at
To bind it, we can use the MethodType function in the types module:
import types a.barFighters = types.MethodType( barFighters, a ) a.barFighters<bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>> a.barFighters()barFighters
This time other instances of the class have not been affected:
"<stdin>", line 1, in <module>AttributeError: A instance has no attribute 'barFighters'a2.barFighters()Traceback (most recent call last): File
Preface - a note on compatibility: other answers may only work in Python 2 - this answer should work perfectly well in Python 2 and 3. If writing Python 3 only, you might leave out explicitly inheriting from
object, but otherwise the code should remain the same.
Adding a Method to an Existing Object Instance
I've read that it is possible to add a method to an existing object (e.g. not in the class definition) in Python.
I understand that it's not always a good decision to do so. But, how might one do this?
Yes, it is possible - But not recommended
I don't recommend this. This is a bad idea. Don't do it.
Here's a couple of reasons:
- You'll add a bound object to every instance you do this to. If you do this a lot, you'll probably waste a lot of memory. Bound methods are typically only created for the short duration of their call, and they then cease to exist when automatically garbage collected. If you do this manually, you'll have a name binding referencing the bound method - which will prevent its garbage collection on usage.
- Object instances of a given type generally have its methods on all objects of that type. If you add methods elsewhere, some instances will have those methods and others will not. Programmers will not expect this, and you risk violating the rule of least surprise.
- Since there are other really good reasons not to do this, you'll additionally give yourself a poor reputation if you do it.
Thus, I suggest that you not do this unless you have a really good reason. It is far better to define the correct method in the class definition or less preferably to monkey-patch the class directly, like this:
Foo.sample_method = sample_method
Since it's instructive, however, I'm going to show you some ways of doing this.
How it can be done
Here's some setup code. We need a class definition. It could be imported, but it really doesn't matter.
class Foo(object): '''An empty class to demonstrate adding a method to an instance'''
Create an instance:
foo = Foo()
Create a method to add to it:
def sample_method(self, bar, baz): print(bar + baz)
Method nought (0) - use the descriptor method,
Dotted lookups on functions call the
__get__ method of the function with the instance, binding the object to the method and thus creating a "bound method."
foo.sample_method = sample_method.__get__(foo)
Method one - types.MethodType
First, import types, from which we'll get the method constructor:
Now we add the method to the instance. To do this, we require the MethodType constructor from the
types module (which we imported above).
The argument signature for types.MethodType is
(function, instance, class):
foo.sample_method = types.MethodType(sample_method, foo, Foo)
Method two: lexical binding
First, we create a wrapper function that binds the method to the instance:
def bind(instance, method): def binding_scope_fn(*args, **kwargs): return method(instance, *args, **kwargs) return binding_scope_fn
1,2)3foo.sample_method = bind(foo, sample_method) foo.sample_method(
Method three: functools.partial
A partial function applies the first argument(s) to a function (and optionally keyword arguments), and can later be called with the remaining arguments (and overriding keyword arguments). Thus:
from functools import partial foo.sample_method = partial(sample_method, foo) foo.sample_method(1,2)3
This makes sense when you consider that bound methods are partial functions of the instance.
Unbound function as an object attribute - why this doesn't work:
If we try to add the sample_method in the same way as we might add it to the class, it is unbound from the instance, and doesn't take the implicit self as the first argument.
1,2)Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: sample_method() takes exactly 3 arguments (2 given)foo.sample_method = sample_method foo.sample_method(
We can make the unbound function work by explicitly passing the instance (or anything, since this method doesn't actually use the
self argument variable), but it would not be consistent with the expected signature of other instances (if we're monkey-patching this instance):
You now know several ways you could do this, but in all seriousness - don't do this.
Module new is deprecated since python 2.6 and removed in 3.0, use types
In the example below I've deliberately removed return value from
patch_me() function.I think that giving return value may make one believe that patch returns a new object, which is not true - it modifies the incoming one. Probably this can facilitate a more disciplined use of monkeypatching.
import typesclass A(object):#but seems to work for old style objects too passdef patch_me(target): def method(target,x): print "x=",x print "called from", target target.method = types.MethodType(method,target) #add more if neededa = A()print a#out: <__main__.A object at 0x2b73ac88bfd0> patch_me(a) #patch instancea.method(5)#out: x= 5#out: called from <__main__.A object at 0x2b73ac88bfd0>patch_me(A)A.method(6) #can patch class too#out: x= 6#out: called from <class '__main__.A'>