Question

当我定义一个类时，我经常想在创建对象时为该类设置一组属性。到目前为止，我已将属性作为参数传递给 init 方法。但是，我对这些代码的重复性质感到不满：

class Repository(OrderedDict,UserOwnedObject,Describable):
  def __init__(self,user,name,gitOriginURI=None,gitCommitHash=None,temporary=False,sourceDir=None):
    self.name = name
    self.gitOriginURI = gitOriginURI
    self.gitCommitHash = gitCommitHash
    self.temporary = temporary
    self.sourceDir = sourceDir
    ...

在此示例中，我必须输入name三次，gitOriginURI三次，gitCommitHash三次，temporary三次，sourceDir三次倍。只是设置这些属性。这是非常无聊的代码。

我考虑过改变这样的课程：

class Foo():
  def __init__(self):
    self.a = None
    self.b = None
    self.c = None

初始化他们的对象，如：

f = Foo()
f.a = whatever
f.b = something_else
f.c = cheese

但是从文档的角度来看，这似乎更糟糕，因为类的用户需要知道需要设置哪些属性，而不是简单地查看类的自动生成的help()字符串。初始化程序。

有没有更好的方法来做到这一点？

我认为有一件事可能是一个有趣的解决方案，如果有一个store_args_to_self()方法可以将传递给init的每个参数存储为self的属性。这种方法存在吗？

让我对这种更好的方法的追求感到悲观的一件事是，查看cPython源代码中date对象的源代码，例如，我看到同样的重复代码：

def __new__(cls, year, month=None, day=None):
    ...
    self._year = year
    self._month = month
    self._day = day

https://github.com/python/cpython/blob/master/Lib/datetime.py#L705

而且，尽管使用setter稍微混淆了，但是也有这样的＆＃34;采取参数并将其设置为自我的属性＆＃34;热土豆代码：

def __init__(self, caption=u"", edit_text=u"", multiline=False,
        align=LEFT, wrap=SPACE, allow_tab=False,
        edit_pos=None, layout=None, mask=None):
    ...

    self.__super.__init__("", align, wrap, layout)
    self.multiline = multiline
    self.allow_tab = allow_tab
    self._edit_pos = 0
    self.set_caption(caption)
    self.set_edit_text(edit_text)
    if edit_pos is None:
        edit_pos = len(edit_text)
    self.set_edit_pos(edit_pos)
    self.set_mask(mask)

https://github.com/urwid/urwid/blob/master/urwid/widget.py#L1158

Answer 1

您可以使用dataclasses project来为您生成__init__方法;它还会处理表示，散列和相等测试（以及可选的丰富比较和不变性）：

from dataclasses import dataclass
from typing import Optional

@dataclass
class Repository(OrderedDict, UserOwnedObject, Describable):
    name: str
    gitOriginURI: Optional[str] = None
    gitCommitHash: Optional[str] = None
    temporary: bool = False
    sourceDir: Optional[str] = None

dataclasses在PEP 557 - Data Classes中定义，已被接受包含在Python 3.7中。该库将适用于Python 3.6及更高版本（因为它依赖于3.6中引入的新变量注释语法）。

该项目的灵感来自attrs project，它提供了更多的灵活性和选项，以及与Python 2.7和Python 3.4及更高版本的兼容性。

Answer 2

嗯，你可以这样做：

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

foo = Foo(a=1, b='two', c='iii')
print(foo.a, foo.b, foo.c)

<强>输出

1 two iii

但如果你这样做，那么在将kwargs中的密钥转储到你的实例__dict__之前，检查class Foo: attrs = ['a', 'b', 'c'] ''' Some stuff about a, b, & c ''' def __init__(self, **kwargs): valid = {key: kwargs.get(key) for key in self.attrs} self.__dict__.update(valid) def __repr__(self): args = ', '.join(['{}={}'.format(key, getattr(self, key)) for key in self.attrs]) return 'Foo({})'.format(args) foo = Foo(a=1, c='iii', d='four') print(foo)中的密钥是否合理可能是个好主意。 ;）

这里有一个稍微更加漂亮的例子，可以对传入的args进行一些检查。

Foo(a=1, b=None, c=iii)

<强>输出

{{1}}

Answer 3

对于Python 2.7，我的解决方案是继承自namedtuple并使用namedtuple本身作为init的唯一参数。为了避免每次我们都可以使用装饰器重载新的。优点是我们有明确的 init 签名w / o * args，** kwargs以及好的IDE建议

def nt_child(c):
    def __new__(cls, p): return super(c, cls).__new__(cls, *p)
    c.__new__ = staticmethod(__new__)
    return c

ClassA_P = namedtuple('ClassA_P', 'a, b, foo, bar')

@nt_child
class ClassA(ClassA_P):
    def __init__(self, p):
        super(ClassA, self).__init__(*p)
        self.something_more = sum(p)

a = ClassA(ClassA_P(1,2,3,4)) # a = ClassA(ClassA_P( <== suggestion a, b, foo, bar
print a.something_more # print a. <== suggesion a, b, foo, bar, something_more

Answer 4

我将在这里留下另一个食谱。 attrs很有用，但有缺点，主要是缺少类__init__的IDE建议。

拥有初始化链也很有趣，我们使用父类的实例作为__init__的第一个arg，而不是逐个提供所有它的attrs。

所以我建议使用简单的装饰器。它分析__init__签名并基于它自动添加类属性（因此方法与attrs的方法相反）。这为__init__提供了很好的IDE建议（但缺乏对属性本身的建议）。

用法：

@data_class
class A:
    def __init__(self, foo, bar): pass

@data_class
class B(A):
    # noinspection PyMissingConstructor
    def __init__(self, a, red, fox):
        self.red_plus_fox = red + fox
        # do not call parent constructor, decorator will do it for you

a = A(1, 2)
print a.__attrs__ # {'foo': 1, 'bar': 2}

b = B(a, 3, 4) # {'fox': 4, 'foo': 1, 'bar': 2, 'red': 3, 'red_plus_fox': 7}
print b.__attrs__

来源：

from collections import OrderedDict

def make_call_dict(f, is_class_method, *args, **kwargs):
    vnames = f.__code__.co_varnames[int(is_class_method):f.__code__.co_argcount]
    defs = f.__defaults__ or []

    d = OrderedDict(zip(vnames, [None] * len(vnames)))
    d.update({vn: d for vn, d in zip(vnames[-len(defs):], defs)})
    d.update(kwargs)
    d.update({vn: v for vn, v in zip(vnames, args)})
    return d

def data_class(cls):
    inherited = hasattr(cls, '_fields')
    if not inherited: setattr(cls, '_fields', None)
    __init__old__ = cls.__init__

    def __init__(self, *args, **kwargs):
        d = make_call_dict(__init__old__, True, *args, **kwargs)

        if inherited:
            # tricky call of parent __init__
            O = cls.__bases__[0]  # put parent dataclass first in inheritance list
            o = d.values()[0]  # first arg in my __init__ is parent class object
            d = OrderedDict(d.items()[1:])
            isg = o._fields[O]  # parent __init__ signature, [0] shows is he expect data object as first arg
            O.__init__(self, *(([o] if isg[0] else []) + [getattr(o, f) for f in isg[1:]]))
        else:
            self._fields = {}

        self.__dict__.update(d)

        self._fields.update({cls: [inherited] + d.keys()})

        __init__old__(self, *args, **kwargs)

    cls.__attrs__ = property(lambda self: {k: v for k, v in self.__dict__.items()
                                           if not k.startswith('_')})
    cls.__init__ = __init__
    return cls

在Python中创建对象时设置类属性的最佳方法是什么？

4 个答案: