Pythonのカスタム属性

pythonに終止符を打ったときに何が起こるか疑問に思ったことはありますか？ str文字（“ \ u002E”）は何を隠していますか？ 彼はどのような秘密を保持していますか？ 神秘主義がなければ、Pythonでユーザー属性の値を検索して設定する方法を知っていますか？ 知りたいですか？ その後...ようこそ！

読みやすく、楽しく、便利な時間を過ごすために、言語のいくつかの基本的な概念を知っておくといいでしょう。 特に、 型とオブジェクトを理解することは非常に役立ち、両方のエンティティのいくつかの例を知ることもできます。 ここを含め、それらについて読むことができます 。

収集したポイントに到達する前に使用する用語について少し説明します。

• オブジェクトとは、Pythonの任意のエンティティ（関数、数値、文字列...つまり、それです）です。
• クラスは、タイプがタイプのオブジェクトです（タイプは__class__属性で確認できます）。
• クラスA のインスタンスは 、 __ class__属性でクラスAへの参照を持つオブジェクトです。

そうそう、記事の例はすべてpython3で書かれています ！ これは間違いなく考慮されるべきです。

上記のどれもが、次に何が起こるかを知りたいというあなたの欲望を和らげることができなかったら、始めましょう！

__dict__

オブジェクトの属性は、条件付きで2つのグループに分けることができます。Pythonで定義されたもの（ __class__ 、 __bases__など ）とユーザー定義されたものです。 この分類による__dict__は、「システム」（pythonで定義）属性を指します。 そのタスクは、ユーザー属性を保存することです。 これは辞書であり、キーはそれぞれattribute_name 、value、 attribute_valueです 。

oオブジェクトの属性を見つけるために、pythonは以下をスキャンします：

1. オブジェクト自体（ o .__ dict__およびそのシステム属性）。
2. オブジェクトクラス（ o .__ class __.__ dict__ ）。 システム属性ではなく、 __ dict__クラスのみ。
3. オブジェクトクラスの継承元のクラス（ o .__ class __.__ bases __.__ dict__ ）。

したがって、 __ dict__を使用すると、特定のインスタンスとクラス（つまり、特定のクラスのインスタンスであるすべてのオブジェクト）の両方に対して属性を定義できます。

class StuffHolder: stuff = "class stuff" a = StuffHolder() b = StuffHolder() a.stuff # "class stuff" b.stuff # "class stuff" b.b_stuff = "b stuff" b.b_stuff # "b stuff" a.b_stuff # AttributeError
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、両方のインスタンスが継承する1つの属性stuffを持つStuffHolderクラスについて説明します。 オブジェクトbに b_stuff属性を追加しても、 aには影響しません。

すべてのアクターの__dict__を見てみましょう。

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} a.__dict__ # {} b.__dict__ # {'b_stuff': 'b stuff'} a.__class__ # <class '__main__.StuffHolder'> b.__class__ # <class '__main__.StuffHolder'>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

_{（ __dict__のStuffHolderクラスは、さまざまなジャンクを持つdict_proxyクラスのオブジェクトを格納しますが、まだ注意を払う必要はありません）。}



__dict__の aもbもstuff属性を持ちません。そこで見つけることなく、検索エンジンは__dict__クラス（ StuffHolder ）でそれを検索し、クラスで割り当てられた値を見つけて返します。 クラス参照は、オブジェクトの__class__属性に格納されます。

属性の検索は実行時に行われるため、インスタンスを作成した後でも、 __ dict__クラスに対するすべての変更がそれらに反映されます。

 a.new_stuff # AttributeError b.new_stuff # AttributeError StuffHolder.new_stuff = "new" StuffHolder.__dict__ # {... 'stuff': 'class stuff', 'new_stuff': 'new'...} a.new_stuff # "new" b.new_stuff # "new"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

インスタンス属性に値を割り当てる場合、 __dict__インスタンスのみが変更されます 。つまり、 __dict__クラスの値は変更されません（クラス属性値がデータ記述子でない場合）：

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} c = StuffHolder() c.__dict__ # {} c.stuff = "more c stuff" c.__dict__ # {'stuff': 'more c stuff'} StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

クラスの属性名とインスタンスが一致する場合、インタプリタは値を検索するときにインスタンスの値を検索します（クラス属性の値がデータ記述子でない場合）：

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} d = StuffHolder() d.stuff # "class stuff" d.stuff = "d stuff" d.stuff # "d stuff"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

概して 、これが__dict__について言えることのすべてです。 これは、ユーザー定義の属性のリポジトリです。 実行時に検索され、検索中にオブジェクトの__dict__クラスと基本クラスが考慮されます。 また、この動作をオーバーライドする方法がいくつかあることを知っておくことが重要です。 それらの1つは、偉大で強力な記述子です！

