问题描述：

什么是元类？它们有什么用处？

解决方案 1：

类作为对象

在深入研究元类之前，扎实掌握 Python 类是有益的。Python 拥有一个特别独特的类概念，它从 Smalltalk 语言中借鉴了这一概念。

在大多数语言中，类只是描述如何生成对象的代码片段。在 Python 中也是如此：

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

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

但在 Python 中，类的意义远不止于此。类也是对象。

是的，物体。

当 Python 脚本运行时，每行代码都会从上到下执行。当 Python 解释器遇到关键字时class，Python 会根据后面类的“描述”创建一个对象。因此，以下指令

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

...创建一个名为! 的对象ObjectCreator

这个对象（类）本身能够创建对象（称为实例）。

但它仍然是一个对象。因此，像所有对象一样：

• 你可以将其分配给变量1

JustAnotherVariable = ObjectCreator

• 你可以为它附加属性

ObjectCreator.class_attribute = 'foo'

• 您可以将其作为函数参数传递

print(ObjectCreator)

1请注意，仅仅将其分配给另一个变量并不会改变类的__name__，即，

>>> print(JustAnotherVariable)
    <class '__main__.ObjectCreator'>

>>> print(JustAnotherVariable())
    <__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))
    <class 'int'>

>>> print(type("1"))
    <class 'str'>

>>> print(type(ObjectCreator))
    <class 'type'>

>>> print(type(ObjectCreator()))
    <class '__main__.ObjectCreator'>

嗯，type还有完全不同的能力：它可以动态创建类。type可以将类的描述作为参数，并返回一个类。

（我知道，根据传递给同一个函数的参数，它有两种完全不同的用途，这是很愚蠢的。这是由于 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实际上是一个元类。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__现在， any 的是什么__class__？

>>> age.__class__.__class__
    <type 'type'>

>>> name.__class__.__class__
    <type 'type'>

>>> foo.__class__.__class__
    <type 'type'>

>>> b.__class__.__class__
    <type 'type'>

因此，元类只是创建类对象的东西。

如果愿意的话，您可以将其称为“类工厂”。

type是 Python 使用的内置元类，但当然，您可以创建自己的元类。

属性__metaclass__​

__metaclass__在 Python 2 中，你可以在编写类时添加属性（请参阅下一部分了解 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 找不到__metaclass__，它将在 MODULE 级别寻找__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 中元类中添加的一项功能是，您还可以将属性作为关键字参数传递到元类中，如下所示：

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

阅读下面的部分了解 Python 如何处理这个问题。

自定义元类

元类的主要目的是在创建类时自动更改类。

您通常对 API 执行此操作，在其中您想要创建与当前上下文匹配的类。

想象一个愚蠢的例子，你决定模块中的所有类的属性都应大写。有几种方法可以做到这一点，但其中一种方法是__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()
        }

        # Python 2 requires passing arguments to super:
        return super(UpperAttrMetaclass, cls).__new__(
            cls, clsname, bases, uppercase_attrs)

        # Python 3 can use no-arg super() which infers them:
        return super().__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。元类可以从元类继承，覆盖父类方法。元类甚至可以使用元类。

• 如果您指定了元类，但没有指定元类函数，则类的子类将是其元类的实例。

• 您可以更好地构造代码。您永远不会将元类用于像上述示例这样微不足道的事情。它通常用于复杂的事情。能够创建多个方法并将它们分组到一个类中对于使代码更易于阅读非常有用。

• 您可以挂接__new__、__init__和__call__。这将允许您执行不同操作，即使通常您可以在 中完成所有操作__new__，但有些人更喜欢使用__init__。

• 这些被称为元类，该死！它一定意味着什么！

为什么要使用元类？

现在最大的问题是，你为什么要使用一些容易出错的模糊功能？

嗯，通常你不会：

元类是更深层次的魔法，99% 的用户永远不必担心它。如果您想知道是否需要它们，那么您就不需要它们（真正需要它们的人肯定知道他们需要它们，并且不需要解释为什么）。

Python 大师 Tim Peters

元类的主要用例是创建 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 可以重现的东西，而是通过在实现级别上稍微作弊来实现的。

