Python add to a function dynamically

Question

how do i add code to an existing function, either before or after?

for example, i have a class:

 class A(object):
     def test(self):
         print "here"

how do i edit the class wit metaprogramming so that i do this

 class A(object):
     def test(self):
         print "here"

         print "and here"

maybe some way of appending another function to test?

add another function such as

 def test2(self):
      print "and here"

and change the original to

 class A(object):
     def test(self):
         print "here"
         self.test2()

is there a way to do this?

Answer 1

Why not use inheritance?

class B(A):
    def test(self):
        super(B, self).test()
        print "and here"

Answer 2

The typical way to add functionality to a function is to use a decorator (using the wraps function):

from functools import wraps

def add_message(func):
    @wraps
    def with_additional_message(*args, **kwargs)
        try:
            return func(*args, **kwargs)
        finally:
            print "and here"
    return with_additional_message

class A:
    @add_message
    def test(self):
        print "here"

Of course, it really depends on what you're trying to accomplish. I use decorators a lot, but if all I wanted to do was to print extra messages, I'd probably do something like

class A:
    def __init__(self):
        self.messages = ["here"]

    def test(self):
        for message in self.messages:
            print message

a = A()
a.test()    # prints "here"

a.messages.append("and here")
a.test()    # prints "here" then "and here"

This requires no meta-programming, but then again your example was probably greatly simplified from what you actually need to do. Perhaps if you post more detail about your specific needs, we can better advise what the Pythonic approach would be.

EDIT: Since it seems like you want to call functions, you can have a list of functions instead of a list of messages. For example:

class A:
    def __init__(self):
        self.funcs = []

    def test(self):
        print "here"
        for func in self.funcs:
            func()

def test2():
    print "and here"

a = A()
a.funcs.append(test2)
a.test()    # prints "here" then "and here"

Note that if you want to add functions that will be called by all instances of A, then you should make funcs a class field rather than an instance field, e.g.

class A:
    funcs = []
    def test(self):
        print "here"
        for func in self.funcs:
            func()

def test2():
    print "and here"

A.funcs.append(test2)

a = A()
a.test()    # print "here" then "and here"

Answer 3

You can use a decorator to modify the function if you want. However, since it's not a decorator applied at the time of the initial definition of the function, you won't be able to use the @ syntactic sugar to apply it.

>>> class A(object):
...     def test(self):
...         print "orig"
...
>>> first_a = A()
>>> first_a.test()
orig
>>> def decorated_test(fn):
...     def new_test(*args, **kwargs):
...         fn(*args, **kwargs)
...         print "new"
...     return new_test
...
>>> A.test = decorated_test(A.test)
>>> new_a = A()
>>> new_a.test()
orig
new
>>> first_a.test()
orig
new

Do note that it will modify the method for existing instances as well.

EDIT: modified the args list for the decorator to the better version using args and kwargs

Answer 4

If your class A inherits from object, you could do something like:

def test2():
    print "test"

class A(object):
    def test(self):
        setattr(self, "test2", test2)
        print self.test2
        self.test2()

def main():
    a = A()
    a.test()

if __name__ == '__main__':
    main()

This code has no interest and you can't use self in your new method you added. I just found this code fun, but I will never use this. I don't like to dynamicaly change the object itself.

It's the fastest way, and more understandable.

Answer 5

There are a lot of really good suggestions above, but one I didn't see was passing in a function with the call. Might look something like this:

class A(object):
    def test(self, deep=lambda self: self):
        print "here"
        deep(self)
def test2(self):
    print "and here"

Using this:

>>> a = A()
>>> a.test()
here
>>> a.test(test2)
here
and here