記述子

属性値として単純型を使用すると、これまでのところすべてが明確になりました。 同じ条件下で関数がどのように動作するかを見てみましょう。

 class FuncHolder: def func(self): pass fh = FuncHolder() FuncHolder.func # <function func at 0x8f806ac> FuncHolder.__dict__ # {...'func': <function func at 0x8f806ac>...} fh.func # <bound method FuncHolder.func of <__main__.FuncHolder object at 0x900f08c>>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

WTF！？ たぶん...多分。 お願いします。 この場合の機能は、すでに見たものとどのように異なりますか？ 答えは簡単です。__get__メソッドを使用します。

 FuncHolder.func.__class__.__get__ # <slot wrapper '__get__' of 'function' objects>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このメソッドは、 fhインスタンスのfunc属性の値を取得するメカニズムをオーバーライドし、このメソッドを実装するオブジェクトは、 非データ記述子と呼ばれる翻訳不可能です。



howtoから：

記述子は、プロトコル記述子のメソッドによって属性を介して再定義されるオブジェクトアクセスです 。

 descr .__ get __（self、obj、type = None）-> value（属性値の受け取り方法をオーバーライドします）
 descr .__ set __（self、obj、value）-> None（属性に値が割り当てられる方法をオーバーライドします）
 descr .__ delete __（self、obj）-> None（属性の削除方法をオーバーライドします）

記述子には2つのタイプがあります。

1. データ記述子-__get __（）および__set __（）メソッドを実装するオブジェクト
2. 非データ記述子（データ記述子ではない？） -__get __（）メソッドを実装するオブジェクト

これらは、 __ dict__インスタンスのエントリに関する動作が異なります。 __dict__にデータ記述子と同じ名前のエントリがある場合、記述子には利点があります。 レコードの名前が「データ記述子なし」の名前と一致する場合、 __ dict__のレコードの優先順位は高くなります。

データ記述子

データ記述子を詳しく見てみましょう。

 class DataDesc: def __get__(self, obj, cls): print("Trying to access from {0} class {1}".format(obj, cls)) def __set__(self, obj, val): print("Trying to set {0} for {1}".format(val, obj)) def __delete__(self, obj): print("Trying to delete from {0}".format(obj)) class DataHolder: data = DataDesc() d = DataHolder() DataHolder.data # Trying to access from None class <class '__main__.DataHolder'> d.data # Trying to access from <__main__.DataHolder object at ...> class <class '__main__.DataHolder'> d.data = 1 # Trying to set 1 for <__main__.DataHolder object at ...> del(d.data) # Trying to delete from <__main__.DataHolder object at ...>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

DataHolder.dataの呼び出しが、クラスのインスタンスではなく__get__ Noneメソッドに渡されることに注意してください。

日付記述子が__dict__インスタンスのエントリよりも有利であるというステートメントを検証してみましょう。

 d.__dict__["data"] = "override!" d.__dict__ # {'data': 'override!'} d.data # Trying to access from <__main__.DataHolder object at ...> class <class '__main__.DataHolder'>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

つまり、 __ dict__インスタンスクラス（またはその基本クラス）に同じ名前と値（データ記述子）のエントリがある場合、 __ dict__インスタンスのエントリは無視されます。



もう一つの重要なポイント。 クラスを通じて記述子を使用して属性の値を変更すると、記述子メソッドは呼び出されず、クラスの__dict__の値は通常の属性であるかのように変更されます。

 DataHolder.__dict__ # {...'data': <__main__.DataDesc object at ...>...} DataHolder.data = "kick descriptor out" DataHolder.__dict__ # {...'data': 'kick descriptor out'...} DataHolder.data # "kick descriptor out"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

データ記述子なし

非データ記述子の例：

 class NonDataDesc: def __get__(self, obj, cls): print("Trying to access from {0} class {1}".format(obj, cls)) class NonDataHolder: non_data = NonDataDesc() n = NonDataHolder() NonDataHolder.non_data # Trying to access from None class <class '__main__.NonDataHolder'> n.non_data # Trying to access from <__main__.NonDataHolder object at ...> class <class '__main__.NonDataHolder'> n.non_data = 1 n.non_data # 1 n.__dict__ # {'non_data': 1}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

彼の振る舞いは、データ記述子がしたこととは少し異なります。 non_data属性に値を割り当てようとすると、 __ dict__インスタンスに書き込まれたため、 __ dict__クラスに格納されているハンドルが非表示になりました。

使用例

