Adding a Method to an Existing Object Instance

Question

I ve read that it is possible to add a method to an existing object  i e   not in the class definition  in Python    I understand that it s not always good to do so  But how might one do this

User · Answer

This is actually an addon to the answer of "Jason Pratt"

Although Jasons answer works, it does only work if one wants to add a function to a class. It did not work for me when I tried to reload an already existing method from the .py source code file.

It took me for ages to find a workaround, but the trick seems simple... 1.st import the code from the source code file 2.nd force a reload 3.rd use types.FunctionType(...) to convert the imported and bound method to a function you can also pass on the current global variables, as the reloaded method would be in a different namespace 4.th now you can continue as suggested by "Jason Pratt" using the types.MethodType(...)

Example:

# this class resides inside ReloadCodeDemo.py
class A:
    def bar( self ):
        print "bar1"
        
    def reloadCode(self, methodName):
        ''' use this function to reload any function of class A'''
        import types
        import ReloadCodeDemo as ReloadMod # import the code as module
        reload (ReloadMod) # force a reload of the module
        myM = getattr(ReloadMod.A,methodName) #get reloaded Method
        myTempFunc = types.FunctionType(# convert the method to a simple function
                                myM.im_func.func_code, #the methods code
                                globals(), # globals to use
                                argdefs=myM.im_func.func_defaults # default values for variables if any
                                ) 
        myNewM = types.MethodType(myTempFunc,self,self.__class__) #convert the function to a method
        setattr(self,methodName,myNewM) # add the method to the function

if __name__ == '__main__':
    a = A()
    a.bar()
    # now change your code and save the file
    a.reloadCode('bar') # reloads the file
    a.bar() # now executes the reloaded code

User · Answer

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    get   Dotted lookups on functions call the   get   method of the function with the instance  binding the object to the method and thus creating a  quot bound method  quot  foo sample method   sample method   get   foo   and now   gt  gt  gt  foo sample method 1 2  3  Method one - types MethodType First  import types  from which we ll get the method constructor  import types  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   and usage   gt  gt  gt  foo sample method 1 2  3  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  usage   gt  gt  gt  foo sample method   bind foo  sample method       gt  gt  gt  foo sample method 1 2  3  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   gt  gt  gt  from functools import partial  gt  gt  gt  foo sample method   partial sample method  foo   gt  gt  gt  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   gt  gt  gt  foo sample method   sample method  gt  gt  gt  foo sample method 1 2  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  sample method   takes exactly 3 arguments  2 given   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    gt  gt  gt  foo sample method foo  1  2  3  Conclusion You now know several ways you could do this  but in all seriousness - don t do this

User · Answer

In Python  there is a difference between functions and bound methods   gt  gt  gt  def foo            print  quot foo quot       gt  gt  gt  class A          def bar  self                print  quot bar quot       gt  gt  gt  a   A    gt  gt  gt  foo  lt function foo at 0x00A98D70 gt   gt  gt  gt  a bar  lt bound method A bar of  lt   main   A instance at 0x00A9BC88 gt  gt   gt  gt  gt   Bound methods have been  quot bound quot   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   gt  gt  gt  def fooFighters  self            print  quot fooFighters quot       gt  gt  gt  A fooFighters   fooFighters  gt  gt  gt  a2   A    gt  gt  gt  a2 fooFighters  lt bound method A fooFighters of  lt   main   A instance at 0x00A9BEB8 gt  gt   gt  gt  gt  a2 fooFighters   fooFighters  Previously defined instances are updated as well  as long as they haven t overridden the attribute themselves    gt  gt  gt  a fooFighters   fooFighters  The problem comes when you want to attach a method to a single instance   gt  gt  gt  def barFighters  self            print  quot barFighters quot       gt  gt  gt  a barFighters   barFighters  gt  gt  gt  a barFighters   Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  barFighters   takes exactly 1 argument  0 given   The function is not automatically bound when it s attached directly to an instance   gt  gt  gt  a barFighters  lt function barFighters at 0x00A98EF0 gt   To bind it  we can use the MethodType function in the types module   gt  gt  gt  import types  gt  gt  gt  a barFighters   types MethodType  barFighters  a    gt  gt  gt  a barFighters  lt bound method   barFighters of  lt   main   A instance at 0x00A9BC88 gt  gt   gt  gt  gt  a barFighters   barFighters  This time other instances of the class have not been affected   gt  gt  gt  a2 barFighters   Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError  A instance has no attribute  barFighters   More information can be found by reading about descriptors and metaclass programming

