インスタンス変数を自動的に初期化しますか？

89

私は次のようなPythonクラスを持っています：

class Process:
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):

に続く：

        self.PID=PID
        self.PPID=PPID
        self.cmd=cmd
        ...

C ++の初期化リストのように、これらのインスタンス変数を自動初期化する方法はありますか？それは多くの冗長なコードを惜しまないでしょう。

python  class  initialization-list 
— アダムマタン
ソース
1
autoassignactivestateレシピの説明、および次の代替autoargs実装も参照してください。Pythonで自動属性割り当てを行うための最良の方法は何ですか。それは良い考えですか。-スタックオーバーフロー
— nealmcb 2017年

回答:

104

デコレータを使用できます。

from functools import wraps
import inspect

def initializer(func):
    """
    Automatically assigns the parameters.

    >>> class process:
    ...     @initializer
    ...     def __init__(self, cmd, reachable=False, user='root'):
    ...         pass
    >>> p = process('halt', True)
    >>> p.cmd, p.reachable, p.user
    ('halt', True, 'root')
    """
    names, varargs, keywords, defaults = inspect.getargspec(func)

    @wraps(func)
    def wrapper(self, *args, **kargs):
        for name, arg in list(zip(names[1:], args)) + list(kargs.items()):
            setattr(self, name, arg)

        for name, default in zip(reversed(names), reversed(defaults)):
            if not hasattr(self, name):
                setattr(self, name, default)

        func(self, *args, **kargs)

    return wrapper

__init__メソッドを飾るためにそれを使用してください：

class process:
    @initializer
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):
        pass

出力：

