Pythonのメタクラスとは何ですか?

5940
e-satis 2008-09-19 20:10.

Pythonでは、メタクラスとは何ですか?また、それらを何に使用しますか?

21 answers

3046
Thomas Wouters 2008-09-19 21:01.

メタクラスは、クラスのクラスです。クラスはクラスのインスタンス(つまりオブジェクト)の動作を定義し、メタクラスはクラスの動作を定義します。クラスはメタクラスのインスタンスです。

Pythonでは(Jerubが示すように)メタクラスに任意の呼び出し可能オブジェクトを使用できますが、より良いアプローチはそれ自体を実際のクラスにすることです。typePythonの通常のメタクラスです。typeそれ自体がクラスであり、それ自体のタイプです。type純粋にPythonのようなものを再現することはできませんが、Pythonは少しごまかします。Pythonで独自のメタクラスを作成するには、実際にはサブクラスを作成するだけですtype

メタクラスは、クラスファクトリとして最も一般的に使用されます。クラスを呼び出してオブジェクトを作成すると、Pythonはメタクラスを呼び出して( 'class'ステートメントを実行するときに)新しいクラスを作成します。したがって、メタクラスを通常のメソッド__init__および__new__メソッドと組み合わせると、クラスを作成するときに、新しいクラスをレジストリに登録したり、クラスを完全に別のものに置き換えたりするなど、「余分なこと」を行うことができます。

場合classステートメントが実行され、Pythonは最初のボディ実行classコードの通常のブロックとしてステートメント。結果の名前空間(dict)は、クラスの属性を保持します。メタクラスは、将来のクラスの基本クラス(メタクラスは継承されます)、将来のクラスの__metaclass__属性(存在する場合)、または__metaclass__グローバル変数を調べることによって決定されます。次に、メタクラスは、クラスの名前、ベース、および属性を使用して呼び出され、インスタンス化されます。

ただし、メタクラスは実際にはクラスのファクトリだけでなく、クラスのタイプを定義するため、メタクラスを使用してさらに多くのことを実行できます。たとえば、メタクラスで通常のメソッドを定義できます。これらのメタクラスメソッドは、インスタンスなしでクラスで呼び出すことができるという点でクラスメソッドに似ていますが、クラスのインスタンスで呼び出すことができないという点でクラスメソッドとは異なります。メタクラスのtype.__subclasses__()メソッドの例ですtype。また、のような、通常の「魔法」のメソッドを定義することができ__add____iter__そして__getattr__、どのようにクラスの振る舞いを実装または変更します。

これは、断片の集約された例です。

def make_hook(f):
    """Decorator to turn 'foo' method into '__foo__'"""
    f.is_hook = 1
    return f

class MyType(type):
    def __new__(mcls, name, bases, attrs):

        if name.startswith('None'):
            return None

        # Go over attributes and see if they should be renamed.
        newattrs = {}
        for attrname, attrvalue in attrs.iteritems():
            if getattr(attrvalue, 'is_hook', 0):
                newattrs['__%s__' % attrname] = attrvalue
            else:
                newattrs[attrname] = attrvalue

        return super(MyType, mcls).__new__(mcls, name, bases, newattrs)

    def __init__(self, name, bases, attrs):
        super(MyType, self).__init__(name, bases, attrs)

        # classregistry.register(self, self.interfaces)
        print "Would register class %s now." % self

    def __add__(self, other):
        class AutoClass(self, other):
            pass
        return AutoClass
        # Alternatively, to autogenerate the classname as well as the class:
        # return type(self.__name__ + other.__name__, (self, other), {})

    def unregister(self):
        # classregistry.unregister(self)
        print "Would unregister class %s now." % self

class MyObject:
    __metaclass__ = MyType


class NoneSample(MyObject):
    pass

# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
    def __init__(self, value):
        self.value = value
    @make_hook
    def add(self, other):
        return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
    pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__
7068
e-satis 2011-07-06 01:29.

オブジェクトとしてのクラス

メタクラスを理解する前に、Pythonでクラスをマスターする必要があります。そしてPythonは、Smalltalk言語から借用した、クラスが何であるかについて非常に独特な考えを持っています。

ほとんどの言語では、クラスはオブジェクトの作成方法を説明するコードの一部にすぎません。これはPythonにも当てはまります。

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

しかし、クラスはPythonのクラス以上のものです。クラスもオブジェクトです。

はい、オブジェクト。

キーワードを使用するとすぐにclass、Pythonはそれを実行し、オブジェクトを作成します。指示

>>> class ObjectCreator(object):
...       pass
...

「ObjectCreator」という名前のオブジェクトをメモリ内に作成します。

このオブジェクト(クラス)はそれ自体がオブジェクト(インスタンス)を作成することができ、これがクラスである理由です。

しかし、それでも、それはオブジェクトであるため、次のようになります。

  • あなたはそれを変数に割り当てることができます
  • あなたはそれをコピーすることができます
  • あなたはそれに属性を追加することができます
  • 関数パラメータとして渡すことができます

例えば:

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

クラスを動的に作成する

クラスはオブジェクトであるため、他のオブジェクトと同様に、その場で作成できます。

まず、次を使用して関数にクラスを作成できますclass

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

ただし、クラス全体を自分で作成する必要があるため、それほど動的ではありません。

クラスはオブジェクトであるため、何かによって生成される必要があります。

classキーワードを使用すると、Pythonはこのオブジェクトを自動的に作成します。しかし、Pythonのほとんどのものと同様に、手動でそれを行う方法を提供します。

機能を覚えていますtypeか?オブジェクトのタイプを知ることができる古き良き関数:

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

まあ、typeまったく異なる能力を持っています、それはまたその場でクラスを作成することができます。typeクラスの説明をパラメータとして受け取り、クラスを返すことができます。

(私は、同じ関数が、渡されたパラメーターに応じて2つの完全に異なる用途を持つことができるのはばかげています。これは、Pythonの下位互換性による問題です)

type このように機能します:

type(name, bases, attrs)

どこ:

  • name:クラスの名前
  • bases:親クラスのタプル(継承の場合、空にすることができます)
  • attrs:属性の名前と値を含む辞書

例えば:

>>> class MyShinyClass(object):
...       pass

この方法で手動で作成できます。

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

クラスの名前およびクラス参照を保持する変数として「MyShinyClass」を使用していることに気付くでしょう。それらは異なる可能性がありますが、物事を複雑にする理由はありません。

typeクラスの属性を定義する辞書を受け入れます。そう:

>>> class Foo(object):
...       bar = True

次のように翻訳できます:

>>> Foo = type('Foo', (), {'bar':True})

そして、通常のクラスとして使用されます:

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

そしてもちろん、あなたはそれから継承することができます、それで:

>>>   class FooChild(Foo):
...         pass

だろう:

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

最終的には、クラスにメソッドを追加する必要があります。適切なシグニチャを使用して関数を定義し、それを属性として割り当てるだけです。

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

また、通常作成されるクラスオブジェクトにメソッドを追加するのと同じように、クラスを動的に作成した後、さらに多くのメソッドを追加できます。

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

Pythonでは、クラスはオブジェクトであり、その場で動的にクラスを作成できます。

これは、キーワードを使用するときにPythonが行うことclassであり、メタクラスを使用して行います。

メタクラスとは(最終的に)

メタクラスは、クラスを作成する「もの」です。

オブジェクトを作成するためにクラスを定義しますよね?

しかし、Pythonクラスはオブジェクトであることを学びました。

さて、メタクラスはこれらのオブジェクトを作成するものです。それらはクラスのクラスであり、次のように描くことができます。

MyClass = MetaClass()
my_object = MyClass()

あなたはそれtypeがあなたがこのようなことをすることを可能にするのを見てきました:

MyClass = type('MyClass', (), {})

これtypeは、関数が実際にはメタクラスであるためです。typePythonが舞台裏ですべてのクラスを作成するために使用するメタクラスです。

なぜそれが小文字で書かれているのか、そうではないのか疑問に思いますかType