User · Answer

If it can be of any help  I recently released a Python library named Gorilla to make the process of monkey patching more convenient   Using a function needle   to patch a module named guineapig goes as follows   import gorilla import guineapig  gorilla patch guineapig  def needle        print  awesome     But it also takes care of more interesting use cases as shown in the FAQ from the documentation   The code is available on GitHub

User · Answer

I think that the above answers missed the key point    Let s have a class with a method   class A object       def m self           pass   Now  let s play with it in ipython   In  2   A m Out 2    lt unbound method A m gt    Ok  so m   somehow becomes an unbound method of A  But is it really like that   In  5   A   dict    m   Out 5    lt function m at 0xa66b8b4 gt    It turns out that m   is just a function  reference to which is added to A class dictionary - there s no magic  Then why A m gives us an unbound method  It s because the dot is not translated to a simple dictionary lookup  It s de facto a call of A   class     getattribute   A   m     In  11   class MetaA type                def   getattribute   self  attr name                    print str self    -   attr name  In  12   class A object                  metaclass     MetaA  In  23   A m  lt class    main   A  gt  - m  lt class    main   A  gt  - m   Now  I m not sure out of the top of my head why the last line is printed twice  but still it s clear what s going on there   Now  what the default   getattribute   does is that it checks if the attribute is a so-called descriptor or not  i e  if it implements a special   get   method  If it implements that method  then what is returned is the result of calling that   get   method  Going back to the first version of our A class  this is what we have   In  28   A   dict    m     get   None  A  Out 28    lt unbound method A m gt    And because Python functions implement the descriptor protocol  if they are called on behalf of an object  they bind themselves to that object in their   get   method   Ok  so how to add a method to an existing object  Assuming you don t mind patching class  it s as simple as   B m   m   Then B m  becomes  an unbound method  thanks to the descriptor magic   And if you want to add a method just to a single object  then you have to emulate the machinery yourself  by using types MethodType   b m   types MethodType m  b    By the way   In  2   A m Out 2    lt unbound method A m gt   In  59   type A m  Out 59    lt type  instancemethod  gt   In  60   type b m  Out 60    lt type  instancemethod  gt   In  61   types MethodType Out 61    lt type  instancemethod  gt

User · Answer

