Python：如何轻松地将函数参数复制到对象的字段中？

Question

很多时候我都有将参数复制到对象字段中的成员函数。例如：

class NouveauRiches(object):
  def __init__(self, car, mansion, jet, bling):
    self.car = car
    self.mansion = mansion
    self.jet = jet
    self.bling = bling

有没有一种 Python 语言结构可以让上面的代码变得不那么乏味？ 可以使用 *args:

def __init__(self, *args):
  self.car, self.mansion, self.jet, self.bling = args

+：不那么乏味

-: 函数签名不够暴露。需要深入了解函数代码才能知道如何使用函数

-: 在调用错误# 参数时不会引发TypeError（但会引发ValueError）

还有其他想法吗？ （无论您有什么建议，请确保调用该函数的代码保持简单）

Answer 1

您可以使用辅助方法来做到这一点，如下所示：

import inspect

def setargs(func):
    f = inspect.currentframe(1)
    argspec = inspect.getargspec(func)
    for arg in argspec.args:
        setattr(f.f_locals["self"], arg, f.f_locals[arg])

用法：

class Foo(object):

    def __init__(self, bar, baz=4711):
        setargs(self.__init__)

        print self.bar # Now defined
        print self.baz # Now defined

这不是很漂亮，它应该只在原型设计时使用。如果您打算让其他人阅读，请使用显式分配。

它可能需要改进，不需要将函数作为参数，但这需要更丑陋的黑客和诡计:)

Answer 2

我会这样做，你也可以覆盖已经定义的属性。

class D:
  def __init__(self, **kwargs):
    self.__dict__.update(kwargs)

但我个人会走很长的路。 想想那些：

- Explicit is better than implicit.
- Flat is better than nested.
(The Zen of Python)

Answer 3

试试类似的东西

d = dict(locals())
del d['self']
self.__dict__.update(d)

当然，它返回所有局部变量，而不仅仅是函数参数。

Answer 4

我不确定这是个好主意，但可以做到：

import inspect
class NouveauRiches(object):
    def __init__(self, car, mansion, jet, bling):
        arguments = inspect.getargvalues(frame)[0]
        values = inspect.getargvalues(frame)[3];
        for name in arguments:
            self.__dict__[name] = values[name]

虽然我想你可以把它放在一个可重复使用的实用方法中。

Answer 5

你可以试试这样的：

class C(object):
    def __init__(self, **kwargs):
        for k in kwargs:
            d = {k: kwargs[k]}
            self.__dict__.update(d)

或者使用 setattr 你可以这样做：

class D(object):
    def __init__(self, **kwargs):
        for k in kwargs:
            setattr(self, k, kwargs[k])

两者都可以这样调用：

myclass = C(test=1, test2=2)

所以你必须使用 **kwargs，而不是 *args。

Answer 6

我有时会为行为“类似”的类这样做，也就是说，它们有一堆可自定义的属性：

class SuperClass(object):
    def __init__(self, **kw):
        for name, value in kw.iteritems():
            if not hasattr(self, name):
                raise TypeError('Unexpected argument: %s' % name)
            setattr(self, name, value)

class SubClass(SuperClass):
    instance_var = None # default value

class SubClass2(SubClass):
    other_instance_var = True

    @property
    def something_dynamic(self):
        return self._internal_var

    @something_dynamic.setter # new Python 2.6 feature of properties
    def something_dynamic(self, value):
        assert value is None or isinstance(value, str)
        self._internal_var = value

然后你可以调用SubClass2(instance_var=[], other_instance_var=False)，它会在没有定义__init__的情况下工作。您也可以使用任何属性。虽然这允许您覆盖您可能不希望的方法（因为它们为 hasattr() 返回 True，就像实例变量一样）。

如果您添加任何property 或其他描述符，它将正常工作。您可以使用它来进行类型检查；与__init__ 中的类型检查不同，它会在任何时候更新该值时应用。请注意，除非您覆盖__init__，否则您不能对这些使用任何 位置参数，因此有时自然位置参数将不起作用。 formencode.declarative 涵盖了这个问题和其他问题，可能很彻底，我不建议您尝试（回想起来，我认为这不值得）。

请注意，任何使用 self.__dict__ 的配方都不会尊重属性和描述符，如果您将它们一起使用，您只会得到奇怪和意想不到的结果。我只推荐使用setattr()来设置属性，从不self.__dict__。

此外，这个秘籍并没有给出非常有用的签名，而一些进行框架和函数自省的签名却可以。使用 some work 可以动态生成 __doc__ 以澄清论点...但我再次不确定是否值得添加更多活动部件。

Answer 7

我是以下的粉丝

import inspect

def args_to_attrs(otherself):
    frame = inspect.currentframe(1)
    argvalues = inspect.getargvalues(frame)

    for arg in argvalues.args:
        if arg == 'self':
            continue
        value = argvalues.locals[arg]
        setattr(otherself, arg, value)

class MyClass:
    def __init__(self, arga="baf", argb="lek", argc=None):
        args_to_attrs(self)

__init__ 的参数是显式命名的，因此很清楚正在设置哪些属性。此外，它比当前接受的答案稍微简化了一些。