>>> c = process(1, 2, 3, 4, 5, 6)
>>> c.PID
1
>>> dir(c)
['FDs', 'PID', 'PPID', '__doc__', '__init__', '__module__', 'cmd', 'reachable', 'user'
— ナディア・アラムリ
ソース
5
これはうまくいき、質問に答えるので、私は投票しました。しかし、私はFerdidandバイエルの答えを保持：「明示的、暗黙よりも優れている」
— ルーカスガブリエル・サンチェス
14
+1私の問題を解決した素晴らしい答えのために。しかし、それは言語のコア機能であるべきではありませんか？PEPを書く価値があると思いますか？
— アダムMatan
3
これは本当に良い答えです-これは私のツールボックスに直接入りました。
— Michael van der Westhuizen
3
@NadiaAlramliコードに小さなバグがあると思います。ここを見てgist.github.com/pmav99/137dbf4681be9a58de74（original.py）
— pmav99
2
現在の例にはバグがあり、署名にデフォルトの引数が含まれていない場合は機能しません。名前とデフォルトがNoneでないことを確認するためのチェックを含める必要があります。例：名前とデフォルトの場合：
36

Python 2.6以降を使用している場合は、collections.namedtupleを使用できます。

>>> from collections import namedtuple
>>> Process = namedtuple('Process', 'PID PPID cmd')
>>> proc = Process(1, 2, 3)
>>> proc.PID
1
>>> proc.PPID
2

これは、クラスが本当に価値の大きな袋である場合に特に適切です。

— キブ
ソース
2
「これは、クラスが本当に価値の大きな袋である場合に特に適切です。」このようなシナリオでは、これを行うこともできます：https
— Big Sharpie
34

Python 3.7以降では、データクラスを使用できます。これは、非常にPythonで保守しやすい方法で、必要なことを実行できます。

これにより、自動的に初期化されたインスタンス変数であるクラスのフィールドを定義できます。

次のようになります。 

@dataclass
class Process:
    PID: int
    PPID: int
    cmd: str
    ...

__init__この方法は、すでにあなたのクラスになります。

なお、ここでは注意ヒントが必要なタイプ私が使用している理由である、intとstrの例では。フィールドのタイプがわからない場合は、モジュールのAnyを使用できます。typing。

データクラスには、提案されたソリューションと比較して多くの利点があります。

  • これは明示的です。すべてのフィールドが表示されます。これにより、PythonのZenが尊重され、読み取りと保守が可能になります。の使用と比較してください**kwargs。
  • メソッドを持つことができます。他のクラスと同じように。
  • それはあなたが方法__init__を使用して自動を超えることを可能にします__post_init__。

編集：NamedTuplesの使用を避ける理由

namedtupleこの場合の使用を提案する人もいますが、namedtupleには、Pythonクラスとは異なる動作がいくつかあります。これらは、最初はあまり明白ではなく、よく知られているはずです。

1.NamedTuplesは不変です

不変性は便利な場合がありますが、インスタンスに必要なものではない可能性があります。引数を使用する場合データクラスも何とか不変でできるfrozen=True上@dataclassデコレータ。

2.NamedTuples__eq__はTupleのように動作します

Pythonでは、SomeNamedTuple(a=1, b=2) == AnotherNamedTuple(c=1, d=2)ですTrue！__eq__比較で使用されるNamedTupleの関数は、クラスやフィールドの名前ではなく、比較されたインスタンス上の値とそれらの値の位置のみを考慮します。

— ジュンディアウス
ソース
これは、クラスの目的がデータを格納することである場合にのみ使用する必要があります。
— JC Rocamonde 2018
または、データの保存を中心に開発します。
— JC Rocamonde 2018
3
データクラスを他の動作ではなく、データを格納するクラスにのみ使用する必要がある理由を説明してください。適切なユースケースをよりよく理解するために、このための新しいSO投稿を完全に作成する場合があります。ありがとう。
— VahidPazirandeh18年
Data Classes can be thought of as "mutable namedtuples with defaults". - PEP557
— aafulei
26

Pythonの禅を引用して、

明示的は暗黙的よりも優れています。

— フェルディナントバイエル
ソース
10
初期化リスト宣言は十分に明示的ではないでしょうか？
— アダムマタン
私は推測する。しかし、そのようなものを言語に追加する理由はわかりません。私は明らかに、舞台裏のある種のデコレータマジックよりも複数の代入ステートメントを好みます。
— フェルディナント
29
@ Ferdinand、stdlibに完全にうまく収まるものを言語で持つのはばかげていることに同意しますが、「美しい方が醜いよりも優れている」が優先され、多くの繰り返しの割り当てが醜いため、stdlibに含める必要があります（あらゆる形式の繰り返しと同様）。
— Alex Martelli
さて、反論するために：DWIM> DWIS
— Terrence Brannon
デコレータは割り当てのリストよりも美しいと思いますが、PyCharmはそれを理解しないことで
— 醜く
23

あなたができるもう一つのこと：

class X(object):
    def __init__(self, a,b,c,d):
        vars = locals() # dict of local names
        self.__dict__.update(vars) # __dict__ holds and object's attributes
        del self.__dict__["self"] # don't need `self`

しかし、私がお勧めする唯一の解決策は、それを綴るだけでなく、「エディターでマクロを作成する」ことです;-p

— Jochen Ritzel
ソース
1
'self'を削除する際の良いキャッチ。
— マイケル
15

次のように、キーワード引数を使用して簡単に行うことができます。

>>> class D:
    def __init__(self, **kwargs):
        for k, v in kwargs.items():
            setattr(self, k, v)

>>> D(test='d').test
'd'

位置引数の同様の実装は次のようになります。

>> class C:
    def __init__(self, *args):
        self.t, self.d = args


>>> C('abc', 'def').t
'abc'
>>> C('abc', 'def').d
'def'

私にはあなたの問題を解決していないようです。

— SilentGhost
ソース
3
私が好きなことをもう一つの変化があるself.__dict__.update( **kwargs )
— S.Lott
locals（）を使用して、通常の引数を指定することもできます。
— mk12 2009
7

ナディアのソリューションはより優れており、より強力ですが、これも興味深いと思います。

def constructor(*arg_names):
  def __init__(self, *args):
    for name, val in zip(arg_names, args):
      self.__setattr__(name, val)
  return __init__


class MyClass(object):
  __init__ = constructor("var1", "var2", "var3")


>>> c = MyClass("fish", "cheese", "beans")
>>> c.var2
"cheese"
— アンドリューマギー
ソース
5

同じ目的で何かが必要でしたが、テストしたすべてのケースをカバーする既存の回答はありませんでした。ナディアの答えは私が探していたものに最も近いので、私は彼女のコードをベースとして始めました。

以下のデコレータは、引数のすべての有効な組み合わせで機能します。 

Positional                                          __init__(self, a, b                )
Keyword                                             __init__(self, a=None, b=None      )
Positional + Keyword                                __init__(self, a, b, c=None, d=None)
Variable Positional                                 __init__(self, *a                  )
Variable Positional + Keyword                       __init__(self, *a, b=None          )
Variable Positional + Variable Keyword              __init__(self, *a, **kwargs        )
Positional + Variable Positional + Keyword          __init__(self, a, *b, c=None       )
Positional + Variable Positional + Variable Keyword __init__(self, a, *b, **kwargs     )
Keyword Only                                        __init__(self, *, a=None           )
Positional + Keyword Only                           __init__(self, a, *, b=None        )

また、標準の-prefix_規則を実装して、__init__クラスインスタンスに割り当てられない-private変数を許可します。 

###  StdLib  ###
from functools import wraps
import inspect


###########################################################################################################################
#//////|   Decorator   |//////////////////////////////////////////////////////////////////////////////////////////////////#
###########################################################################################################################

def auto_assign_arguments(function):

  @wraps(function)
  def wrapped(self, *args, **kwargs):
    _assign_args(self, list(args), kwargs, function)
    function(self, *args, **kwargs)

  return wrapped


###########################################################################################################################
#//////|   Utils   |//////////////////////////////////////////////////////////////////////////////////////////////////////#
###########################################################################################################################

def _assign_args(instance, args, kwargs, function):

  def set_attribute(instance, parameter, default_arg):
    if not(parameter.startswith("_")):
      setattr(instance, parameter, default_arg)

  def assign_keyword_defaults(parameters, defaults):
    for parameter, default_arg in zip(reversed(parameters), reversed(defaults)):
      set_attribute(instance, parameter, default_arg)

  def assign_positional_args(parameters, args):
    for parameter, arg in zip(parameters, args.copy()):
      set_attribute(instance, parameter, arg)
      args.remove(arg)

  def assign_keyword_args(kwargs):
    for parameter, arg in kwargs.items():
      set_attribute(instance, parameter, arg)
  def assign_keyword_only_defaults(defaults):
    return assign_keyword_args(defaults)

  def assign_variable_args(parameter, args):
    set_attribute(instance, parameter, args)

  POSITIONAL_PARAMS, VARIABLE_PARAM, _, KEYWORD_DEFAULTS, _, KEYWORD_ONLY_DEFAULTS, _ = inspect.getfullargspec(function)
  POSITIONAL_PARAMS = POSITIONAL_PARAMS[1:] # remove 'self'

  if(KEYWORD_DEFAULTS     ): assign_keyword_defaults     (parameters=POSITIONAL_PARAMS,  defaults=KEYWORD_DEFAULTS)
  if(KEYWORD_ONLY_DEFAULTS): assign_keyword_only_defaults(defaults=KEYWORD_ONLY_DEFAULTS                          )
  if(args                 ): assign_positional_args      (parameters=POSITIONAL_PARAMS,  args=args                )
  if(kwargs               ): assign_keyword_args         (kwargs=kwargs                                           )
  if(VARIABLE_PARAM       ): assign_variable_args        (parameter=VARIABLE_PARAM,      args=args                )


###########################################################################################################################$#//////|   Tests   |//////////////////////////////////////////////////////////////////////////////////////////////////////#$###########################################################################################################################$$if __name__ == "__main__":$$#######|   Positional   |##################################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, b):$      pass$$  t = T(1, 2)$  assert (t.a == 1) and (t.b == 2)$$#######|   Keyword   |#####################################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a="KW_DEFAULT_1", b="KW_DEFAULT_2"):$      pass$$  t = T(a="kw_arg_1", b="kw_arg_2")$  assert (t.a == "kw_arg_1") and (t.b == "kw_arg_2")$$#######|   Positional + Keyword   |########################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, b, c="KW_DEFAULT_1", d="KW_DEFAULT_2"):$      pass$$  t = T(1, 2)$  assert (t.a == 1) and (t.b == 2) and (t.c == "KW_DEFAULT_1") and (t.d == "KW_DEFAULT_2")$$  t = T(1, 2, c="kw_arg_1")$  assert (t.a == 1) and (t.b == 2) and (t.c == "kw_arg_1") and (t.d == "KW_DEFAULT_2")$$  t = T(1, 2, d="kw_arg_2")$  assert (t.a == 1) and (t.b == 2) and (t.c == "KW_DEFAULT_1") and (t.d == "kw_arg_2")$$#######|   Variable Positional   |#########################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, *a):$      pass$$  t = T(1, 2, 3)$  assert (t.a == [1, 2, 3])$$#######|   Variable Positional + Keyword   |###############################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, *a, b="KW_DEFAULT_1"):$      pass$$  t = T(1, 2, 3)$  assert (t.a == [1, 2, 3]) and (t.b == "KW_DEFAULT_1")$$  t = T(1, 2, 3, b="kw_arg_1")$  assert (t.a == [1, 2, 3]) and (t.b == "kw_arg_1")$$#######|   Variable Positional + Variable Keyword   |######################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, *a, **kwargs):$      pass$$  t = T(1, 2, 3, b="kw_arg_1", c="kw_arg_2")$  assert (t.a == [1, 2, 3]) and (t.b == "kw_arg_1") and (t.c == "kw_arg_2")$$#######|   Positional + Variable Positional + Keyword   |##################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, *b, c="KW_DEFAULT_1"):$      pass$$  t = T(1, 2, 3, c="kw_arg_1")$  assert (t.a == 1) and (t.b == [2, 3]) and (t.c == "kw_arg_1")$$#######|   Positional + Variable Positional + Variable Keyword   |#########################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, *b, **kwargs):$      pass$$  t = T(1, 2, 3, c="kw_arg_1", d="kw_arg_2")$  assert (t.a == 1) and (t.b == [2, 3]) and (t.c == "kw_arg_1") and (t.d == "kw_arg_2")$$#######|   Keyword Only   |################################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, *, a="KW_DEFAULT_1"):$      pass$$  t = T(a="kw_arg_1")$  assert (t.a == "kw_arg_1")$$#######|   Positional + Keyword Only   |###################################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, *, b="KW_DEFAULT_1"):$      pass$$  t = T(1)$  assert (t.a == 1) and (t.b == "KW_DEFAULT_1")$$  t = T(1, b="kw_arg_1")$  assert (t.a == 1) and (t.b == "kw_arg_1")$$#######|   Private __init__ Variables (underscored)   |####################################################################$$  class T:$    @auto_assign_arguments$    def __init__(self, a, b, _c):$      pass$$  t = T(1, 2, 3)$  assert hasattr(t, "a") and hasattr(t, "b") and not(hasattr(t, "_c"))

注意：

テストを含めましたが、簡潔にするために最後の行（58）にまとめました。find/replaceすべての$文字に改行を付けることで、考えられるすべてのユースケースを詳しく説明するテストを拡張できます。

— Enteleform
ソース
3

locals（）にはすでに値が含まれているため、変数を初期化する必要はないかもしれません。

クラスダミー（オブジェクト）：

def __init__(self, a, b, default='Fred'):
    self.params = {k:v for k,v in locals().items() if k != 'self'}

d =ダミー（2、3）

d.params

{'a'：2、 'b'：3、 'デフォルト'： 'フレッド'}

d.params ['b']

3

もちろん、クラス内ではself.paramsを使用できます

— user3215769
ソース
それは素晴らしく、独創的なアプローチだが、d['b']Pythonの中に書かれている共通語ながらd.params['b']コードリーダーのための混乱の原因となります。
— アダムマタン2014年
3

getargspecPython 3.5以降で非推奨になるとすぐに、以下を使用したソリューションがありますinspect.signature。

from inspect import signature, Parameter
import functools


def auto_assign(func):
    # Signature:
    sig = signature(func)
    for name, param in sig.parameters.items():
        if param.kind in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
            raise RuntimeError('Unable to auto assign if *args or **kwargs in signature.')
    # Wrapper:
    @functools.wraps(func)
    def wrapper(self, *args, **kwargs):
        for i, (name, param) in enumerate(sig.parameters.items()):
            # Skip 'self' param:
            if i == 0: continue
            # Search value in args, kwargs or defaults:
            if i - 1 < len(args):
                val = args[i - 1]
            elif name in kwargs:
                val = kwargs[name]
            else:
                val = param.default
            setattr(self, name, val)
        func(self, *args, **kwargs)
    return wrapper

動作するかどうかを確認します。

class Foo(object):
    @auto_assign
    def __init__(self, a, b, c=None, d=None, e=3):
        pass

f = Foo(1, 2, d="a")
assert f.a == 1
assert f.b == 2
assert f.c is None
assert f.d == "a"
assert f.e == 3

print("Ok")
— ミハイル・ゲラシモフ
ソース
2

Python 3.3以降の場合：

from functools import wraps
from inspect import Parameter, signature


def instance_variables(f):
    sig = signature(f)
    @wraps(f)
    def wrapper(self, *args, **kwargs):
        values = sig.bind(self, *args, **kwargs)
        for k, p in sig.parameters.items():
            if k != 'self':
                if k in values.arguments:
                    val = values.arguments[k]
                    if p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY):
                        setattr(self, k, val)
                    elif p.kind == Parameter.VAR_KEYWORD:
                        for k, v in values.arguments[k].items():
                            setattr(self, k, v) 
                else:
                    setattr(self, k, p.default) 
    return wrapper