Consolidating Jason Pratt s and the community wiki answers  with a look at the results of different methods of binding   Especially note how adding the binding function as a class method works  but the referencing scope is incorrect      usr bin python -u import types import inspect     dynamically adding methods to a unique instance of a class     get a list of a class s method type attributes def listattr c       for m in   n  v  for n  v in inspect getmembers c  inspect ismethod  if isinstance v types MethodType            print m 0   m 1     externally bind a function as a method of an instance of a class def ADDMETHOD c  method  name       c   dict   name    types MethodType method  c   class C        r   10   class attribute variable to test bound scope      def   init   self           pass       internally bind a function as a method of self s class -- note that this one has issues      def addmethod self  method  name           self   dict   name    types MethodType  method  self   class            predfined function to compare with     def f0 self  x           print  f0 tx    d tr    d      x  self r   a   C     created before modified instnace b   C     modified instnace   def f1 self  x     bind internally     print  f1 tx    d tr    d      x  self r   def f2  self  x     add to class instance s    dict   as method type     print  f2 tx    d tr    d      x  self r   def f3  self  x     assign to class as method type     print  f3 tx    d tr    d      x  self r   def f4  self  x     add to class instance s    dict   using a general function     print  f4 tx    d tr    d      x  self r     b addmethod f1   f1   b   dict    f2     types MethodType  f2  b  b f3   types MethodType  f3  b  ADDMETHOD b  f4   f4     b f0 0    OUT  f0   x   0   r   10 b f1 1    OUT  f1   x   1   r   10 b f2 2    OUT  f2   x   2   r   10 b f3 3    OUT  f3   x   3   r   10 b f4 4    OUT  f4   x   4   r   10   k   2 print  changing b r from  0  to  1   format b r  k  b r   k print  new b r    0   format b r   b f0 0    OUT  f0   x   0   r   2 b f1 1    OUT  f1   x   1   r   10            b f2 2    OUT  f2   x   2   r   2 b f3 3    OUT  f3   x   3   r   2 b f4 4    OUT  f4   x   4   r   2  c   C     created after modifying instance    let s have a look at each instance s method type attributes print   nattributes of a   listattr a    OUT    attributes of a      init    lt bound method C   init   of  lt   main   C instance at 0x000000000230FD88 gt  gt    addmethod  lt bound method C addmethod of  lt   main   C instance at 0x000000000230FD88 gt  gt    f0  lt bound method C f0 of  lt   main   C instance at 0x000000000230FD88 gt  gt   print   nattributes of b   listattr b    OUT    attributes of b      init    lt bound method C   init   of  lt   main   C instance at 0x000000000230FE08 gt  gt    addmethod  lt bound method C addmethod of  lt   main   C instance at 0x000000000230FE08 gt  gt    f0  lt bound method C f0 of  lt   main   C instance at 0x000000000230FE08 gt  gt    f1  lt bound method   f1 of  lt class   main   C at 0x000000000237AB28 gt  gt    f2  lt bound method   f2 of  lt   main   C instance at 0x000000000230FE08 gt  gt    f3  lt bound method   f3 of  lt   main   C instance at 0x000000000230FE08 gt  gt    f4  lt bound method   f4 of  lt   main   C instance at 0x000000000230FE08 gt  gt   print   nattributes of c   listattr c    OUT    attributes of c      init    lt bound method C   init   of  lt   main   C instance at 0x0000000002313108 gt  gt    addmethod  lt bound method C addmethod of  lt   main   C instance at 0x0000000002313108 gt  gt    f0  lt bound method C f0 of  lt   main   C instance at 0x0000000002313108 gt  gt    Personally  I prefer the external ADDMETHOD function route  as it allows me to dynamically assign new method names within an iterator as well   def y self  x       pass d   C   for i in range 1 5       ADDMETHOD d  y   f d    i  print   nattributes of d   listattr d    OUT    attributes of d      init    lt bound method C   init   of  lt   main   C instance at 0x0000000002303508 gt  gt    addmethod  lt bound method C addmethod of  lt   main   C instance at 0x0000000002303508 gt  gt    f0  lt bound method C f0 of  lt   main   C instance at 0x0000000002303508 gt  gt    f1  lt bound method   y of  lt   main   C instance at 0x0000000002303508 gt  gt    f2  lt bound method   y of  lt   main   C instance at 0x0000000002303508 gt  gt    f3  lt bound method   y of  lt   main   C instance at 0x0000000002303508 gt  gt    f4  lt bound method   y of  lt   main   C instance at 0x0000000002303508 gt  gt

User · Answer

I find it strange that nobody mentioned that all of the methods listed above creates a cycle reference between the added method and the instance  causing the object to be persistent till garbage collection  There was an old trick adding a descriptor by extending the class of the object   def addmethod obj  name  func       klass   obj   class       subclass   type klass   name     klass            setattr subclass  name  func      obj   class     subclass

User · Answer

Since this question asked for non-Python versions  here s JavaScript   a methodname   function      console log  Yay  a new method

User · Answer

What you re looking for is setattr I believe  Use this to set an attribute on an object    gt  gt  gt  def printme s   print repr s   gt  gt  gt  class A  pass  gt  gt  gt  setattr A  printme  printme   gt  gt  gt  a   A    gt  gt  gt  a printme     s becomes the implicit  self  variable  lt     main      A instance at 0xABCDEFG gt

User · Answer

from types import MethodType  def method self      print  hi     setattr  targetObj  method   name    MethodType method  targetObj  type method       With this  you can use the self pointer

User · Answer

This question was opened years ago  but hey  there s an easy way to simulate the binding of a function to a class instance using decorators   def binder  function  instance     copy of function   type  function   function func code        copy of function   bind to     instance   def bound function   args    kwargs       return copy of function  copy of function   bind to     args    kwargs    return bound function   class SupaClass  object     def   init    self       self supaAttribute   42   def new method  self     print self supaAttribute   supaInstance   SupaClass    supaInstance supMethod   binder  new method  supaInstance   otherInstance   SupaClass    otherInstance supaAttribute   72 otherInstance supMethod   binder  new method  otherInstance   otherInstance supMethod    supaInstance supMethod      There  when you pass the function and the instance to the binder decorator  it will create a new function  with the same code object as the first one  Then  the given instance of the class is stored in an attribute of the newly created function  The decorator return a  third  function calling automatically the copied function  giving the instance as the first parameter        In conclusion you get a function simulating it s binding to the class instance  Letting the original function unchanged