其次，元类很复杂。您可能不想将它们用于非常简单的类更改。您可以使用两种不同的技术来更改类：

• 猴子补丁

• 类装饰器

99％ 的时间里您需要进行班级变更，最好使用这些。

但 98% 的时间里，你根本不需要改变职业。

解决方案 2：

元类是类的类。类定义类的实例（即对象）的行为方式，而元类定义类的行为方式。类是元类的实例。

虽然在 Python 中你可以使用任意可调用函数作为元类（如Jerub所示），但更好的方法是将其本身变为一个实际的类。type是 Python 中常见的元类。type本身是一个类，并且是它自己的类型。你无法type在纯粹的 Python 中重新创建类似的东西，但 Python 会稍微作弊。要在 Python 中创建自己的元类，你实际上只需要子类化type。

元类最常用作类工厂。当您通过调用类来创建对象时，Python 会通过调用元类来创建一个新类（当它执行“class”语句时）。因此，结合常规__init__和__new__方法，元类允许您在创建类时执行“额外操作”，例如使用某个注册表注册新类或用其他类完全替换该类。

class执行该语句时，Python 首先将class语句主体作为普通代码块执行。生成的命名空间（字典）保存了待生成类的属性。通过查看待生成类的基类（元类是继承的）、待生成类__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__

解决方案 3：

请注意，这个答案针对的是 Python 2.x，因为它是在 2008 年编写的，元类在 3.x 中略有不同。

元类是让“类”发挥作用的秘密武器。新样式对象的默认元类称为“类型”。

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'

现在，一个实际上有意义的例子，这将自动使在类上设置的“属性”列表中的变量设置为 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

解决方案 4：

其他人已经解释了元类的工作原理以及它们如何融入 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，用于记录类的定义顺序。

解决方案 5：

元类的一个用途是自动向实例添加新属性和方法。

例如，如果你看一下Django 模型，它们的定义看起来有点令人困惑。看起来好像你只是在定义类属性：

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

然而，运行时 Person 对象充满了各种有用的方法。请参阅源代码以了解一些令人惊奇的元类。

解决方案 6：

我认为 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 中，类也需要是一等对象才能实现此行为。

我自己从未写过，但我认为元类最出色的用途之一可以在Django 框架中看到。模型类使用元类方法来实现声明式的编写新模型或形成类。当元类创建类时，所有成员都可以自定义类本身。

• 创建新模型

• 实现这一点的元类

剩下要说的是：如果您不知道元类是什么，那么您不需要它们的可能性是 99%。

解决方案 7：

什么是元类？它们有何用途？

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 对象时，我们可以默认做的最有价值的事情之一就是为其提供一个好的__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__定义，我们就可以更有效地调试代码。但是，eval(repr(Class))不太可能进行进一步检查（因为函数不可能从其默认__repr__值进行评估）。

预期用途：__prepare__命名空间

例如，如果我们想知道类的方法是以什么顺序创建的，我们可以提供一个有序的字典作为类的命名空间。如果它是在 Python 3 中实现的，我们将使用__prepare__which返回该类的命名空间字典来执行此操作：

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>})

解决方案 8：

Python 3 更新

（此时）元类中有两种关键方法：

• __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)

如您所见，您必须重复两次属性名称。这不仅容易导致拼写错误，还可能产生令人恼火的错误。

一个简单的元类可以解决这个问题：

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

解决方案 9：

__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

解决方案 10：

Ametaclass是一个类，它告诉应如何创建（某个）其他类。

metaclass这是我所看到的解决问题的案例：我有一个非常复杂的问题，可能可以用不同的方法解决，但我选择使用 来解决它metaclass。由于其复杂性，它是我编写的少数几个模块之一，其中模块中的注释超过了已编写的代码量。这里是...

#!/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()

解决方案 11：

tl;dr 版本

该type(obj)函数获取对象的类型。

type()类的 是其元类。

要使用元类：

class Foo(object):
    __metaclass__ = MyMetaClass

type是其自己的元类。类的类是元类——类的主体是传递给元类的参数，用于构造类。

在这里您可以阅读有关如何使用元类来定制类构造的信息。

解决方案 12：

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。

解决方案 13：

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