まあ、strそれは、文字列オブジェクトintを作成するクラス、および整数オブジェクトを作成するクラスとの一貫性の問題だと思います。typeクラスオブジェクトを作成するクラスです。

__class__属性を確認するとわかります。

すべて、つまりすべてがPythonのオブジェクトです。これには、int、文字列、関数、およびクラスが含まれます。それらはすべてオブジェクトです。そして、それらはすべてクラスから作成されています。

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

さて、何で__class__どんなのは__class__

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

したがって、メタクラスはクラスオブジェクトを作成するものにすぎません。

必要に応じて、「クラスファクトリ」と呼ぶことができます。

type Pythonが使用する組み込みのメタクラスですが、もちろん、独自のメタクラスを作成することもできます。

__metaclass__属性

Python 2では__metaclass__、クラスを作成するときに属性を追加できます(Python 3の構文については次のセクションを参照してください)。

class Foo(object):
    __metaclass__ = something...
    [...]

その場合、Pythonはメタクラスを使用してクラスを作成しますFoo

注意してください、それはトリッキーです。

class Foo(object)最初に書き込みますが、クラスオブジェクトFooはまだメモリに作成されていません。

Pythonは__metaclass__クラス定義で検索します。見つかった場合は、それを使用してオブジェクトクラスを作成しますFoo。そうでない場合はtype、クラスの作成に使用されます。

それを数回読んでください。

あなたがするとき:

class Foo(Bar):
    pass

Pythonは次のことを行います。

__metaclass__属性はありますFooか?

はいの場合は、メモリ内にクラスオブジェクトを作成します(クラスオブジェクトと言いましたが、ここにいてください)。名前Fooは、にあるものを使用し__metaclass__ます。

Pythonがが見つからない場合は、MODULEレベルで__metaclass__を検索__metaclass__し、同じことを試みます(ただし、何も継承しないクラス、基本的には古いスタイルのクラスのみ)。

次に、何も見つからない場合__metaclass__は、Bar's(最初の親)独自のメタクラス(デフォルトの場合がありますtype)を使用してクラスオブジェクトを作成します。

ここでは、__metaclass__属性が継承されず、親(Bar.__class__)のメタクラスが継承されることに注意してください。で作成された(ではなく)属性をBar使用した場合、サブクラスはその動作を継承しません。__metaclass__Bartype()type.__new__()

さて、大きな問題は、何を入れることができるかということです__metaclass__

答えは、クラスを作成できるものです。

そして、何がクラスを作成できますか?type、またはそれをサブクラス化または使用するもの。

Python3のメタクラス

Python 3では、メタクラスを設定するための構文が変更されました。

class Foo(object, metaclass=something):
    ...

つまり、__metaclass__基本クラスのリストのキーワード引数を優先して、属性は使用されなくなりました。

ただし、メタクラスの動作はほぼ同じです。

Python 3でメタクラスに追加された1つのことは、次のように、属性をキーワード引数としてメタクラスに渡すこともできることです。

class Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):
    ...

Pythonがこれを処理する方法については、以下のセクションをお読みください。

カスタムメタクラス

メタクラスの主な目的は、作成時にクラスを自動的に変更することです。

これは通常、現在のコンテキストに一致するクラスを作成するAPIに対して行います。

モジュール内のすべてのクラスの属性を大文字で記述する必要があると判断した愚かな例を想像してみてください。これを行うにはいくつかの方法がありますが、1つの方法は__metaclass__モジュールレベルで設定することです。

このように、このモジュールのすべてのクラスはこのメタクラスを使用して作成され、すべての属性を大文字に変換するようにメタクラスに指示する必要があります。

幸いなことに、__metaclass__実際には任意の呼び出し可能であり、正式なクラスである必要はありません(名前に「class」が含まれているものは、クラスである必要はありません。図を見てください...しかし、それは役に立ちます)。

そこで、関数を使った簡単な例から始めましょう。

# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attrs):
    """
      Return a class object, with the list of its attribute turned
      into uppercase.
    """
    # pick up any attribute that doesn't start with '__' and uppercase it
    uppercase_attrs = {
        attr if attr.startswith("__") else attr.upper(): v
        for attr, v in future_class_attrs.items()
    }

    # let `type` do the class creation
    return type(future_class_name, future_class_parents, uppercase_attrs)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with "object" though
    # but we can define __metaclass__ here instead to affect only this class
    # and this will work with "object" children
    bar = 'bip'

確認しよう:

>>> hasattr(Foo, 'bar')
False
>>> hasattr(Foo, 'BAR')
True
>>> Foo.BAR
'bip'

さて、まったく同じことをしましょう。ただし、メタクラスに実際のクラスを使用します。

# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
    # __new__ is the method called before __init__
    # it's the method that creates the object and returns it
    # while __init__ just initializes the object passed as parameter
    # you rarely use __new__, except when you want to control how the object
    # is created.
    # here the created object is the class, and we want to customize it
    # so we override __new__
    # you can do some stuff in __init__ too if you wish
    # some advanced use involves overriding __call__ as well, but we won't
    # see this
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in future_class_attrs.items()
        }
        return type(future_class_name, future_class_parents, uppercase_attrs)

上記を書き直してみましょう。ただし、変数名の意味がわかったので、より短く、より現実的な変数名を使用します。

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type(clsname, bases, uppercase_attrs)

あなたは余分な議論に気づいたかもしれませんcls。特別なことは何もありません__new__。最初のパラメーターとして、定義されているクラスを常に受け​​取ります。ちょうどあなたが持っているようにself、最初のパラメータ、またはクラスメソッドの定義クラスとしてインスタンスを受け取る通常の方法のために。

しかし、これは適切なOOPではありません。私たちは、呼び出しているtype直接、私たちは親のを上書きするか、呼び出しされていません__new__。代わりにそれをやってみましょう:

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type.__new__(cls, clsname, bases, uppercase_attrs)

を使用することで、さらにクリーンにすることができます。これによりsuper、継承が容易になります(はい、メタクラス、メタクラスからの継承、型からの継承が可能であるため)。

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return super(UpperAttrMetaclass, cls).__new__(
            cls, clsname, bases, uppercase_attrs)

ああ、Python 3では、次のようにキーワード引数を使用してこの呼び出しを行うと、次のようになります。

class Foo(object, metaclass=MyMetaclass, kwarg1=value1):
    ...

それを使用するために、メタクラスでこれに変換されます。

class MyMetaclass(type):
    def __new__(cls, clsname, bases, dct, kwargs1=default):
        ...

それでおしまい。メタクラスについては、これ以上何もありません。

メタクラスを使用するコードの複雑さの背後にある理由は、メタクラスが原因ではありません。通常、メタクラスを使用して、イントロスペクション、継承の操作、変数などに依存するねじれた処理を実行するためです__dict__

確かに、メタクラスは黒魔術を行うのに特に役立ち、したがって複雑なことをします。しかし、それ自体は単純です。

  • クラス作成をインターセプトする
  • クラスを変更する
  • 変更されたクラスを返す

関数の代わりにメタクラスクラスを使用するのはなぜですか?

__metaclass__呼び出し可能なものはすべて受け入れることができるので、明らかに複雑なクラスを使用するのはなぜですか?

そうする理由はいくつかあります。

  • 意図は明らかです。あなたが読むときUpperAttrMetaclass(type)、あなたは何が続くのかを知っています
  • OOPを使用できます。メタクラスはメタクラスから継承し、親メソッドをオーバーライドできます。メタクラスはメタクラスを使用することもできます。
  • メタクラスを指定した場合、クラスのサブクラスはそのメタクラスのインスタンスになりますが、メタクラス関数では指定しません。
  • コードをより適切に構造化できます。上記の例のように些細なことでメタクラスを使用することは決してありません。それは通常、何か複雑なもののためのものです。複数のメソッドを作成し、それらを1つのクラスにグループ化する機能があると、コードを読みやすくするのに非常に役立ちます。
  • あなたは上のフックすることができ__new____init__そして__call__。これにより、さまざまなことができるようになります。通常はすべてを実行できる場合でも、__new__を使用する方が快適な人もい__init__ます。
  • これらはメタクラスと呼ばれています。それは何かを意味するに違いありません!