class Point(object):
    @instance_variables 
    def __init__(self, x, y, z=1, *, m='meh', **kwargs):
        pass

デモ：

>>> p = Point('foo', 'bar', r=100, u=200)
>>> p.x, p.y, p.z, p.m, p.r, p.u
('foo', 'bar', 1, 'meh', 100, 200)

フレームを使用したPython2と3の両方の非デコレータアプローチ：

import inspect


def populate_self(self):
    frame = inspect.getouterframes(inspect.currentframe())[1][0]
    for k, v in frame.f_locals.items():
        if k != 'self':
            setattr(self, k, v)


class Point(object):
    def __init__(self, x, y):
        populate_self(self)

デモ： 

>>> p = Point('foo', 'bar')
>>> p.x
'foo'
>>> p.y
'bar'
— アシュウィニチャウダリー
ソース
1

nu11ptrは小さなモジュール、行ったPyInstanceVars関数デコレータとしてこの機能を含みます。モジュールのREADMEには、「[...]パフォーマンスはCPythonでの明示的な初期化よりも30〜40％だけ悪い」と記載されています。」と記載されています。

モジュールのドキュメントから直接取り上げた使用例：

>>> from instancevars import *
>>> class TestMe(object):
...     @instancevars(omit=['arg2_'])
...     def __init__(self, _arg1, arg2_, arg3='test'):
...             self.arg2 = arg2_ + 1
...
>>> testme = TestMe(1, 2)
>>> testme._arg1
1
>>> testme.arg2_
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'TestMe' object has no attribute 'arg2_'
>>> testme.arg2
3
>>> testme.arg3
'test'
— ベンレグン
ソース
0

これはクローズドな質問かもしれませんが、あなたがそれについてどう思うかを知るために、私の解決策を提案したいと思います。initメソッドにデコレータを適用するメタクラスを使用しました

import inspect

class AutoInit(type):
    def __new__(meta, classname, supers, classdict):
        classdict['__init__'] = wrapper(classdict['__init__'])
        return type.__new__(meta, classname, supers, classdict)

def wrapper(old_init):
    def autoinit(*args):
        formals = inspect.getfullargspec(old_init).args
        for name, value in zip(formals[1:], args[1:]):
            setattr(args[0], name, value)
    return autoinit
— delca85
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.