无论如何，这两个是最常用的钩子。元分类功能强大，并且上面远没有列出元分类的详尽用途。

解决方案 14：

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 类的实例。也就是说，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']

当我们在元类中传递关键字参数时，魔法就会生效，它指示 Python 解释器通过 ListMetaclass.new() 创建 CustomList，此时，我们可以修改类的定义，比如添加一个新的方法然后返回修改后的定义。

解决方案 15：

除了已发布的答案之外，我还可以说，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'

解决方案 16：

请注意，在 Python 3.6 中引入了一种新的 dunder 方法__init_subclass__(cls, **kwargs)来替换元类的许多常见用例。当创建定义类的子类时，将调用该方法。请参阅Python 文档。

解决方案 17：

下面是其用途的另一个示例：

• 您可以使用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的威力很大，你可以用它做很多事情（比如猴子魔法），但要小心，这可能只有你知道。

解决方案 18：

最佳答案是正确的。

但读者可能来这里是为了寻找有关类似名称的内部类的答案。它们存在于流行的库中，例如Django和WTForms。

正如 DavidW 在该答案下方的评论中指出的那样，这些是特定于库的功能，不要与具有类似名称的高级、不相关的Python 语言功能相混淆。

相反，这些是类字典内的命名空间。为了便于阅读，它们是使用内部类构建的。

在这个例子中，特殊字段abstract明显与作者模型的字段分开。

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=50)
    email = models.EmailField()

    class Meta:
        abstract = True

另一个例子来自文档WTForms：

from wtforms.form import Form
from wtforms.csrf.session import SessionCSRF
from wtforms.fields import StringField

class MyBaseForm(Form):
    class Meta:
        csrf = True
        csrf_class = SessionCSRF

    name = StringField("name")

此语法在 Python 编程语言中没有得到特殊处理。此处不是关键字，不会触发元类行为。相反，和Meta等包中的第三方库代码会在某些类的构造函数和其他地方读取此属性。Django`WTForms`

这些声明的存在会修改具有这些声明的类的行为。例如，WTForms读取self.Meta.csrf以确定表单是否需要字段csrf。

解决方案 19：

在面向对象编程中，元类是其实例为类的类。就像普通类定义某些对象的行为一样，元类定义某些类及其实例的行为。元类一词只是用于创建类的东西。换句话说，它是类的类。元类用于创建类，因此就像对象是类的实例一样，类是元类的实例。在 Python 中，类也被视为对象。

解决方案 20：

在 Python 中，类是一个对象，就像任何其他对象一样，它是“某物”的一个实例。这个“某物”就是所谓的元类。元类是一种特殊类型的类，可以创建其他类的对象。因此，元类负责创建新的类。这允许程序员自定义类的生成方式。

要创建元类，通常需要重写new () 和init () 方法。可以重写new () 来更改创建对象的方式，而可以重写init () 来更改初始化对象的方式。可以通过多种方式创建元类。其中一种方法是使用 type() 函数。当使用 3 个参数调用 type() 函数时，会创建一个元类。参数包括：

1. 类名

2. 具有由类继承的基类的元组

3. 包含所有类方法和类变量的字典

创建元类的另一种方法是使用“metaclass”关键字。将元类定义为简单类。在继承类的参数中，传递 metaclass=metaclass_name

元类具体可用于以下情况：

1. 当必须将特定效果应用于所有子类时

2. 需要自动更改类别（创建时）

3. 由 API 开发人员提供

解决方案 21：

我在一个名为 的包中看到了元类的一个有趣用例classutilities。它检查所有类变量是否都是大写格式（对于配置类来说，统一逻辑很方便），并检查类中是否没有实例级方法。元类的另一个有趣示例是根据复杂条件（检查多个环境变量的值）停用单元测试。

解决方案 22：

在 Python 中，元类是子类的子类，它决定了子类的行为方式。类是另一个元类的实例。在 Python 中，类指定了类的实例将如何表现。

由于元类负责类的生成，因此您可以编写自己的自定义元类，通过执行其他操作或注入代码来更改类的创建方式。自定义元类并不总是很重要，但它们可能很重要。

解决方案 23：

看看这个：