なぜメタクラスを使用するのですか?

さて、大きな問題です。エラーが発生しやすいあいまいな機能を使用するのはなぜですか?

まあ、通常はしません:

メタクラスはより深い魔法であり、99%のユーザーがそれについて心配する必要はありません。あなたがそれらを必要とするかどうか疑問に思うなら、あなたは必要ありません(実際にそれらを必要とする人々は、彼らがそれらを必要とし、理由についての説明を必要としないことを確実に知る必要があります)。

Pythonの第一人者TimPeters

メタクラスの主なユースケースは、APIの作成です。この典型的な例は、DjangoORMです。これにより、次のようなものを定義できます。

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

しかし、これを行う場合:

person = Person(name='bob', age='35')
print(person.age)

IntegerFieldオブジェクトは返されません。を返しint、データベースから直接取得することもできます。

これが可能なのmodels.Model__metaclass__Person定義し、単純なステートメントで定義したばかりの魔法をデータベースフィールドへの複雑なフックに変える魔法を使用しているためです。

Djangoは、単純なAPIを公開し、メタクラスを使用して、このAPIからコードを再作成し、舞台裏で実際の仕事を行うことで、複雑なものを単純に見せます。

最後の言葉

まず、クラスはインスタンスを作成できるオブジェクトであることを知っています。

実際、クラスはそれ自体がインスタンスです。メタクラスの。

>>> class Foo(object): pass
>>> id(Foo)
142630324

すべてがPythonのオブジェクトであり、それらはすべてクラスのインスタンスまたはメタクラスのインスタンスのいずれかです。

を除いてtype

type実際にはそれ自体のメタクラスです。これは純粋なPythonで再現できるものではなく、実装レベルで少しごまかすことによって行われます。

第二に、メタクラスは複雑です。非常に単純なクラス変更には使用したくない場合があります。次の2つの異なる手法を使用して、クラスを変更できます。

  • モンキーパッチ
  • クラスデコレータ

クラスの変更が必要な時間の99%は、これらを使用することをお勧めします。

しかし、98%の場合、クラスを変更する必要はまったくありません。

424
Jerub 2008-09-19 20:26.

この回答は、2008年に作成されたPython 2.xに対するものであり、メタクラスは3.xではわずかに異なることに注意してください。

メタクラスは、「クラス」を機能させる秘訣です。新しいスタイルオブジェクトのデフォルトのメタクラスは「type」と呼ばれます。

class type(object)
  |  type(object) -> the object's type
  |  type(name, bases, dict) -> a new type

メタクラスは3つの引数を取ります。'名前'、 'ベース'および '辞書'

ここから秘密が始まります。この例のクラス定義で、名前、ベース、およびdictがどこから来ているかを探します。

class ThisIsTheName(Bases, Are, Here):
    All_the_code_here
    def doesIs(create, a):
        dict

' class: 'がどのように呼び出すかを示すメタクラスを定義しましょう。

def test_metaclass(name, bases, dict):
    print 'The Class Name is', name
    print 'The Class Bases are', bases
    print 'The dict has', len(dict), 'elems, the keys are', dict.keys()

    return "yellow"

class TestName(object, None, int, 1):
    __metaclass__ = test_metaclass
    foo = 1
    def baz(self, arr):
        pass

print 'TestName = ', repr(TestName)

# output => 
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName =  'yellow'

そして今、実際に何かを意味する例では、これにより、リスト内の変数がクラスに設定され、Noneに自動的に設定されます。

def init_attributes(name, bases, dict):
    if 'attributes' in dict:
        for attr in dict['attributes']:
            dict[attr] = None

    return type(name, bases, dict)

class Initialised(object):
    __metaclass__ = init_attributes
    attributes = ['foo', 'bar', 'baz']

print 'foo =>', Initialised.foo
# output=>
foo => None

Initialisedメタクラスを持つことによって得られる魔法の振る舞いinit_attributesは、のサブクラスに渡されないことに注意してくださいInitialised

これはさらに具体的な例であり、クラスの作成時にアクションを実行するメタクラスを作成するために「type」をサブクラス化する方法を示しています。これはかなり注意が必要です。

class MetaSingleton(type):
    instance = None
    def __call__(cls, *args, **kw):
        if cls.instance is None:
            cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
        return cls.instance

class Foo(object):
    __metaclass__ = MetaSingleton

a = Foo()
b = Foo()
assert a is b
179
kindall 2011-06-22 06:30.

他の人は、メタクラスがどのように機能し、Python型システムにどのように適合するかを説明しています。これらの用途の例を次に示します。私が作成したテストフレームワークでは、クラスが定義された順序を追跡して、後でこの順序でインスタンス化できるようにしたいと思いました。メタクラスを使用してこれを行うのが最も簡単であることがわかりました。

class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1

class MyType(object):              # Python 2
    __metaclass__ = MyMeta

class MyType(metaclass=MyMeta):    # Python 3
    pass

そのサブクラスであるものはすべて、クラスが定義された順序を記録MyTypeするクラス属性_orderを取得します。

167
Antti Rasinen 2008-09-19 20:45.

メタクラスの用途の1つは、インスタンスに新しいプロパティとメソッドを自動的に追加することです。

たとえば、Djangoモデルを見ると、その定義は少し紛らわしいように見えます。クラスプロパティのみを定義しているように見えます。

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

ただし、実行時に、Personオブジェクトはあらゆる種類の便利なメソッドで満たされます。いくつかの驚くべきメタクラスのソースを参照してください。

128
Matthias Kestenholz 2008-09-19 20:32.

ONLampのメタクラスプログラミングの紹介はよく書かれていて、すでに数年経っていますが、このトピックについて本当に良い紹介をしていると思います。

http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html (でアーカイブ https://web.archive.org/web/20080206005253/http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html)。

つまり、クラスはインスタンスを作成するための青写真であり、メタクラスはクラスを作成するための青写真です。Pythonでは、この動作を有効にするために、クラスもファーストクラスのオブジェクトである必要があることが簡単にわかります。

自分で書いたことはありませんが、メタクラスの最も優れた使用法の1つは、Djangoフレームワークに見られると思います。モデルクラスは、メタクラスアプローチを使用して、新しいモデルまたはフォームクラスを作成する宣言型のスタイルを有効にします。メタクラスがクラスを作成している間、すべてのメンバーはクラス自体をカスタマイズする可能性があります。

  • 新しいモデルの作成
  • これを可能にするメタクラス

残されているのは、メタクラスが何であるかわからない場合、メタクラスが不要になる確率は99%です。

119
Aaron Hall 2015-08-11 13:28.

メタクラスとは何ですか?何に使うの?

TLDR:メタクラスは、クラスがインスタンスの動作をインスタンス化して定義するのと同じように、クラスの動作をインスタンス化して定義します。

擬似コード:

>>> Class(...)
instance

上記は見覚えがあるはずです。さて、どこClassから来たのですか?これはメタクラス(疑似コードでもあります)のインスタンスです:

>>> Metaclass(...)
Class

実際のコードでは、デフォルトのメタクラスを渡すことができます。これはtype、クラスをインスタンス化するために必要なすべてのものであり、クラスを取得します。

>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace
<class '__main__.Foo'>

別の言い方をすれば

  • メタクラスがクラスに対してであるように、クラスはインスタンスに対してです。

    オブジェクトをインスタンス化すると、インスタンスが取得されます。

    >>> object()                          # instantiation of class
    <object object at 0x7f9069b4e0b0>     # instance
    

    同様に、デフォルトのメタクラスでクラスを明示的に定義するとtype、それがインスタンス化されます。

    >>> type('Object', (object,), {})     # instantiation of metaclass
    <class '__main__.Object'>             # instance
    
  • 言い換えると、クラスはメタクラスのインスタンスです。

    >>> isinstance(object, type)
    True
    
  • 第三に、メタクラスはクラスのクラスです。

    >>> type(object) == type
    True
    >>> object.__class__
    <class 'type'>
    

クラス定義を記述してPythonがそれを実行すると、メタクラスを使用してクラスオブジェクトがインスタンス化されます(次に、そのクラスのインスタンスをインスタンス化するために使用されます)。

クラス定義を使用してカスタムオブジェクトインスタンスの動作を変更できるのと同様に、メタクラスクラス定義を使用してクラスオブジェクトの動作を変更できます。

それらは何に使用できますか?ドキュメントから:

メタクラスの潜在的な用途は無限です。検討されてきたいくつかのアイデアには、ロギング、インターフェースチェック、自動委任、自動プロパティ作成、プロキシ、フレームワーク、および自動リソースロック/同期が含まれます。

それでも、絶対に必要な場合を除いて、通常、ユーザーはメタクラスの使用を避けることをお勧めします。

クラスを作成するたびにメタクラスを使用します。

たとえば、次のようにクラス定義を作成すると、

class Foo(object): 
    'demo'

クラスオブジェクトをインスタンス化します。

>>> Foo
<class '__main__.Foo'>
>>> isinstance(Foo, type), isinstance(Foo, object)
(True, True)

これは、type適切な引数を使用して機能的に呼び出し、その結果をその名前の変数に割り当てることと同じです。

name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)