User · Answer

There are at least two ways for attach a method to an instance without types MethodType    gt  gt  gt  class A       def m self         print  im m  invoked with     self   gt  gt  gt  a   A    gt  gt  gt  a m   im m  invoked with    lt   main   A instance at 0x973ec6c gt   gt  gt  gt  a m  lt bound method A m of  lt   main   A instance at 0x973ec6c gt  gt   gt  gt  gt    gt  gt  gt  def foo firstargument        print  im foo  invoked with     firstargument   gt  gt  gt  foo  lt function foo at 0x978548c gt    1    gt  gt  gt  a foo   foo   get   a  A    or foo   get   a  type a    gt  gt  gt  a foo   im foo  invoked with    lt   main   A instance at 0x973ec6c gt   gt  gt  gt  a foo  lt bound method A foo of  lt   main   A instance at 0x973ec6c gt  gt    2    gt  gt  gt  instancemethod   type A m   gt  gt  gt  instancemethod  lt type  instancemethod  gt   gt  gt  gt  a foo2   instancemethod foo  a  type a    gt  gt  gt  a foo2   im foo  invoked with    lt   main   A instance at 0x973ec6c gt   gt  gt  gt  a foo2  lt bound method instance foo of  lt   main   A instance at 0x973ec6c gt  gt    Useful links  Data model - invoking descriptors Descriptor HowTo Guide - invoking descriptors

User · Answer

You can use lambda to bind a method to an instance   def run self       print self  instanceString  class A object       def   init   self           self  instanceString    This is instance string   a   A   a run   lambda  run a  a run     Output   This is instance string

User · Answer

In Python monkeypatching generally works by overwriting a class or function s signature with your own  Below is an example from the Zope Wiki  from SomeOtherProduct SomeModule import SomeClass def speak self      return  quot ook ook eee eee eee  quot  SomeClass speak   speak  This code will overwrite create a method called peak in the class  In Jeff Atwood s recent post on monkey patching  he showed an example in C  3 0 which is the current language I use for work

User · Answer

Module new is deprecated since python 2 6 and removed in 3 0  use types  see http   docs python org library new html  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 types  class A object   but seems to work for old style objects too     pass  def patch me target       def method target x           print  x   x         print  called from   target     target method   types MethodType method target       add more if needed  a   A   print a  out   lt   main   A object at 0x2b73ac88bfd0 gt    patch me a      patch instance a method 5   out  x  5  out  called from  lt   main   A object at 0x2b73ac88bfd0 gt  patch me A  A method 6          can patch class too  out  x  6  out  called from  lt class    main   A  gt

User · Answer

What Jason Pratt posted is correct    gt  gt  gt  class Test object         def a self           pass       gt  gt  gt  def b self         pass       gt  gt  gt  Test b   b  gt  gt  gt  type b   lt type  function  gt   gt  gt  gt  type Test a   lt type  instancemethod  gt   gt  gt  gt  type Test b   lt type  instancemethod  gt    As you can see  Python doesn t consider b   any different than a    In Python all methods are just variables that happen to be functions

User · Answer

Apart from what others said  I found that   repr   and   str   methods can t be monkeypatched on object level  because repr   and str   use class-methods  not locally-bounded object methods    Instance monkeypatch  ins  In  55   x   str     show   get   x                                                                     ins  In  56   x                                                                                            Out 56    lt   main   X at 0x7fc207180c10 gt    ins  In  57   str x                                                                                        Out 57     lt   main   X object at 0x7fc207180c10 gt     ins  In  58   x   str                                                                                      Nice object     Class monkeypatch  ins  In  62   X   str     lambda     quot From class quot                                                              ins  In  63   str x                                                                                        Out 63    From class

[python] Adding a Method to an Existing Object Instance

This is actually an addon to the answer of "Jason Pratt"

Examples related to python

Examples related to oop

Examples related to methods

Examples related to monkeypatching