記述子は、クラスのインスタンスの属性へのアクセスを制御できる強力なツールです。 それらの使用の一例は関数です;インスタンスを通して呼び出されると、それらはメソッドになります（上記の例を参照）。 記述子を使用するもう1つの一般的な方法は、 プロパティを作成することです。 プロパティとは、オブジェクトの状態を特徴付ける特定の値を意味し、そのアクセスは特別なメソッド（ゲッター、セッター）を使用して制御されます。 記述子を使用してプロパティを作成するのは簡単です。

 class Descriptor: def __get__(self, obj, type): print("getter used") def __set__(self, obj, val): print("setter used") def __delete__(self, obj): print("deleter used") class MyClass: prop = Descriptor()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

または、組み込みクラスプロパティを使用できます。これはデータ記述子です。 上記のコードは次のように書き換えることができます。

 class MyClass: def _getter(self): print("getter used") def _setter(self, val): print("setter used") def _deleter(self): print("deleter used") prop = property(_getter, _setter, _deleter, "doc string")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

どちらの場合でも、同じ動作が得られます。

 m = MyClass() m.prop # getter used m.prop = 1 # setter used del(m.prop) # deleter used
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プロパティは常にデータ記述子であることを知っておくことが重要です。 コンストラクター（getter、setter、またはdeliter）に関数を渡さない場合、属性に対して対応するアクションを実行しようとすると、 AttributeErrorがスローされます。

 class MySecondClass: prop = property() m2 = MySecondClass() m2.prop # AttributeError: unreadable attribute m2.prop = 1 # AttributeError: can't set attribute del(m2) # AttributeError: can't delete attribute
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

組み込み記述子には次のものも含まれます。

• staticmethod-クラス外の関数と同じで、インスタンスは最初の引数として渡されません 。
• classmethod-クラスメソッドと同じ、インスタンスクラスのみが最初の引数として渡されます。

 class StaticAndClassMethodHolder: def _method(*args): print("_method called with ", args) static = staticmethod(_method) cls = classmethod(_method) s = StaticAndClassMethodHolder() s._method() # _method called with (<__main__.StaticAndClassMethodHolder object at ...>,) s.static() # _method called with () s.cls() # _method called with (<class '__main__.StaticAndClassMethodHolder'>,)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

__getattr __（）、__ setattr __（）、__ delattr __（）および__getattribute __（）

オブジェクトの動作を属性として決定する場合は、記述子（たとえば、 property ）を使用する必要があります。 オブジェクトのファミリ（ 関数など ）についても同様です。 属性へのアクセスに影響を与える別の方法は、 __ getattr __（） 、 __setattr __（）、__delattr __（）、および__getattribute __（）メソッドを使用することです。 記述子とは異なり、 属性を含むオブジェクトに対して定義する必要があり、このオブジェクトの属性にアクセスするときに呼び出されます。



要求された属性が通常のメカニズム（ __dict__インスタンス、クラスなど）で見つからない場合、 __ getattr __（self、name）が呼び出されます。

 class SmartyPants: def __getattr__(self, attr): print("Yep, I know", attr) tellme = "It's a secret" smarty = SmartyPants() smarty.name = "Smartinius Smart" smarty.quicksort # Yep, I know quicksort smarty.python # Yep, I know python smarty.tellme # "It's a secret" smarty.name # "Smartinius Smart"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

属性値を取得しようとすると、__ getattribute __（self、name）が呼び出されます。 このメソッドがオーバーライドされた場合、標準の属性値検索メカニズムは有効になりません。 組み込み関数を介した特別なメソッド（ __len __（） 、 __str __（）など）の呼び出し、または言語構文を介した暗黙的な呼び出しは、 __getattribute __（）をバイパスすることに注意してください。

 class Optimist: attr = "class attribute" def __getattribute__(self, name): print("{0} is great!".format(name)) def __len__(self): print("__len__ is special") return 0 o = Optimist() o.instance_attr = "instance" o.attr # attr is great! o.dark_beer # dark_beer is great! o.instance_attr # instance_attr is great! o.__len__ # __len__ is great! len(o) # __len__ is special\n 0
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

インスタンス属性の値を設定しようとすると、__ setattr __（self、name、value）が呼び出されます。 __getattribute __（）と同様に、このメソッドがオーバーライドされた場合、標準値設定メカニズムは使用されません。

 class NoSetters: attr = "class attribute" def __setattr__(self, name, val): print("not setting {0}={1}".format(name,val)) no_setters = NoSetters() no_setters.a = 1 # not setting a=1 no_setters.attr = 1 # not setting attr=1 no_setters.__dict__ # {} no_setters.attr # "class attribute" no_setters.a # AttributeError
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

__delattr __（self、name） -__setattr __（）に似ていますが、属性を削除するときに使用されます。