__dict__名前空間など、いくつかのものが自動的に追加されることに注意してください。

>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__module__': '__main__', '__weakref__': <attribute '__weakref__' 
of 'Foo' objects>, '__doc__': 'demo'})

どちらの場合も、作成したオブジェクトのメタクラスtypeです。

クラスの内容について(サイドノート__dict____module__クラスは、それらが定義されている場所を知っている、としなければならないので、そこにある__dict____weakref__私たちは定義していないので、そこにある__slots__-私たちは場合定義し__slots__、我々はインスタンス内のスペースのビットを節約できます、とそれらを禁止__dict____weakref__、除外することができます。例:

>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})
>>> Baz.__dict__
mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})

...しかし私は逸脱します。)

type他のクラス定義と同じように拡張できます。

__repr__クラスのデフォルトは次のとおりです。

>>> Foo
<class '__main__.Foo'>

Pythonオブジェクトを作成する際にデフォルトで実行できる最も価値のあることの1つは、それに優れたを提供すること__repr__です。私たちが電話help(repr)をするとき、私たちは__repr__、平等のテストも必要とするaの良いテストがあることを学びます- obj == eval(repr(obj))。型クラスのクラスインスタンスの次の簡単な実装は__repr____eq__クラスのデフォルト__repr__を改善する可能性のあるデモンストレーションを提供します。

class Type(type):
    def __repr__(cls):
        """
        >>> Baz
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        >>> eval(repr(Baz))
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        """
        metaname = type(cls).__name__
        name = cls.__name__
        parents = ', '.join(b.__name__ for b in cls.__bases__)
        if parents:
            parents += ','
        namespace = ', '.join(': '.join(
          (repr(k), repr(v) if not isinstance(v, type) else v.__name__))
               for k, v in cls.__dict__.items())
        return '{0}(\'{1}\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)
    def __eq__(cls, other):
        """
        >>> Baz == eval(repr(Baz))
        True            
        """
        return (cls.__name__, cls.__bases__, cls.__dict__) == (
                other.__name__, other.__bases__, other.__dict__)

したがって、このメタクラスを使用してオブジェクトを作成すると__repr__、コマンドラインにエコーされると、デフォルトよりも醜い見た目がはるかに少なくなります。

>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})

__repr__クラスインスタンスに適切に定義されているため、コードをデバッグするためのより強力な機能があります。ただし、それ以上のチェックeval(repr(Class))はほとんどありません(関数がデフォルトから評価することはかなり不可能であるため__repr__)。

予想される使用法:__prepare__名前空間

たとえば、クラスのメソッドが作成される順序を知りたい場合は、クラスの名前空間として順序付けられたdictを指定できます。Python 3で実装されている場合、クラスの名前空間dict__prepare__を返すことでこれを行います。

from collections import OrderedDict

class OrderedType(Type):
    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        return OrderedDict()
    def __new__(cls, name, bases, namespace, **kwargs):
        result = Type.__new__(cls, name, bases, dict(namespace))
        result.members = tuple(namespace)
        return result

そして使用法:

class OrderedMethodsObject(object, metaclass=OrderedType):
    def method1(self): pass
    def method2(self): pass
    def method3(self): pass
    def method4(self): pass

これで、これらのメソッド(およびその他のクラス属性)が作成された順序の記録ができました。

>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')

この例はドキュメントから採用されたものであることに注意してください。標準ライブラリの新しい列挙型がこれを行います。

つまり、クラスを作成してメタクラスをインスタンス化することでした。他のクラスと同じようにメタクラスを扱うこともできます。メソッドの解決順序があります。

>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)

そして、それはほぼ正しいですrepr(関数を表す方法を見つけられない限り、評価することはできません)。

>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})
84
Ethan Furman 2016-03-02 09:48.

Python3アップデート

(この時点で)メタクラスには2つの重要なメソッドがあります。

  • __prepare__、および
  • __new__

__prepare__OrderedDictクラスの作成中に名前空間として使用されるカスタムマッピング(など)を指定できます。選択した名前空間のインスタンスを返す必要があります。実装しない場合__prepare__は法線dictが使用されます。

__new__ 最終クラスの実際の作成/変更に責任があります。

必要最低限​​の、何もしない、余分なメタクラスは次のようになります。

class Meta(type):

    def __prepare__(metaclass, cls, bases):
        return dict()

    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

簡単な例:

いくつかの簡単な検証コードを属性で実行したいとします。たとえば、常にまたはであるint必要がありstrます。メタクラスがないと、クラスは次のようになります。

class Person:
    weight = ValidateType('weight', int)
    age = ValidateType('age', int)
    name = ValidateType('name', str)

ご覧のとおり、属性の名前を2回繰り返す必要があります。これにより、タイプミスとイライラするバグが発生する可能性があります。

単純なメタクラスでその問題に対処できます。

class Person(metaclass=Validator):
    weight = ValidateType(int)
    age = ValidateType(int)
    name = ValidateType(str)

これはメタクラスがどのように見えるかです(__prepare__必要ないので使用しません):

class Validator(type):
    def __new__(metacls, cls, bases, clsdict):
        # search clsdict looking for ValidateType descriptors
        for name, attr in clsdict.items():
            if isinstance(attr, ValidateType):
                attr.name = name
                attr.attr = '_' + name
        # create final class and return it
        return super().__new__(metacls, cls, bases, clsdict)

のサンプル実行:

p = Person()
p.weight = 9
print(p.weight)
p.weight = '9'

生成:

9
Traceback (most recent call last):
  File "simple_meta.py", line 36, in <module>
    p.weight = '9'
  File "simple_meta.py", line 24, in __set__
    (self.name, self.type, value))
TypeError: weight must be of type(s) <class 'int'> (got '9')

:この例は、クラスデコレータを使用して実行することもできるほど単純ですが、おそらく実際のメタクラスはさらに多くのことを実行します。

参照用の「ValidateType」クラス:

class ValidateType:
    def __init__(self, type):
        self.name = None  # will be set by metaclass
        self.attr = None  # will be set by metaclass
        self.type = type
    def __get__(self, inst, cls):
        if inst is None:
            return self
        else:
            return inst.__dict__[self.attr]
    def __set__(self, inst, value):
        if not isinstance(value, self.type):
            raise TypeError('%s must be of type(s) %s (got %r)' %
                    (self.name, self.type, value))
        else:
            inst.__dict__[self.attr] = value
72
Michael Ekoka 2016-10-13 23:21.

__call__()クラスインスタンスを作成するときのメタクラスのメソッドの役割

