python - Adding a Method to an Existing Object Instance


Translate

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?


Alle Antworten
  • Translate

    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):

    >>> a.fooFighters()
    fooFighters
    

    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:

    >>> a.barFighters
    <function barFighters at 0x00A98EF0>
    

    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:

    >>> a2.barFighters()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: A instance has no attribute 'barFighters'
    

    More information can be found by reading about descriptors and metaclass programming.


  • Translate

    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: <__main__.A object at 0x2b73ac88bfd0>  
    patch_me(a)    #patch instance
    a.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'>
    

  • Translate

    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 "bound method."

    foo.sample_method = sample_method.__get__(foo)
    

    and now:

    >>> 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:

    >>> 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:

    >>> foo.sample_method = bind(foo, sample_method)    
    >>> 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:

    >>> 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.

    >>> foo.sample_method = sample_method
    >>> foo.sample_method(1,2)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    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):

    >>> 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.


  • Translate

    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]: <unbound method A.m>
    

    Ok, so m() somehow becomes an unbound method of A. But is it really like that?

    In [5]: A.__dict__['m']
    Out[5]: <function m at 0xa66b8b4>
    

    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
    <class '__main__.A'> - m
    <class '__main__.A'> - 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]: <unbound method A.m>
    

    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]: <unbound method A.m>
    
    In [59]: type(A.m)
    Out[59]: <type 'instancemethod'>
    
    In [60]: type(b.m)
    Out[60]: <type 'instancemethod'>
    
    In [61]: types.MethodType
    Out[61]: <type 'instancemethod'>
    

  • Translate

    In Python monkey patching generally works by overwriting a class or functions signature with your own. Below is an example from the Zope Wiki:

    from SomeOtherProduct.SomeModule import SomeClass
    def speak(self):
       return "ook ook eee eee eee!"
    SomeClass.speak = speak
    

    That code will overwrite/create a method called speak on the class. In Jeff Atwood's recent post on monkey patching. He shows an example in C# 3.0 which is the current language I use for work.


  • Translate

    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
    

  • Translate

    There are at least two ways for attach a method to an instance without types.MethodType:

    >>> class A:
    ...  def m(self):
    ...   print 'im m, invoked with: ', self
    
    >>> a = A()
    >>> a.m()
    im m, invoked with:  <__main__.A instance at 0x973ec6c>
    >>> a.m
    <bound method A.m of <__main__.A instance at 0x973ec6c>>
    >>> 
    >>> def foo(firstargument):
    ...  print 'im foo, invoked with: ', firstargument
    
    >>> foo
    <function foo at 0x978548c>
    

    1:

    >>> a.foo = foo.__get__(a, A) # or foo.__get__(a, type(a))
    >>> a.foo()
    im foo, invoked with:  <__main__.A instance at 0x973ec6c>
    >>> a.foo
    <bound method A.foo of <__main__.A instance at 0x973ec6c>>
    

    2:

    >>> instancemethod = type(A.m)
    >>> instancemethod
    <type 'instancemethod'>
    >>> a.foo2 = instancemethod(foo, a, type(a))
    >>> a.foo2()
    im foo, invoked with:  <__main__.A instance at 0x973ec6c>
    >>> a.foo2
    <bound method instance.foo of <__main__.A instance at 0x973ec6c>>
    

    Useful links:
    Data model - invoking descriptors
    Descriptor HowTo Guide - invoking descriptors


  • Translate

    What you're looking for is setattr I believe. Use this to set an attribute on an object.

    >>> def printme(s): print repr(s)
    >>> class A: pass
    >>> setattr(A,'printme',printme)
    >>> a = A()
    >>> a.printme() # s becomes the implicit 'self' variable
    < __ main __ . A instance at 0xABCDEFG>
    

  • Translate

    Since this question asked for non-Python versions, here's JavaScript:

    a.methodname = function () { console.log("Yay, a new method!") }
    

  • Translate

    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__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FD88>>
    # addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FD88>>
    # f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FD88>>
    
    print '\nattributes of b:'
    listattr(b)
    # OUT:
    # attributes of b:
    # __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FE08>>
    # addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FE08>>
    # f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FE08>>
    # f1 <bound method ?.f1 of <class __main__.C at 0x000000000237AB28>>
    # f2 <bound method ?.f2 of <__main__.C instance at 0x000000000230FE08>>
    # f3 <bound method ?.f3 of <__main__.C instance at 0x000000000230FE08>>
    # f4 <bound method ?.f4 of <__main__.C instance at 0x000000000230FE08>>
    
    print '\nattributes of c:'
    listattr(c)
    # OUT:
    # attributes of c:
    # __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002313108>>
    # addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002313108>>
    # f0 <bound method C.f0 of <__main__.C instance at 0x0000000002313108>>
    

    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__ <bound method C.__init__ of <__main__.C instance at 0x0000000002303508>>
    # addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002303508>>
    # f0 <bound method C.f0 of <__main__.C instance at 0x0000000002303508>>
    # f1 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
    # f2 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
    # f3 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
    # f4 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
    

  • Translate

    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
    

  • Translate

    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.


  • Translate

    What Jason Pratt posted is correct.

    >>> class Test(object):
    ...   def a(self):
    ...     pass
    ... 
    >>> def b(self):
    ...   pass
    ... 
    >>> Test.b = b
    >>> type(b)
    <type 'function'>
    >>> type(Test.a)
    <type 'instancemethod'>
    >>> type(Test.b)
    <type 'instancemethod'>
    

    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.


  • Translate

    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.


  • Translate

    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
    

  • Translate
    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