Creación de métodos dinámicos/en tiempo de ejecución (generación de código) en Python

Question

Necesito generar código para un método en tiempo de ejecución. Es importante poder ejecutar código arbitrario y tener una docstring.

me ocurrió una solución que combina exec y setattr, aquí hay un ejemplo ficticio:

class Viking(object): 
    def __init__(self): 
     code = ''' 
      def dynamo(self, arg): 
       """ dynamo's a dynamic method! 
       """ 
       self.weight += 1 
       return arg * self.weight 
      ''' 
     self.weight = 50 

     d = {} 
     exec code.strip() in d 
     setattr(self.__class__, 'dynamo', d['dynamo']) 


if __name__ == "__main__": 
    v = Viking() 
    print v.dynamo(10) 
    print v.dynamo(10) 
    print v.dynamo.__doc__ 

¿Hay una manera mejor/más seguro/más idiomática de lograr el mismo resultado?

Answer 1

basado en el código de Theran, pero extendiéndolo a los métodos de las clases:

 


class Dynamo(object): 
    pass 

def add_dynamo(cls,i): 
    def innerdynamo(self): 
     print "in dynamo %d" % i 
    innerdynamo.__doc__ = "docstring for dynamo%d" % i 
    innerdynamo.__name__ = "dynamo%d" % i 
    setattr(cls,innerdynamo.__name__,innerdynamo) 

for i in range(2): 
    add_dynamo(Dynamo, i) 

d=Dynamo() 
d.dynamo0() 
d.dynamo1() 

 

Cuál debería imprimir:

 

in dynamo 0 
in dynamo 1 
 

Answer 2

Python le permitirá declarar una función en una función, por lo que no tiene que hacer el truco exec.

def __init__(self): 

    def dynamo(self, arg): 
     """ dynamo's a dynamic method! 
     """ 
     self.weight += 1 
     return arg * self.weight 
    self.weight = 50 

    setattr(self.__class__, 'dynamo', dynamo) 

Si usted quiere tener varias versiones de la función, se puede poner todo esto en un bucle y variar lo que les nombre en la función setattr:

def __init__(self): 

    for i in range(0,10): 

     def dynamo(self, arg, i=i): 
      """ dynamo's a dynamic method! 
      """ 
      self.weight += i 
      return arg * self.weight 

     setattr(self.__class__, 'dynamo_'+i, dynamo) 
     self.weight = 50 

(sé que esto no es es un gran código, pero hace entender el punto). En cuanto a la configuración de la docstring, sé que es posible, pero tendría que buscarla en la documentación.

Editar: Puede establecer la cadena de documentación a través de dynamo.__doc__, por lo que podría hacer algo como esto en su cuerpo del ciclo:

dynamo.__doc__ = "Adds %s to the weight" % i 

Otra Editar: Con la ayuda de @eliben y @bobince, la problema de cierre debe ser resuelto.

Answer 3

La función docstrings y los nombres son propiedades mutables. Puede hacer lo que quiera en la función interna, o incluso tener múltiples versiones de la función interna que macedynamo() elija entre. No es necesario construir ningún código de cadenas.

He aquí un fragmento de la intérprete:

>>> def makedynamo(i): 
...  def innerdynamo(): 
...   print "in dynamo %d" % i 
...  innerdynamo.__doc__ = "docstring for dynamo%d" % i 
...  innerdynamo.__name__ = "dynamo%d" % i 
...  return innerdynamo 

>>> dynamo10 = makedynamo(10) 
>>> help(dynamo10) 
Help on function dynamo10 in module __main__: 

dynamo10() 
    docstring for dynamo10 

Answer 4

Perdón por mi mal inglés.

Recientemente necesito generar una función dinámica para vincular cada elemento del menú para abrir un marco particular en wxPython. Esto es lo que hago.

primero, creo una lista de asignación entre el elemento de menú y el marco.

menus = [(self.menuItemFile, FileFrame), (self.menuItemEdit, EditFrame)] 

el primer elemento en la asignación es el elemento del menú y el último elemento es el marco que se va a abrir. A continuación, ato el evento wx.EVT_MENU desde cada elemento del menú a un marco particular.

for menu in menus: 
    f = genfunc(self, menu[1]) 
    self.Bind(wx.EVT_MENU, f, menu[0]) 

función genfunc es el constructor función dinámica, aquí está el código:

def genfunc(parent, form): 
    def OnClick(event): 
     f = form(parent) 
     f.Maximize() 
     f.Show() 
    return OnClick 

Answer 5

class Dynamo(object): 
    def __init__(self): 
     pass 

    @staticmethod 
    def init(initData=None): 
     if initData is not None: 
      dynamo= Dynamo() 
      for name, value in initData.items(): 
       code = ''' 
def %s(self, *args, **kwargs): 
%s 
          ''' % (name, value) 
       result = {} 
       exec code.strip() in result 
       setattr(dynamo.__class__, name, result[name]) 

      return dynamo 

     return None 

service = Dynamo.init({'fnc1':'pass'}) 
service.fnc1()