メタクラスはクラスのクラスです。クラスはそのクラスのインスタンス（すなわちオブジェクト）の振る舞いを定義し、メタクラスはクラスの振る舞いを定義します。クラスはメタクラスのインスタンスです。
Pythonではメタクラス（ Jerub showsなど）に任意の呼び出し可能オブジェクトを使用できますが、より良い方法はそれを実際のクラス自体にすることです。 typeはPythonの通常のメタクラスです。 typeはそれ自体がクラスであり、それ自身の型です。純粋にPythonでtypeのようなものを再現することはできませんが、Pythonは少し詐欺します。 Pythonで独自のメタクラスを作成するには、本当にtypeをサブクラス化したいだけです。
メタクラスはクラスファクトリとして最も一般的に使用されています。クラスを呼び出してオブジェクトを作成すると、Pythonはメタクラスを呼び出すことによって（ 'class'ステートメントを実行するときに）新しいクラスを作成します。したがって、通常の__init__および__new__メソッドと組み合わせると、メタクラスを使用して、新しいクラスをレジストリに登録したり、クラスを他のものと完全に置き換えたりするなど、クラスの作成時に「追加の作業」を実行できます。
classステートメントが実行されると、Pythonは最初にclassステートメントの本体を通常のコードブロックとして実行します。結果の名前空間（辞書）は、クラスの属性を保持します。メタクラスは、存在するクラスのメタクラス（継承されるメタクラス）、存在するクラスの存在する場合は__metaclass__属性、またはグローバル変数__metaclass__を調べることによって決定されます。次に、メタクラスは、インスタンス化するためにクラスの名前、基本、および属性とともに呼び出されます。
しかし、実際にはメタクラスはクラスの type を定義しています。ファクトリだけではありません。そのため、もっと多くのことができます。たとえば、メタクラスで通常のメソッドを定義できます。これらのメタクラス・メソッドは、インスタンスなしでクラスで呼び出すことができるという点でクラスメソッドと似ていますが、クラスのインスタンスで呼び出すことができないという点でクラスメソッドとも異なります。 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.__+ 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 of the class,
Tuple of the parent class (for inheritance, can be empty),
dictionary containing attributes names and values)
例えば。：
>>> 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が実際にはメタクラスであるためです。 typeは、Pythonが舞台裏ですべてのクラスを作成するために使用するメタクラスです。
Typeではなく、なぜ小文字で書かれているのでしょうか。
文字列オブジェクトを作成するクラスであるstrと、整数オブジェクトを作成するクラスであるintとの一貫性の問題だと思います。 typeは、クラスオブジェクトを作成するクラスです。
__class__属性をチェックするとわかります。
すべて、そして私がすべてを意味するのは、Pythonのオブジェクトです。これには、整数、文字列、関数、そしてクラスが含まれます。それらはすべてオブジェクトです。そしてそれらはすべてクラスから作成されています。
>>> 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は次のことを行います。
Fooに__metaclass__属性がありますか？
そうであれば、__metaclass__にあるものを使ってFooという名前でクラスオブジェクトを作成してください（私はここでクラスオブジェクトと言いました）。
Pythonが__metaclass__を見つけられない場合は、MODULEレベルで__metaclass__を探し、同じことを試みます（ただし、何も継承しないクラス、基本的に古いスタイルのクラスのみ）。
それで__metaclass__がまったく見つからなければ、Bar（最初の親）自身のメタクラス（デフォルトのtypeかもしれません）を使ってクラスオブジェクトを作成します。
__metaclass__属性は継承されず、親のメタクラス（Bar.__class__）は継承されます。 Barがtype()（およびtype.__new__()ではない）でBarを作成した__metaclass__属性を使用した場合、サブクラスはその動作を継承しません。
大きな問題は、__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__は実際には任意の呼び出し可能オブジェクトにすることができます。正式なクラスである必要はありません（名前に '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_attr):
"""
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_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
# let `type` do the class creation
return type(future_class_name, future_class_parents, uppercase_attr)
__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'
print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True
f = Foo()
print(f.BAR)
# Out: '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_attr):
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return type(future_class_name, future_class_parents, uppercase_attr)
しかし、これは本当にOOPではありません。 typeを直接呼び出して、親の__new__をオーバーライドまたは呼び出しません。やってみましょう：
class UpperAttrMetaclass(type):
def __new__(upperattr_metaclass, future_class_name,
future_class_parents, future_class_attr):
uppercase_attr = {}
for name, val in future_class_attr.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
# reuse the type.__new__ method
# this is basic OOP, nothing magic in there
return type.__new__(upperattr_metaclass, future_class_name,
future_class_parents, uppercase_attr)
追加の引数upperattr_metaclassに気付いたかもしれません。特別なことは何もありません：__new__は常に最初のパラメータとしてそれが定義されているクラスを受け取ります。あなたが最初のパラメータとしてインスタンスを受け取る通常のメソッドのためのself、またはクラスメソッドのための定義クラスがあるように。
もちろん、ここで使用した名前はわかりやすくするために長いものですが、selfの場合と同様に、すべての引数には従来の名前が付けられています。実際のプロダクションメタクラスは次のようになります。
class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return type.__new__(cls, clsname, bases, uppercase_attr)
継承を容易にするsuperを使用することで、さらにクリーンにすることができます（メタクラスから継承し、型から継承するメタクラスを使用できるため）。
class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)
ああ、そしてあなたがこのようにキーワード引数でこの呼び出しを行うなら、Python 3では：
class Foo(object, metaclass=Thing, kwarg1=value1):
...
それはそれを使うためにメタクラスではこれに変換されます。
class Thing(type):
def __new__(cls, clsname, bases, dct, kwargs1=default):
...
それでおしまい。メタクラスについては、これ以上何もありません。
メタクラスを使用するコードの複雑さの背後にある理由は、メタクラスが原因ではありません。それは、イントロスペクション、継承の操作、__dict__などのvarsなどに依存するツイスト処理を行うために通常メタクラスを使用するためです。
確かに、メタクラスは黒魔術をするために特に有用です、そしてそれ故に複雑なもの。しかし、それだけで、それらは単純です。
- クラス作成を傍受する
- クラスを修正する
- 変更したクラスを返す
なぜ関数の代わりにメタクラスクラスを使うのですか？
__metaclass__は任意の呼び出し可能オブジェクトを受け入れることができるので、明らかにより複雑なのでなぜクラスを使用するのでしょうか。
その理由はいくつかあります。
- その意図は明らかです。
UpperAttrMetaclass(type)を読むと、何が続くのかがわかります。 - あなたはOOPを使うことができます。メタクラスはメタクラスから継承し、親メソッドをオーバーライドすることができます。メタクラスはメタクラスも使用できます。
- メタクラスクラスを指定した場合、クラスのサブクラスはそのメタクラスのインスタンスになりますが、メタクラス関数には含まれません。
- あなたはより良いあなたのコードを構築することができます。上記の例のように些細なことにメタクラスを使用することは決してありません。それは通常複雑なもののためです。複数のメソッドを作成し、それらを1つのクラスにグループ化する機能を持つことは、コードを読みやすくするために非常に便利です。
__new__、__init__および__call__をフックすることができます。これはあなたが別のことをすることを可能にするでしょう。通常、__new__ですべてできる場合でも、__init__を使用する方がずっと快適な人もいます。- これらはメタクラスと呼ばれています。それは何かを意味する必要があります！
なぜあなたはメタクラスを使うのですか？
今度は大きな問題です。あいまいなエラーが発生しやすい機能を使用するのはなぜですか。
まあ、通常あなたはしません：
メタクラスは、99％のユーザーが心配してはいけないという、より深い魔法です。あなたがそれらを必要とするかどうか疑問に思うなら、あなたはそうではありません（実際にそれらを必要とする人々は彼らがそれらを必要とすることを確実に知っています、そしてなぜか説明を必要としません）。
Python Guru Tim Peters
メタクラスの主な使用例はAPIの作成です。この典型的な例はDjango ORMです。
それはあなたがこのような何かを定義することを可能にします：
class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
しかし、あなたがこれをするならば：
guy = Person(name='bob', age='35')
print(guy.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では若干異なります。
メタクラスは「クラス」の仕事をする秘密のソースです。新しいスタイルオブジェクトのデフォルトのメタクラスは 'type'です。
class type(object)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
メタクラスは3つの引数を取ります。 ' name '、 ' bases 'および ' 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'
そして今、実際に何かを意味する例では、これは自動的に "attributes"リスト内の変数をクラスに設定し、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
「Initalised」がメタクラスinit_attributesを持つことによって得られる魔法の振る舞いは、Initalisedのサブクラスに渡されないことに注意してください。
さらに具体的な例を示します。クラスが作成されたときにアクションを実行するメタクラスを作成するために '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
メタクラスの用途の1つは、インスタンスに新しいプロパティとメソッドを自動的に追加することです。
たとえば、 Djangoモデル を見ると、それらの定義は少しわかりにくいように見えます。クラスプロパティを定義しているだけのようです。
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
しかし、実行時にはPersonオブジェクトはあらゆる種類の便利なメソッドで埋められます。 source を見て、すばらしいメタクラスを見つけてください。
他の人たちは、メタクラスがどのように機能するのか、そしてそれらがどのように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を取得します。
私はメタクラスプログラミングへの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 framework に見ることができると思います。モデルクラスはメタクラスアプローチを使用して、新しいモデルまたはフォームクラスを記述するための宣言型スタイルを有効にします。メタクラスがクラスを作成している間に、すべてのメンバーがクラス自体をカスタマイズする可能性を得ます。
残されているのは、メタクラスが何であるかがわからない場合、あなたが を必要としない確率は が99％であるということです。
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__()マジックメソッドをクラスに実装するとき可能です。
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()
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'
__qual:'NewClass'
Note:
クラスはいつでもインスタンス化されていないことに注意してください。クラスを作成するという単純な動作がmetaclassの実行を引き起こしました。
Tl; drバージョン
type(obj)関数はあなたにオブジェクトの型を取得します。
クラスのtype()はその メタクラス です。
メタクラスを使用するには
class Foo(object):
__metaclass__ = MyMetaClass
Pythonクラスは、それ自体が、そのインスタンスのメタクラスのオブジェクトです。
デフォルトのメタクラス。クラスを次のように決定したときに適用されます。
class foo:
...
メタクラスはクラス全体に何らかのルールを適用するために使用されます。たとえば、データベースにアクセスするためのORMを構築していて、各テーブルのレコードをそのフィールドにマッピングされたクラス（フィールド、ビジネスルールなどに基づいて）にする場合、メタクラスを使用するとします。たとえば、接続プールロジックです。これは、すべてのテーブルのすべてのクラスのレコードで共有されます。もう1つの用途は、複数のクラスのレコードを含む外部キーをサポートするためのロジックです。
メタクラスを定義すると、typeをサブクラス化し、次のマジックメソッドをオーバーライドしてロジックを挿入できます。
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クラスは型クラスのインスタンスです。つまり、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 （）、この時点で、たとえばクラス定義を修正し、新しいメソッドを追加して、修正された定義を返すことができます。
公表された回答に加えて、私はmetaclassがクラスの振る舞いを定義すると言うことができます。そのため、メタクラスを明示的に設定できます。 Pythonがキーワードclassを取得するたびに、Pythonは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'