Pythonプログラミングを数か月以上行っていると、最終的には次のようなコードに出くわします。

# define a class
class SomeClass(object):
    # ...
    # some definition here ...
    # ...

# create an instance of it
instance = SomeClass()

# then call the object as if it's a function
result = instance('foo', 'bar')

後者は__call__()、クラスにマジックメソッドを実装するときに可能です。

class SomeClass(object):
    # ...
    # some definition here ...
    # ...

    def __call__(self, foo, bar):
        return bar + foo

この__call__()メソッドは、クラスのインスタンスが呼び出し可能オブジェクトとして使用されるときに呼び出されます。しかし、以前の回答から見てきたように、クラス自体はメタクラスのインスタンスであるため、クラスを呼び出し可能オブジェクトとして使用する場合(つまり、インスタンスを作成する場合)、実際にはそのメタクラスの__call__()メソッドを呼び出しています。この時点で、ほとんどのPythonプログラマーは、このようなインスタンスを作成するときにinstance = SomeClass()その__init__()メソッドを呼び出すと言われているため、少し混乱しています。もう少し深く掘り下げた人の中には、__init__()が存在する前にそれを知っている人もいます__new__()。さて、今日__new__()、メタクラスが存在する前に、真実の別の層が明らかにされています__call__()

特にクラスのインスタンスを作成するという観点から、メソッド呼び出しチェーンを調べてみましょう。

これは、インスタンスが作成される直前とインスタンスが返される直前を正確にログに記録するメタクラスです。

class Meta_1(type):
    def __call__(cls):
        print "Meta_1.__call__() before creating an instance of ", cls
        instance = super(Meta_1, cls).__call__()
        print "Meta_1.__call__() about to return instance."
        return instance

これはそのメタクラスを使用するクラスです

class Class_1(object):

    __metaclass__ = Meta_1

    def __new__(cls):
        print "Class_1.__new__() before creating an instance."
        instance = super(Class_1, cls).__new__(cls)
        print "Class_1.__new__() about to return instance."
        return instance

    def __init__(self):
        print "entering Class_1.__init__() for instance initialization."
        super(Class_1,self).__init__()
        print "exiting Class_1.__init__()."

そして今、のインスタンスを作成しましょう Class_1

instance = Class_1()
# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.
# Class_1.__new__() before creating an instance.
# Class_1.__new__() about to return instance.
# entering Class_1.__init__() for instance initialization.
# exiting Class_1.__init__().
# Meta_1.__call__() about to return instance.

上記のコードは、実際にはタスクをログに記録する以上のことは何もしないことに注意してください。各メソッドは、実際の作業をその親の実装に委任するため、デフォルトの動作が維持されます。以来typeであるMeta_1の親クラス(typeデフォルトの親のメタクラスである)と、上記の出力の順序付けシーケンスを考慮すると、我々は今の疑似実装であるものについての手掛かりを持っていますtype.__call__()

class type:
    def __call__(cls, *args, **kwarg):

        # ... maybe a few things done to cls here

        # then we call __new__() on the class to create an instance
        instance = cls.__new__(cls, *args, **kwargs)

        # ... maybe a few things done to the instance here

        # then we initialize the instance with its __init__() method
        instance.__init__(*args, **kwargs)

        # ... maybe a few more things done to instance here

        # then we return it
        return instance

メタクラスの__call__()メソッドが最初に呼び出されるメソッドであることがわかります。次に、インスタンスの作成をクラスの__new__()メソッドに委任し、初期化をインスタンスのメソッドに委任します__init__()。また、最終的にインスタンスを返すものでもあります。

それ以上のことからメタクラスがあること茎__call__()もの呼び出しかどうかを決定する機会が与えられているClass_1.__new__()かは、Class_1.__init__()最終的に行われますが。実行中に、これらのメソッドのいずれによっても触れられていないオブジェクトを実際に返す可能性があります。シングルトンパターンへのこのアプローチを例にとってみましょう。

class Meta_2(type):
    singletons = {}

    def __call__(cls, *args, **kwargs):
        if cls in Meta_2.singletons:
            # we return the only instance and skip a call to __new__()
            # and __init__()
            print ("{} singleton returning from Meta_2.__call__(), "
                   "skipping creation of new instance.".format(cls))
            return Meta_2.singletons[cls]

        # else if the singleton isn't present we proceed as usual
        print "Meta_2.__call__() before creating an instance."
        instance = super(Meta_2, cls).__call__(*args, **kwargs)
        Meta_2.singletons[cls] = instance
        print "Meta_2.__call__() returning new instance."
        return instance

class Class_2(object):

    __metaclass__ = Meta_2

    def __new__(cls, *args, **kwargs):
        print "Class_2.__new__() before creating instance."
        instance = super(Class_2, cls).__new__(cls)
        print "Class_2.__new__() returning instance."
        return instance

    def __init__(self, *args, **kwargs):
        print "entering Class_2.__init__() for initialization."
        super(Class_2, self).__init__()
        print "exiting Class_2.__init__()."

タイプのオブジェクトを繰り返し作成しようとするとどうなるかを観察してみましょう Class_2

a = Class_2()
# Meta_2.__call__() before creating an instance.
# Class_2.__new__() before creating instance.
# Class_2.__new__() returning instance.
# entering Class_2.__init__() for initialization.
# exiting Class_2.__init__().
# Meta_2.__call__() returning new instance.

b = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

c = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

a is b is c # True
60
Craig 2014-02-25 11:20.

メタクラスは、他のクラスをどのように作成するかを指示するクラスです。

これは、メタクラスを問題の解決策と見なした場合です。非常に複雑な問題があり、おそらく別の方法で解決できた可能性がありますが、メタクラスを使用して解決することにしました。複雑なため、モジュール内のコメントが記述されたコードの量を超えている、私が記述した数少ないモジュールの1つです。ここにあります...

#!/usr/bin/env python

# Copyright (C) 2013-2014 Craig Phillips.  All rights reserved.

# This requires some explaining.  The point of this metaclass excercise is to
# create a static abstract class that is in one way or another, dormant until
# queried.  I experimented with creating a singlton on import, but that did
# not quite behave how I wanted it to.  See now here, we are creating a class
# called GsyncOptions, that on import, will do nothing except state that its
# class creator is GsyncOptionsType.  This means, docopt doesn't parse any
# of the help document, nor does it start processing command line options.
# So importing this module becomes really efficient.  The complicated bit
# comes from requiring the GsyncOptions class to be static.  By that, I mean
# any property on it, may or may not exist, since they are not statically
# defined; so I can't simply just define the class with a whole bunch of
# properties that are @property @staticmethods.
#
# So here's how it works:
#
# Executing 'from libgsync.options import GsyncOptions' does nothing more
# than load up this module, define the Type and the Class and import them
# into the callers namespace.  Simple.
#
# Invoking 'GsyncOptions.debug' for the first time, or any other property
# causes the __metaclass__ __getattr__ method to be called, since the class
# is not instantiated as a class instance yet.  The __getattr__ method on
# the type then initialises the class (GsyncOptions) via the __initialiseClass
# method.  This is the first and only time the class will actually have its
# dictionary statically populated.  The docopt module is invoked to parse the
# usage document and generate command line options from it.  These are then
# paired with their defaults and what's in sys.argv.  After all that, we
# setup some dynamic properties that could not be defined by their name in
# the usage, before everything is then transplanted onto the actual class
# object (or static class GsyncOptions).
#
# Another piece of magic, is to allow command line options to be set in
# in their native form and be translated into argparse style properties.
#
# Finally, the GsyncListOptions class is actually where the options are
# stored.  This only acts as a mechanism for storing options as lists, to
# allow aggregation of duplicate options or options that can be specified
# multiple times.  The __getattr__ call hides this by default, returning the
# last item in a property's list.  However, if the entire list is required,
# calling the 'list()' method on the GsyncOptions class, returns a reference
# to the GsyncListOptions class, which contains all of the same properties
# but as lists and without the duplication of having them as both lists and
# static singlton values.
#
# So this actually means that GsyncOptions is actually a static proxy class...
#
# ...And all this is neatly hidden within a closure for safe keeping.
def GetGsyncOptionsType():
    class GsyncListOptions(object):
        __initialised = False

    class GsyncOptionsType(type):
        def __initialiseClass(cls):
            if GsyncListOptions._GsyncListOptions__initialised: return

            from docopt import docopt
            from libgsync.options import doc
            from libgsync import __version__

            options = docopt(
                doc.__doc__ % __version__,
                version = __version__,
                options_first = True
            )

            paths = options.pop('<path>', None)
            setattr(cls, "destination_path", paths.pop() if paths else None)
            setattr(cls, "source_paths", paths)
            setattr(cls, "options", options)

            for k, v in options.iteritems():
                setattr(cls, k, v)

            GsyncListOptions._GsyncListOptions__initialised = True

        def list(cls):
            return GsyncListOptions

        def __getattr__(cls, name):
            cls.__initialiseClass()
            return getattr(GsyncListOptions, name)[-1]

        def __setattr__(cls, name, value):
            # Substitut option names: --an-option-name for an_option_name
            import re
            name = re.sub(r'^__', "", re.sub(r'-', "_", name))
            listvalue = []

            # Ensure value is converted to a list type for GsyncListOptions
            if isinstance(value, list):
                if value:
                    listvalue = [] + value
                else:
                    listvalue = [ None ]
            else:
                listvalue = [ value ]

            type.__setattr__(GsyncListOptions, name, listvalue)

    # Cleanup this module to prevent tinkering.
    import sys
    module = sys.modules[__name__]
    del module.__dict__['GetGsyncOptionsType']

    return GsyncOptionsType