Python 3.10.0rc2 (tags/v3.10.0rc2:839d789, Sep  7 2021, 18:51:45) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> class Object:
...     pass
... 
>>> class Meta(type):
...     test = 'Worked!!!'
...     def __repr__(self):
...             return 'This is "Meta" metaclass'
... 
>>> class ObjectWithMetaClass(metaclass=Meta):
...     pass
... 
>>> Object or type(Object())
<class '__main__.Object'>
>>> ObjectWithMetaClass or type(ObjectWithMetaClass())
This is "Meta" metaclass
>>> Object.test
AttributeError: ...
>>> ObjectWithMetaClass.test
'Worked!!!'
>>> type(Object)
<class 'type'>
>>> type(ObjectWithMetaClass)
<class '__main__.Meta'>
>>> type(type(ObjectWithMetaClass))
<class 'type'>
>>> Object.__bases__
(<class 'object'>,)
>>> ObjectWithMetaClass.__bases__
(<class 'object'>,)
>>> type(ObjectWithMetaClass).__bases__
(<class 'type'>,)
>>> Object.__mro__
(<class '__main__.Object'>, <class 'object'>)
>>> ObjectWithMetaClass.__mro__
(This is "Meta" metaclass, <class 'object'>)
>>> 

换句话说，当未创建对象（对象类型）时，我们会查找 MetaClass。

解决方案 24：

我想补充一点type.__new__()为什么type()

首先，看看下面的课程

In [1]: class MyMeta(type):
   ...:     def __new__(cls, cls_name, bases, attrs):
   ...:         print(cls, cls_name, bases, attrs)
   ...:         return super().__new__(cls, cls_name, bases, attrs)
   ...:

In [2]: class AClass(metaclass=MyMeta):
   ...:     pass
   ...:
<class '__main__.MyMeta'> AClass () {'__module__': '__main__', '__qualname__': 'AClass'}

In [3]: class BClass:
   ...:     pass
   ...:

In [4]: AClass.__class__
Out[4]: __main__.MyMeta

In [5]: BClass.__class__
Out[5]: type

In [6]: class SubAClass(AClass):
   ...:     pass
   ...:
<class '__main__.MyMeta'> SubAClass (<class '__main__.AClass'>,) {'__module__': '__main__', '__qualname__': 'SubAClass'}

1. type.__new__刚刚分配MyMeta给AClass.__class__。

how?type.__new__将采用第一个参数 cls，它

是 MyMeta，并且执行AClass.__class__ = MyMeta。

当我们尝试创建 SubAClass 的子类 AClass 时，Python 会

看一下我们指定用于创建 SubAClass 的元类

在这种情况下，我们没有为 SubAClass 传递元类，因此 Python 得到了元类的 None。

然后 Python 会尝试获取 SubAClass 的第一个基类的元类，显然它得到了MyMeta。

1. 如果你打电话type()而不是type.__new__，那么我们

必须AClass.__class__是type。为什么？

type()仍然调用但隐式地作为第一个参数type.__new__传递。type

这意味着 AClass 相当于 BClass，它们都有类型

作为他们的__class__属性

元类的搜索在 C 代码中是如何进行的？

它的工作原理和我们刚才提到的差不多

当你定义一个类时，该函数builtin___build_class__将被调用

代码非常简单

static PyObject *
builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
                        PyObject *kwnames){

    if (meta == NULL) {
        /* if there are no bases, use type: */
        if (PyTuple_GET_SIZE(bases) == 0) {
            meta = (PyObject *) (&PyType_Type);
        }
        /* else get the type of the first base */
        else {
            PyObject *base0 = PyTuple_GET_ITEM(bases, 0);
            meta = (PyObject *)Py_TYPE(base0);
        }
        Py_INCREF(meta);
        isclass = 1;  /* meta is really a class */
    }

    PyObject *margs[3] = {name, bases, ns};
    cls = PyObject_VectorcallDict(meta, margs, 3, mkw);
}

基本上meta = (PyObject *)Py_TYPE(base0);就是我们想知道的一切

可以翻译为
meta = Py_TYPE(AClass) = MyMeta = AClass.__class__

解决方案 25：

如果你对元编程感兴趣，那么你应该知道元编程是一种控制编程