为方法动态添加关键参数

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}

欢迎任何建议或想法。

关于上下文的一点：

Module 类是某种函数包装器，可用于将低端函数自动包含在数据流系统中，但添加中间过程。我希望模块运行函数（实际上，它可能是 __call___ 函数）具有正确的 API，以便数据流系统能够很好地透明地生成正确的模块输入。

我正在使用 python 2.7

Answer 1

您可能正在寻找这样的东西：

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)

我刚刚围绕前一个函数创建了一个包装实例方法。 （部分灵感来自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...

Answer 2

kwargs 是一个字典，我们需要做的就是保存它以备后用。然后用户可以用他们的值覆盖它。

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

编辑

您是否正在寻找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 3

为了结束，我给出找到的唯一解决方案：使用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()

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 表示，则可能会出现问题
• 我觉得太复杂了（所以不是pythonic），个人没用过

Answer 4

这听起来不是个好主意。与其纠结函数签名，不如定义一组默认值作为实例变量，并在函数中使用它：

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