# Our singlton abstract proxy class.
class GsyncOptions(object):
    __metaclass__ = GetGsyncOptionsType()
46
noɥʇʎԀʎzɐɹƆ 2016-12-27 16:21.

tl; drバージョン

このtype(obj)関数は、オブジェクトのタイプを取得します。

type()クラスのは、そのですメタクラス

メタクラスを使用するには:

class Foo(object):
    __metaclass__ = MyMetaClass

type独自のメタクラスです。クラスのクラスはメタクラスです。クラスの本体は、クラスを構築するために使用されるメタクラスに渡される引数です。

ここでは、メタクラスを使用してクラス構造をカスタマイズする方法について読むことができます。

45
Mushahid Khan 2016-08-10 08:49.

type実際にはmetaclass-別のクラスを作成するクラスです。ほとんどmetaclassはのサブクラスですtypemetaclass受信したnew最初の引数としてクラスを上下に述べたように細部を持つクラスのオブジェクトへのアクセスを提供します。

>>> class MetaClass(type):
...     def __init__(cls, name, bases, attrs):
...         print ('class name: %s' %name )
...         print ('Defining class %s' %cls)
...         print('Bases %s: ' %bases)
...         print('Attributes')
...         for (name, value) in attrs.items():
...             print ('%s :%r' %(name, value))
... 

>>> class NewClass(object, metaclass=MetaClass):
...    get_choch='dairy'
... 
class name: NewClass
Bases <class 'object'>: 
Defining class <class 'NewClass'>
get_choch :'dairy'
__module__ :'builtins'
__qualname__ :'NewClass'

Note:

クラスはいつでもインスタンス化されていないことに注意してください。クラスを作成するという単純な行為により、の実行がトリガーされmetaclassます。

29
Xingzhou Liu 2017-07-13 21:58.

Pythonクラスは、それ自体がメタクラスのオブジェクトです(インスタンスのように)。

デフォルトのメタクラス。クラスを次のように決定するときに適用されます。

class foo:
    ...

メタクラスは、クラスのセット全体に何らかのルールを適用するために使用されます。たとえば、データベースにアクセスするためのORMを構築していて、各テーブルのレコードをそのテーブルにマップされたクラス(フィールド、ビジネスルールなどに基づく)にしたい場合、メタクラスを使用できます。たとえば、接続プールロジックは、すべてのテーブルのすべてのクラスのレコードで共有されます。もう1つの用途は、複数のクラスのレコードを含む外部キーをサポートするロジックです。

メタクラスを定義するときは、タイプをサブクラス化し、次のマジックメソッドをオーバーライドしてロジックを挿入できます。

class somemeta(type):
    __new__(mcs, name, bases, clsdict):
      """
  mcs: is the base metaclass, in this case type.
  name: name of the new class, as provided by the user.
  bases: tuple of base classes 
  clsdict: a dictionary containing all methods and attributes defined on class

  you must return a class object by invoking the __new__ constructor on the base metaclass. 
 ie: 
    return type.__call__(mcs, name, bases, clsdict).

  in the following case:

  class foo(baseclass):
        __metaclass__ = somemeta

  an_attr = 12

  def bar(self):
      ...

  @classmethod
  def foo(cls):
      ...

      arguments would be : ( somemeta, "foo", (baseclass, baseofbase,..., object), {"an_attr":12, "bar": <function>, "foo": <bound class method>}

      you can modify any of these values before passing on to type
      """
      return type.__call__(mcs, name, bases, clsdict)


    def __init__(self, name, bases, clsdict):
      """ 
      called after type has been created. unlike in standard classes, __init__ method cannot modify the instance (cls) - and should be used for class validaton.
      """
      pass


    def __prepare__():
        """
        returns a dict or something that can be used as a namespace.
        the type will then attach methods and attributes from class definition to it.

        call order :

        somemeta.__new__ ->  type.__new__ -> type.__init__ -> somemeta.__init__ 
        """
        return dict()

    def mymethod(cls):
        """ works like a classmethod, but for class objects. Also, my method will not be visible to instances of cls.
        """
        pass

とにかく、これら2つは最も一般的に使用されるフックです。メタクラス化は強力であり、上記はメタクラス化の使用法の完全なリストにはほど遠いです。

23
binbjz 2018-01-12 23:16.

type()関数は、オブジェクトの型を返すか、新しい型を作成できます。

たとえば、type()関数を使用してHiクラスを作成でき、クラスHi(object)でこのように使用する必要はありません。

def func(self, name='mike'):
    print('Hi, %s.' % name)

Hi = type('Hi', (object,), dict(hi=func))
h = Hi()
h.hi()
Hi, mike.

type(Hi)
type

type(h)
__main__.Hi

type()を使用してクラスを動的に作成することに加えて、クラスの作成動作を制御し、メタクラスを使用できます。

Pythonオブジェクトモデルによると、クラスはオブジェクトであるため、クラスは別の特定のクラスのインスタンスである必要があります。デフォルトでは、Pythonクラスは型クラスのインスタンスです。つまり、typeは、ほとんどの組み込みクラスのメタクラスであり、ユーザー定義クラスのメタクラスです。

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

class CustomList(list, metaclass=ListMetaclass):
    pass

lst = CustomList()
lst.add('custom_list_1')
lst.add('custom_list_2')

lst
['custom_list_1', 'custom_list_2']

メタクラスでキーワード引数を渡すと、Magicが有効になります。これは、PythonインタープリターがListMetaclassを介してCustomListを作成することを示します。new()、この時点で、たとえばクラス定義を変更し、新しいメソッドを追加してから、改訂された定義を返すことができます。

13
Andy Fedoroff 2018-09-16 02:41.

公開された回答に加えて、ametaclassはクラスの動作を定義すると言えます。したがって、メタクラスを明示的に設定できます。Pythonはキーワードを取得するたびに、のclass検索を開始しmetaclassます。見つからない場合–デフォルトのメタクラスタイプがクラスのオブジェクトの作成に使用されます。__metaclass__属性を使用してmetaclass、クラスを設定できます。

class MyClass:
   __metaclass__ = type
   # write here other method
   # write here one more method

print(MyClass.__metaclass__)

次のような出力が生成されます。

class 'type'

