Pythonでは、メタクラスとは何であり、何に使用するのでしょうか。

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

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__

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

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

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

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

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

しかし、クラスはPythonのクラスを超えています。クラスもオブジェクトです。

はい、オブジェクト。

キーワードを使用するとすぐにclass、Pythonがそれを実行し、OBJECTを作成します。指示

>>> 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__aを探し__metaclass__、同じことを試みます（ただし、何も継承しないクラス、基本的には古いスタイルのクラスのみ）。

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

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

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

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

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

Python 3のメタクラス

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__実際には呼び出し可能であり、正式なクラスである必要はありません（名前に「クラス」が含まれているものは、クラスである必要はありません。

したがって、関数を使用して、簡単な例から始めます。

# 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％が心配する必要はありません。それらが必要かどうか疑問に思っても、必要ありません（実際にそれらを必要とする人々は、それらが必要であることを確実に知っており、理由についての説明も必要ありません）。

パイソングルティムピーターズ

メタクラスの主な使用例は、APIの作成です。この典型的な例はDjango ORMです。次のように定義できます。

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％の場合、クラスの変更はまったく必要ありません。

2008年に書かれたPython 2.xの回答です。メタクラスは3.xでは少し異なります。

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

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

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

ここから秘密が始まります。この例のクラス定義で、名前、ベース、辞書の出所を探します。

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。

これはさらに具体的な例であり、「タイプ」をサブクラス化して、クラスの作成時にアクションを実行するメタクラスを作成する方法を示しています。これはかなりトリッキーです：

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

他の人たちは、メタクラスがどのように機能し、どのように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

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

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

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

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

ただし、実行時には、Personオブジェクトはあらゆる種類の便利なメソッドで満たされます。素晴らしいメタクラセリーのソースをご覧ください。

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％です。

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

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__、等しいかどうかのテストも必要とするの良いテストがあることがわかります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__クラスインスタンスにniceが定義されているため、コードをデバッグする機能が強化されています。ただし、を使用してこれ以上チェックすること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>})

Python 3アップデート

（この時点で）メタクラスには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

__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__()、クラスにmagicメソッドを実装するときに可能です。

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

メタクラスは、他のクラスの作成方法を示すクラスです。

これは、問題の解決策としてメタクラスを見た場合です。私は本当に複雑な問題を抱えていましたが、おそらく別の方法で解決できたかもしれませんが、メタクラスを使用して解決することにしました。複雑なため、これは私が作成した数少ないモジュールの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()

tl; drバージョン

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

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

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

class Foo(object):
    __metaclass__ = MyMetaClass

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

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

type実際にはmetaclass-別のクラスを作成するクラスです。ほとんどmetaclassはのサブクラスですtype。metaclass受信した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ます。

Pythonクラス自体は、たとえばメタクラスのオブジェクトです。

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

class foo:
    ...

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

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

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つは最も一般的に使用されるフックです。メタクラス化は強力であり、メタクラス化の用途の完全かつ完全なリストにはどこにもありません。

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クラスはタイプクラスのインスタンスです。つまり、タイプはほとんどの組み込みクラスのメタクラスであり、ユーザー定義クラスのメタクラスです。

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']

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

公開された回答に加えて、a metaclassはクラスの動作を定義すると言えます。したがって、メタクラスを明示的に設定できます。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'

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

これを使用できる別の例を次に示します。

• を使用し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強力ですが、そこにあなたがそれを行うことができます（たとえば、サル魔法のような）多くのものがありますが、これが唯一のあなたに知られていてもよいように注意してください。

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

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

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

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

メタクラスは、具体的には次の状況で使用できます。

1. 特定の効果をすべてのサブクラスに適用する必要がある場合
2. クラスの自動変更（作成時）が必要です
3. API開発者による

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

メタクラスは、クラスがどのように動作するかを定義する一種のクラスです。または、クラス自体がメタクラスのインスタンスであると言えます。