Динамическое добавление ключей-аргументов к методу

Question

Я хотел бы задать динамические аргументы ключа-аргумента по умолчанию. Например, с

class Module(object): 
    def __init__(self, **kargs): 
     set-default-key-args-of-method(self.run, kargs) # change run arguments 
    def run(self, **kargs): 
     print kargs 

Мы имеем:

m = Module(ans=42) 

m.run.im_func.func_code.co_argcount # => 2 
m.run.im_func.func_code.co_varnames # => ('self','ans','kargs') 
m.run.im_func.func_defaults   # => (42,) 
m.run()        # print {'ans':42} 

Я пытался что-то с types.CodeType (который я не очень понимаю) для функции (а не метод) и получил его (нуль не-к-неудачу), но добавленные ключевые аргументы не показывались в словаре kargs функции (он только печатает {})

Это изменение должно быть выполнено только для текущего экземпляра , На самом деле, я использую класс прямо сейчас (я OO в моем сознании), поэтому я хотел бы сделать это с помощью метода класса, но функция может быть лучше. Что-то вроде:

def wrapped_run(**kargs): 
    def run(**key_args): 
     print key_args 

    return wrap-the-run-function(run, kargs) 

run = wrapped_run(ans=42) 

run.func_code.co_argcount # => 1 
run.func_code.co_varnames # => ('ans','key_args') ## keep the 'key_args' or not 
run.func_defaults   # => (42,) 
run()      # print {'ans':42} 

Любые советы или идеи приветствуются.

Немного о контексте:

Класс модуля является своего рода функция упаковщик, который можно использовать, чтобы включить нижний конец функции в системе автоматически, но потока данных добавить промежуточные процедуры. Я бы хотел, чтобы функция запуска модуля (на самом деле, вероятно, это была функция __call___) имела правильный API, чтобы система потока данных могла легко генерировать вход модуля корректно.

Я использую Python 2.7

Answer 1

Ради закрытия, я дам единственное решение, которое было найдено: использование exec (предложенный mgilson)

import os, new 

class DynamicKargs(object): 
    """ 
    Class that makes a run method with same arguments 
    as those given to the constructor 
    """ 
    def __init__(self, **kargs): 
     karg_repr = ','.join([str(key)+'='+repr(value) \ 
           for key,value in kargs.iteritems()]) 
     exec 'def run(self,' + karg_repr + ',**kargs):\n return self._run(' + karg_repr + ',**kargs)' 

     self.run = new.instancemethod(run, self) 

    def _run(self, **kargs): 
     print kargs 

# this can also be done with a function 
def _run(**kargs): 
    print kargs 

def dynamic_kargs(**kargs): 
    karg_repr = ','.join([str(key)+'='+repr(value) for key,value in kargs.iteritems()]) 
    exec 'def run(' + karg_repr + ',**kargs):\n return _run(' + karg_repr + ',**kargs)' 
    return run 


# example of use 
# -------------- 
def example(): 
    dyn_kargs = DynamicKargs(question='ultimate', answer=42) 
    print 'Class example \n-------------' 
    print 'var number:', dyn_kargs.run.im_func.func_code.co_argcount 
    print 'var names: ', dyn_kargs.run.im_func.func_code.co_varnames 
    print 'defaults: ', dyn_kargs.run.im_func.func_defaults 
    print 'run print: ', 
    dyn_kargs.run() 
    print '' 

    dyn_kargs = dynamic_kargs(question='foo', answer='bar') 
    print 'Function example \n----------------' 
    print 'var number:', dyn_kargs.func_code.co_argcount 
    print 'var names: ', dyn_kargs.func_code.co_varnames 
    print 'defaults: ', dyn_kargs.func_defaults 
    print 'run print: ', 
    dyn_kargs() 

The example функция печатает:

Class example 
------------- 
var number: 3 
var names: ('self', 'answer', 'question', 'kargs') 
defaults: (42, 'ultimate') 
run print: {'answer': 42, 'question': 'ultimate'} 

Function example 
---------------- 
var number: 2 
var names: ('answer', 'question', 'kargs') 
defaults: ('bar', 'foo') 
run print: {'answer': 'bar', 'question': 'foo'} 

Однако:

• там могут быть проблемы, если значение аргумента недостаточно хорошо представлены их repr
• Я думаю, что это слишком сложно (при этом не вещий), и лично я не использовал его

Answer 2

Это не звучит как хорошая идея. Вместо того, чтобы отвод о с подписями функций, было бы лучше, чтобы определить набор по умолчанию в качестве переменного экземпляра, и использовать его в функции:

class Module(object): 
    def __init__(self, **kwargs): 
     self.run_defaults = kwargs 
    def run(self, **kwargs): 
     actual_values = self.run_defaults.copy() 
     actual_values.update(kwargs) 
     print actual_values 

Answer 3

kwargs является словарем, и все, что нам нужно нужно сделать, это сохраните его позже. Тогда пользователь может переопределить его своими значениями.

class Module(object): 
    def __init__(self, **kwargs): 
     self.defaults = kwargs 
    def run(**kwargs): 
     values = dict(self.defaults.items() + kwargs.items()) 
     print values 

EDIT

Вы, возможно, ищете lambda поколения функции?

def wrapfunc(**kwargs): 
    def run(kwargs): 
     print kwargs 
    return lambda x: run(dict(kwargs.items() + x.items())) 

run = wrapfunc(ans=42) 
run({}) 
run({'ans':12}) 

Answer 4

Вы можете искать что-то вроде этого:

class Module(object): 
    def __init__(self, **kargs): 
     old_run = self.run.im_func 
     def run(self,**kwargs): 
      kargs_local = kargs.copy() 
      kargs.update(kwargs) 
      return old_run(self,**kargs) 
     self.run = run.__get__(self,Module) 

    def run(self,**kargs): 
     print kargs 

m1 = Module(foo=3,bar='baz') 
m1.run() 
print type(m1.run) 

m2 = Module(foo=4,qux='bazooka') 
m2.run() 
print type(m2.run) 

Я только что создал оболочку instancemethod вокруг предыдущей функции. (частично вдохновленный this post).

В качестве альтернативы:

from functools import partial 
from types import MethodType 

class Module(object): 
    def __init__(self, **kargs): 
     self.run = MethodType(partial(self.run.im_func,**kargs),self,Module) 

    def run(self,**kargs): 
     print kargs 

, но это еще не дает API, который вы ищете ...