もちろん、独自のmetaclassクラスを作成して、クラスを使用して作成されたクラスの動作を定義することもできます。

metaclassこれを行うには、これがメインであるため、デフォルトの型クラスを継承する必要がありますmetaclass

class MyMetaClass(type):
   __metaclass__ = type
   # you can write here any behaviour you want

class MyTestClass:
   __metaclass__ = MyMetaClass

Obj = MyTestClass()
print(Obj.__metaclass__)
print(MyMetaClass.__metaclass__)

出力は次のようになります。

class '__main__.MyMetaClass'
class 'type'
6
Venu Gopal Tewari 2019-07-09 19:37.

オブジェクト指向プログラミングでは、メタクラスはインスタンスがクラスであるクラスです。通常のクラスが特定のオブジェクトの動作を定義するのと同じように、メタクラスは特定のクラスとそのインスタンスの動作を定義します。メタクラスという用語は、単にクラスの作成に使用されるものを意味します。言い換えれば、それはクラスのクラスです。メタクラスはクラスを作成するために使用されるため、オブジェクトがクラスのインスタンスであるように、クラスはメタクラスのインスタンスです。Pythonでは、クラスもオブジェクトと見なされます。

4
Carson 2019-12-21 01:03.

用途の別の例を次に示します。

  • を使用しmetaclassて、そのインスタンス(クラス)の機能を変更できます。
class MetaMemberControl(type):
    __slots__ = ()

    @classmethod
    def __prepare__(mcs, f_cls_name, f_cls_parents,  # f_cls means: future class
                    meta_args=None, meta_options=None):  # meta_args and meta_options is not necessarily needed, just so you know.
        f_cls_attr = dict()
        if not "do something or if you want to define your cool stuff of dict...":
            return dict(make_your_special_dict=None)
        else:
            return f_cls_attr

    def __new__(mcs, f_cls_name, f_cls_parents, f_cls_attr,
                meta_args=None, meta_options=None):

        original_getattr = f_cls_attr.get('__getattribute__')
        original_setattr = f_cls_attr.get('__setattr__')

        def init_getattr(self, item):
            if not item.startswith('_'):  # you can set break points at here
                alias_name = '_' + item
                if alias_name in f_cls_attr['__slots__']:
                    item = alias_name
            if original_getattr is not None:
                return original_getattr(self, item)
            else:
                return super(eval(f_cls_name), self).__getattribute__(item)

        def init_setattr(self, key, value):
            if not key.startswith('_') and ('_' + key) in f_cls_attr['__slots__']:
                raise AttributeError(f"you can't modify private members:_{key}")
            if original_setattr is not None:
                original_setattr(self, key, value)
            else:
                super(eval(f_cls_name), self).__setattr__(key, value)

        f_cls_attr['__getattribute__'] = init_getattr
        f_cls_attr['__setattr__'] = init_setattr

        cls = super().__new__(mcs, f_cls_name, f_cls_parents, f_cls_attr)
        return cls


class Human(metaclass=MetaMemberControl):
    __slots__ = ('_age', '_name')

    def __init__(self, name, age):
        self._name = name
        self._age = age

    def __getattribute__(self, item):
        """
        is just for IDE recognize.
        """
        return super().__getattribute__(item)

    """ with MetaMemberControl then you don't have to write as following
    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age
    """


def test_demo():
    human = Human('Carson', 27)
    # human.age = 18  # you can't modify private members:_age  <-- this is defined by yourself.
    # human.k = 18  # 'Human' object has no attribute 'k'  <-- system error.
    age1 = human._age  # It's OK, although the IDE will show some warnings. (Access to a protected member _age of a class)

    age2 = human.age  # It's OK! see below:
    """
    if you do not define `__getattribute__` at the class of Human,
    the IDE will show you: Unresolved attribute reference 'age' for class 'Human'
    but it's ok on running since the MetaMemberControl will help you.
    """


if __name__ == '__main__':
    test_demo()

metaclass強力ですが、そこにあなたがそれを行うことができます(たとえば、サル魔法のような)多くのものがありますが、これが唯一のあなたに知られていてもよいように注意してください。

3
Swati Srivastava 2020-01-20 20:59.

Pythonのクラスはオブジェクトであり、他のオブジェクトと同様に、「何か」のインスタンスです。この「何か」は、メタクラスと呼ばれるものです。このメタクラスは、他のクラスのオブジェクトを作成する特別なタイプのクラスです。したがって、メタクラスは新しいクラスを作成する責任があります。これにより、プログラマーはクラスの生成方法をカスタマイズできます。

メタクラスを作成するには、通常、new()メソッドとinit()メソッドのオーバーライドが行われます。new()をオーバーライドしてオブジェクトの作成方法を変更し、init()をオーバーライドしてオブジェクトの初期化方法を変更できます。メタクラスは、いくつかの方法で作成できます。方法の1つは、type()関数を使用することです。type()関数は、3つのパラメーターを指定して呼び出されると、メタクラスを作成します。パラメータは次のとおりです:-

  1. クラス名
  2. クラスに継承された基本クラスを持つタプル
  3. すべてのクラスメソッドとクラス変数を持つ辞書

メタクラスを作成する別の方法は、「metaclass」キーワードで構成されます。メタクラスを単純なクラスとして定義します。継承されたクラスのパラメーターで、metaclass = metaclass_nameを渡します

メタクラスは、特に次の状況で使用できます:-

  1. 特定の効果をすべてのサブクラスに適用する必要がある場合
  2. クラスの自動変更(作成時)が必要です
  3. API開発者による
3
Lars 2020-03-04 00:06.

Python 3.6では、__init_subclass__(cls, **kwargs)メタクラスの多くの一般的なユースケースを置き換えるために新しいdunderメソッドが導入されたことに注意してください。定義クラスのサブクラスが作成されるときに呼び出されます。Pythonドキュメントを参照してください。

1
Neeraj Bansal 2020-07-09 23:16.

定義:
メタクラスは、インスタンスがクラスであるクラスです。「通常の」クラスがクラスのインスタンスの動作を定義するように、メタクラスはクラスとそのインスタンスの動作を定義します。

メタクラスは、すべてのオブジェクト指向プログラミング言語でサポートされているわけではありません。メタクラスをサポートするこれらのプログラミング言語は、それらを実装する方法がかなり異なります。Pythonはそれらをサポートしています。

一部のプログラマーは、Pythonのメタクラスを「問題を待っているまたは探しているソリューション」と見なしています。

メタクラスには多くのユースケースがあります。

logging and profiling
interface checking
registering classes at creation time
automatically adding new methods
automatic property creation
proxies
automatic resource locking/synchronization.

メタクラスの定義:
引数の内容を新しいメソッドに出力し、型の結果を返します。新しい呼び出し:

class LittleMeta(type):
    def __new__(cls, clsname, superclasses, attributedict):
        print("clsname: ", clsname)
        print("superclasses: ", superclasses)
        print("attributedict: ", attributedict)
        return type.__new__(cls, clsname, superclasses, attributedict)

次の例では、メタクラス「LittleMeta」を使用します。

class S:
    pass    
class A(S, metaclass=LittleMeta):
    pass    
a = A()

出力:

clsname:  A
superclasses:  (<class '__main__.S'>,)
attributedict:  {'__module__': '__main__', '__qualname__': 'A'}
1
Usama Abdulrehman 2020-07-15 18:34.

metaclassPythonのAは、クラスの動作を定義するクラスのクラスです。クラス自体はのインスタンスですmetaclass。Pythonのクラスは、クラスのインスタンスがどのように動作するかを定義します。metaclassクラス定義でキーワードを渡すことにより、クラス作成プロセスをカスタマイズできます。これは、このキーワードで既に渡されているクラスを継承することによっても実行できます。

class MyMeta(type):
    pass

class MyClass(metaclass=MyMeta):
    pass

class MySubclass(MyClass):
    pass

私たちは、のタイプのことを見ることができますMyMetaクラスであるtypeとことの種類MyClassMySubClassありますMyMeta