__getattribute __（） 、 __setattr __（）、および__delattr __（）をオーバーライドする場合、属性にアクセスする標準的な方法はオブジェクトを介して呼び出すことができることに注意してください。

 class GentleGuy: def __getattribute__(self, name): if name.endswith("_please"): return object.__getattribute__(self, name.replace("_please", "")) raise AttributeError("And the magic word!?") gentle = GentleGuy() gentle.coffee = "some coffee" gentle.coffee # AttributeError gentle.coffee_please # "some coffee"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

塩

したがって、Pythonのaのインスタンスのattrname属性値を取得するには：

1. .__ class __.__ getattribute __（）メソッドが定義されている場合、このメソッドが呼び出され、受信した値が返されます。
2. attrnameが__class__や__doc__などの特別な（pythonで定義された）属性である場合、その値が返されます。
3. .__ class __.__ dict__でattrnameを持つエントリをチェックします 。 存在し、値がデータ記述子である場合、 記述子の__get __（）メソッドを呼び出した結果が返されます。 すべての基本クラスもチェックされます。
4. attrnameという名前のエントリが.__ dict__に存在する場合、そのエントリの値が返されます。 aがクラスの場合、属性はその基本クラス間でも検索され、データ記述子がある場合、または__dict__に ある場合、記述子の__get __（）の結果が返されます。
5. .__ class __.__ dict__をチェックし、 attrnameを含むエントリがあり、これが「データ記述子」である場合、結果は記述子の__get __（）になります。レコードが存在し、記述子がない場合、レコードの値が返されます。 基本クラスも検索されます。
6. .__ class __.__ getattr __（）メソッドが存在する場合、それが呼び出され、その結果が返されます。 そのようなメソッドがない場合、 AttributeErrorがスローされます。

インスタンスaの attrname属性の値を設定するには ：

1. .__ class __.__ setattr __（）メソッドが存在する場合、呼び出されます。
2. .__ class __.__ dict__をチェックします。attrnameを持つエントリがあり、これがデータ記述子である場合、記述子の__set __（）メソッドが呼び出されます。 基本クラスもチェックされます。
3. attrnameキーを持つ値エントリが.__ dict__に追加されます

__slots__

Guidoが新しいスタイルのクラスがどのように発明されたかについてのpythonストーリーで書いているように：

...クラスシステムの変更がパフォーマンスに悪影響を与えるのではないかと心配しました。 特に、データ記述子が正しく機能するために、オブジェクトの属性を使用したすべての操作は、この属性がデータ記述子であるという事実について__dict__クラスをチェックすることから始まりました...

ユーザーがパフォーマンスの低下に失望した場合、思いやりのあるPython開発者は__slots__を思いつきました 。

__slots__の存在は、オブジェクトの可能な属性名をそこに示されているものに制限します。 また、すべての属性名が事前にわかっているため、 __ dict__インスタンスを作成する必要がなくなります。

 class Slotter: __slots__ = ["a", "b"] s = Slotter() s.__dict__ # AttributeError sc = 1 # AttributeError sa = 1 sa # 1 sb = 1 sb # 1 dir(s) # [ ... 'a', 'b' ... ]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ギドの恐怖は実現しなかったことが判明しましたが、明らかになるまでにはすでに手遅れでした。 さらに、 __ slots__を使用すると、特に多くの小さなオブジェクトを作成するときに使用されるメモリの量を減らすことにより、実際にパフォーマンスを向上させることができます。

おわりに

Pythonの属性へのアクセスは、非常に多くの方法で制御できます。 それらはそれぞれ独自の問題を解決し、一緒にオブジェクトを使用するほとんどすべての考えられるシナリオに適しています。 これらのメカニズムは、複数の継承、メタクラス、およびその他の利点とともに、言語の柔軟性の基礎です。 属性を処理するためのこの多くのオプションを理解し、理解し、そして最も重要なことには受け入れるのに時間がかかりました。 一見、少し冗長で、特に論理的ではないように見えますが、これが日常のプログラミングではほとんど役に立たないことを考えると、このような強力なツールを武器に持つことは素晴らしいことです。

この記事で、あなたの手が通り抜けられなかったいくつかのポイントを明確にしてほしいと思います。 そして今、あなたの目に火をつけ、Pointに自信を持っているので、コード要件の変更に対して、最もクリーンで読みやすく、耐性のある膨大な量を書きます！ まあ、またはコメント。



お時間をいただきありがとうございます。

参照資料

1. シャラブチャトゥルベディ。 Pythonの属性とメソッド
2. グイドヴァンロッサム。 新しいスタイルのクラスの内部ストーリー
3. Pythonドキュメント

UPD：ユーザーleronからの便利なリンク： Python Data Model