Python ajouter à une fonction dynamiquement

Typique de la façon d'ajouter des fonctionnalités à une fonction est d'utiliser un décorateur (à l'aide de l'enveloppe de la fonction):

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"

Bien sûr, cela dépend vraiment de ce que vous essayez d'accomplir. J'utilise les décorateurs beaucoup, mais si tout ce que je voulais faire était d'impression de messages supplémentaires, je serais probablement faire quelque chose comme

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"

Il ne faut pas de méta-programmation, mais votre exemple est probablement grandement simplifiée de ce que vous avez réellement besoin de le faire. Peut-être que si vous publiez plus de détails sur vos besoins spécifiques, nous pouvons conseiller à ce que le Pythonic approche serait.

EDIT: Puisqu'il semble que vous voulez appeler des fonctions, vous pouvez avoir une liste de fonctions au lieu d'une liste de messages. Par exemple:

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"

Noter que si vous souhaitez ajouter des fonctions qui seront appelées par toutes les instances de A, alors vous devriez faire funcs un champ de classe plutôt que d'un champ d'instance, par exemple

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"

Cette réponse permet de modifier la fonction d'origine sans créer un wrapper. J'ai trouvé les deux natifs python types, qui sont utiles pour répondre à votre question:

types.FunctionType

Et

types.CodeType

Ce Code semble faire la job:

import inspect
import copy
import types
import dill
import dill.source


#Define a function we want to modify:
def test():
    print "Here"

#Run the function to check output
print '\n\nRunning Function...'
test()
#>>> Here

#Get the source code for the test function:
testSource = dill.source.getsource(test)
print '\n\ntestSource:'
print testSource


#Take the inner part of the source code and modify it how we want:
newtestinnersource = ''
testSourceLines = testSource.split('\n')
linenumber = 0 
for line in testSourceLines:
    if (linenumber > 0):
        if (len(line[4:]) > 0):
            newtestinnersource += line[4:] + '\n'
    linenumber += 1
newtestinnersource += 'print "Here2"'
print '\n\nnewtestinnersource'
print newtestinnersource


#Re-assign the function's code to be a compiled version of the `innersource`
code_obj = compile(newtestinnersource, '<string>', 'exec')
test.__code__ = copy.deepcopy(code_obj)
print '\n\nRunning Modified Function...'
test() #<- NOW HAS MODIFIED SOURCE CODE, AND PERFORMS NEW TASK
#>>>Here
#>>>Here2

Copier et coller, profitez-en!!!!!

#!/usr/bin/env python 

def say(host, msg): 
   print '%s says %s' % (host.name, msg) 

def funcToMethod(func, clas, method_name=None): 
   setattr(clas, method_name or func.__name__, func) 

class transplant: 
   def __init__(self, method, host, method_name=None): 
      self.host = host 
      self.method = method 
      setattr(host, method_name or method.__name__, self) 

   def __call__(self, *args, **kwargs): 
      nargs = [self.host] 
      nargs.extend(args) 
      return apply(self.method, nargs, kwargs) 

class Patient: 
   def __init__(self, name): 
      self.name = name 

if __name__ == '__main__': 
   jimmy = Patient('Jimmy') 
   transplant(say, jimmy, 'say1') 
   funcToMethod(say, jimmy, 'say2') 

   jimmy.say1('Hello') 
   jimmy.say2(jimmy, 'Good Bye!')