print(type(MyMeta))
print(type(MyClass))
print(type(MySubclass))

<class 'type'>
<class '__main__.MyMeta'>
<class '__main__.MyMeta'>

クラスを定義し、nometaclassが定義されている場合、デフォルトのタイプmetaclassが使用されます。ametaclassが指定され、それがのインスタンスではない場合type()、それはmetaclass。として直接使用されます。

メタクラスは、ロギング、作成時のクラスの登録、プロファイリングなどに適用できます。それらは非常に抽象的な概念のようであり、それらを使用する必要があるかどうか疑問に思われるかもしれません。

Related questions

MORE COOL STUFF

ケイト・ブランシェットは3日間一緒に夫と一緒に寝て、25年経ってもまだ夫と結婚しています

ケイト・ブランシェットは3日間一緒に夫と一緒に寝て、25年経ってもまだ夫と結婚しています

ケイト・ブランシェットは、夫に会ったとき、典型的な交際のアドバイスに逆らいました。

マイケルシーンが非営利の俳優である理由

マイケルシーンが非営利の俳優である理由

マイケルシーンは非営利の俳優ですが、それは正確にはどういう意味ですか?

ホールマークスターのコリンエッグレスフィールドがRomaDramaLiveでスリル満点のファンと出会う![エクスクルーシブ]

ホールマークスターのコリンエッグレスフィールドがRomaDramaLiveでスリル満点のファンと出会う![エクスクルーシブ]

特徴的なスターのコリン・エッグレスフィールドは、RomaDrama Liveでのスリル満点のファンとの出会いについて料理しました!加えて、大会での彼のINSPIREプログラム。

「たどりつけば」をオンラインでストリーミングできない理由

「たどりつけば」をオンラインでストリーミングできない理由

ノーザンエクスポージャーが90年代の最も人気のある番組の1つになった理由を確認するには、Blu-rayまたはDVDプレーヤーをほこりで払う必要があります。

バイオニック読書はあなたをより速く読むことができますか?

バイオニック読書はあなたをより速く読むことができますか?

BionicReadingアプリの人気が爆発的に高まっています。しかし、それは本当にあなたを速読術にすることができますか?

ドミニカのボイリング湖:アクセスは簡単ではありませんが、ハイキングする価値があります

ドミニカのボイリング湖:アクセスは簡単ではありませんが、ハイキングする価値があります

ドミニカのボイリング湖は、世界で2番目に大きいボイリング湖です。そこにたどり着くまでのトレッキングは大変で長いですが、努力する価値は十分にあります。

私たちの水をきれいに保つのを助けるためにあなたの髪を寄付してください

私たちの水をきれいに保つのを助けるためにあなたの髪を寄付してください

サロンからのヘアトリミングや個人的な寄付は、油流出を吸収して環境を保護するのに役立つマットとして再利用できます。

ホワイトハウスの最も記憶に残る結婚式を見てください

ホワイトハウスの最も記憶に残る結婚式を見てください

過去200年以上の間にホワイトハウスで結婚したのはほんの数人です。彼らは誰でしたか、そしてそこで結婚式を獲得するために何が必要ですか?

驚くほど素晴らしいDropMixミュージックミキシングカードゲームは30ドルで驚くべき取引です

驚くほど素晴らしいDropMixミュージックミキシングカードゲームは30ドルで驚くべき取引です

DropMixはNFC対応のカードゲームで、基本的にはリミックスアーティストになります。現在、Amazonでは$ 30まで下がっており、これまでで最高の価格に匹敵します。ロックバンドで有名なHarmonixによって開発されたDropMixは、おそらく少し野心的すぎるように思われます。結局のところ、ほとんどの人は素晴らしいリズムを持っていませんが、ゲームは驚くほどうまく実行されます。

メアリーJ.ブライジがついにハリウッドウォークオブフェイムスターを獲得

メアリーJ.ブライジがついにハリウッドウォークオブフェイムスターを獲得

写真:APメアリーJ.ブライジは、間もなくハリウッドウォークオブフェイムのスターを獲得します。これは、メアリーJよりもハリウッドウォークオブフェイムのほうが正直なところ恩恵です。

MeltdownとSpectreの脆弱性についてこれまでに知っていることはすべて、簡単な方法で説明されています

MeltdownとSpectreの脆弱性についてこれまでに知っていることはすべて、簡単な方法で説明されています

画像:グラズ工科大学/ NataschaEiblがデザインしたロゴ。MeltdownとSpectreは、攻撃者がシステムメモリに保存されているあらゆる種類の情報にアクセスできるようにする2つの脆弱性に付けられた名前です。

彼のニューヨークの家から追い出されようとしている97歳の第二次世界大戦の獣医。メリーエフィングクリスマス

彼のニューヨークの家から追い出されようとしている97歳の第二次世界大戦の獣医。メリーエフィングクリスマス

日本人に襲われたときに真珠湾にいた97歳の第二次世界大戦のベテランが、ニューヨークのブルックリンから追い出されています。

Zendaya Wishes Boyfriend Tom Holland Happy Birthday with Cuddly Photo: He 'Makes Me the Happiest'

Zendaya Wishes Boyfriend Tom Holland Happy Birthday with Cuddly Photo: He 'Makes Me the Happiest'

Zendaya shared a sweet photo in honor of boyfriend Tom Holland's 26th birthday Wednesday

小さな女性:脳卒中を患った後に病院から解放されたアトランタのジューシーな赤ちゃん:「まだ癒し」

小さな女性:脳卒中を患った後に病院から解放されたアトランタのジューシーな赤ちゃん:「まだ癒し」

シーレン「Ms.JuicyBaby」ピアソンは、先月脳卒中で入院した後、「もう一度たくさんのことをする方法を学ばなければならない」ため、言語療法を受けていることを明らかにしました。

エマストーンは彼女のクリフサイドマリブビーチハウスを420万ドルでリストアップしています—中を見てください!

エマストーンは彼女のクリフサイドマリブビーチハウスを420万ドルでリストアップしています—中を見てください!

オスカー受賞者の世紀半ばの家には、3つのベッドルーム、2つのバス、オーシャンフロントの景色があります。

ジーニー・メイ・ジェンキンスは、母乳育児の経験の中で、彼女は「本当に、本当に落ち込んでいる」と言います

ジーニー・メイ・ジェンキンスは、母乳育児の経験の中で、彼女は「本当に、本当に落ち込んでいる」と言います

ジーニー・メイ・ジェンキンスは、生後4か月の娘、モナコに母乳育児をしていると語った。

投資ノート:Bioscout AU$300万シード

投資ノート:Bioscout AU$300万シード

Bioscoutは、農家を運転席に置くという使命を負っています。Artesian(GrainInnovate)やUniseedと並んで、最新のシードラウンドでチームを支援できることをうれしく思います。問題真菌症による重大な作物の損失は、農民にとって試練であることが証明されています。

リトルマーケットリサーチ1| 2022年のクイックグリンプス遠隔医療市場

リトルマーケットリサーチ1| 2022年のクイックグリンプス遠隔医療市場

遠隔医療は、パンデミック後の時代では新しいものではなく、時代遅れの分野でもありません。しかし、業界を詳しく見ると、需要と供給の強力な持続可能性と、米国で絶え間ない革命となる強力な潜在的成長曲線を示しています。

スタートアップ資金調達環境:タイのスタートアップエコシステムの次は何ですか?

スタートアップ資金調達環境:タイのスタートアップエコシステムの次は何ですか?

2021年は、世界的なベンチャーキャピタル(VC)の資金調達にとって記録的な年でした。DealStreetAsiaによると、東南アジアも例外ではなく、この地域では年間で記録的な25の新しいユニコーンが採掘されました。

ムーアの法則を超えて

ムーアの法則を超えて

計算に対する私たちの欲求とムーアの法則が提供できるものとの間には、指数関数的に増大するギャップがあります。私たちの文明は計算に基づいています—建築と想像力の現在の限界を超える技術を見つけなければなりません。

Language