什么是元类，我们将它们用于什么？
答案 0 :(得分：6252)
答案 1 :(得分：2473)
元类是类的类。类定义了类的实例（即对象）在元类定义类的行为方式时的行为方式。类是元类的实例。
虽然在Python中你可以为元类使用任意的callables（比如Jerub节目），但更好的方法是让它成为一个真正的类本身。 type是Python中常用的元类。 type本身就是一个类，它是它自己的类型。您将无法仅在Python中重新创建type之类的内容，但Python会有所作为。要在Python中创建自己的元类，你真的只想要继承type。
元类最常用作类工厂。当您通过调用类创建对象时，Python通过调用元类创建一个新类（当它执行'class'语句时）。结合正常的__init__和__new__方法，元类因此允许您在创建类时执行“额外的事情”，例如使用某些注册表注册新类或者将类完全替换为其他类。 / p>
执行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__
答案 2 :(得分：351)
注意，这个答案适用于Python 2.x，因为它是在2008年编写的，元类在3.x中略有不同。
元类是让“课堂”工作的秘诀。新样式对象的默认元类称为“类型”。
class type(object)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
元类需要3个参数。 '名称'，'基础'和' dict '
这是秘密开始的地方。在此示例类定义中查找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
请注意，通过使用元类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
答案 3 :(得分：144)
元类的一个用途是自动向实例添加新属性和方法。
例如，如果你看一下Django models，他们的定义看起来有点令人困惑。看起来好像只是定义了类属性：
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
但是，在运行时，Person对象充满了各种有用的方法。请参阅source了解一些神奇的元素。
答案 4 :(得分：144)
其他人已经解释了元类如何工作以及它们如何适应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 :(得分：105)
我认为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 framework中可以看到元类最好的用法之一。模型类使用元类方法来启用编写新模型或表单类的声明式样式。虽然元类正在创建类，但所有成员都可以自定义类。
剩下要说的是：如果你不知道什么是元类，你不需要它们的可能性是99％。
答案 6 :(得分：91)
什么是元类？你用它们做什么？
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执行它时，它使用元类来实例化类对象（反过来，它将用于实例化该类的实例）。
正如我们可以使用类定义来改变自定义对象实例的行为方式一样，我们可以使用元类定义来改变类对象的行为方式。
它们可以用于什么？来自docs：
元类的潜在用途是无限的。已探索的一些想法包括日志记录，接口检查，自动委托，自动属性创建，代理，框架和自动资源锁定/同步。
尽管如此，除非绝对必要，否则通常鼓励用户避免使用元类。
编写类定义时，例如，像这样，
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__ - 如果我们define __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}), {returns the namespace dict for the class if it is implemented in Python 3})'.format(metaname, name, parents, namespace)
def __eq__(cls, other):
"""
>>> Baz == eval(repr(Baz))
True
"""
return (cls.__name__, cls.__bases__, cls.__dict__) == (
other.__name__, other.__bases__, other.__dict__)
所以现在当我们用这个元类创建一个对象时，命令行上回显的__repr__提供的视线比默认值要小得多：
>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
为类实例定义了一个很好的__repr__，我们有更强的调试代码的能力。但是，使用eval(repr(Class))进行进一步检查是不太可能的（因为从默认的__repr__开始计算函数是不可能的。）
__prepare__命名空间例如，如果我们想知道创建类的方法的顺序，我们可以提供一个有序的dict作为类的命名空间。我们会使用__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'>)
请注意，此示例改编自documentation - 新enum in the standard library执行此操作。
所以我们所做的是通过创建一个类来实例化一个元类。我们也可以像处理任何其他类一样对待元类。它有一个方法解析顺序：
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>})
（除非我们能找到表示我们函数的方法，否则我们不能再进行评估。）：
{{1}}
答案 7 :(得分：66)
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
答案 8 :(得分：57)
__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__()方法。但正如我们从前面的答案中看到的，类本身是元类的一个实例，所以当我们将类用作可调用的时（即当我们创建它的实例时），我们实际上正在调用它的元类“{{1} } 方法。在这一点上，大多数Python程序员都有点困惑，因为他们被告知在创建像__call__()这样的实例时，你正在调用它的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答案 9 :(得分：50)
元类是一个类，它告诉我们应该如何（某些）创建其他类。
这是我看到元类作为我的问题的解决方案的情况： 我有一个非常复杂的问题，可能是以不同方式解决的，但我选择使用元类来解决它。由于其复杂性，它是我编写的少数几个模块之一，其中模块中的注释超过了已编写的代码量。这是......
#!/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()
答案 10 :(得分：36)
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的执行。
答案 11 :(得分：32)
type(obj)函数可以获取对象的类型。
类的type()是元类。
使用元类：
class Foo(object):
__metaclass__ = MyMetaClass
答案 12 :(得分：22)
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
无论如何，这两个是最常用的钩子。元类化是强大的，并且上面是远远不足和详尽的元类别用途列表。
答案 13 :(得分：17)
type（）函数可以返回对象的类型或创建新类型
例如，我们可以使用type（）函数创建一个Hi类，而不需要使用这种方式与类Hi（对象）：
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 （），此时，我们可以修改类定义，例如，添加一个新方法，然后返回修改后的定义。
答案 14 :(得分：7)
除了已发布的答案外，我可以说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'
答案 15 :(得分：4)
请注意，在python 3.6中，引入了新的dunder方法__init_subclass__(cls, **kwargs)来替换元类的许多常见用例。创建定义类的子类时调用is。参见python docs。
答案 16 :(得分：2)
在 Python 中，元类是决定子类行为方式的子类的子类。一个类是另一个元类的实例。在 Python 中，类指定类的实例将如何表现。
由于元类负责类生成，因此您可以编写自己的自定义元类，通过执行其他操作或注入代码来更改类的创建方式。自定义元类并不总是很重要，但它们可能很重要。
答案 17 :(得分：2)
我在名为 classutilities 的包中看到了一个有趣的元类用例。它检查所有类变量是否都是大写格式（方便配置类有统一的逻辑），并检查类中是否没有实例级方法。
元类的另一个有趣示例是基于复杂条件（检查多个环境变量的值）停用单元测试。
答案 18 :(得分：1)
定义：
元类是其实例是类的类。就像“普通”类定义类的实例的行为一样，元类定义类及其实例的行为。
不是所有的面向对象的编程语言都支持元类。支持元类的那些编程语言，在实现它们的方式上有很大的不同。 Python支持它们。
一些程序员将Python中的元类视为“等待或寻找问题的解决方案”。
元类有很多用例。
logging and profiling interface checking registering classes at creation time automatically adding new methods automatic property creation proxies automatic resource locking/synchronization.
定义元类：
它将在 new 方法中打印其参数的内容并返回类型的结果。 new 调用：
class LittleMeta(type):
def __new__(cls, clsname, superclasses, attributedict):
print("clsname: ", clsname)
print("superclasses: ", superclasses)
print("attributedict: ", attributedict)
return type.__new__(cls, clsname, superclasses, attributedict)
在下面的示例中，我们将使用元类“ LittleMeta”：
class S:
pass
class A(S, metaclass=LittleMeta):
pass
a = A()
输出：
clsname: A
superclasses: (<class '__main__.S'>,)
attributedict: {'__module__': '__main__', '__qualname__': 'A'}
答案 19 :(得分：1)
Python中的metaclass是一个类的类，它定义类的行为。类本身就是metaclass的实例。 Python中的类定义了该类实例的行为。我们可以通过在类定义中传递metaclass关键字来自定义类创建过程。也可以通过继承已通过此关键字传递的类来完成此操作。
class MyMeta(type):
pass
class MyClass(metaclass=MyMeta):
pass
class MySubclass(MyClass):
pass
我们可以看到MyMeta类的类型是type，MyClass和MySubClass的类型是MyMeta。
print(type(MyMeta))
print(type(MyClass))
print(type(MySubclass))
<class 'type'>
<class '__main__.MyMeta'>
<class '__main__.MyMeta'>
在定义类时，未定义任何metaclass，将使用默认类型metaclass。如果给出了metaclass，但它不是type()的实例，那么它将直接用作metaclass。
元类可以应用于日志记录，创建时注册类以及进行概要分析。它们似乎是非常抽象的概念，您可能想知道是否需要使用它们。
答案 20 :(得分：0)
这是它可以用来做什么的另一个例子：
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功能强大，可以执行许多操作（例如猴子魔术），但请注意，这可能只有您知道。
答案 21 :(得分：-1)
在面向对象的编程中，元类是其实例为类的类。正如普通类定义某些对象的行为一样，元类定义某些类及其实例的行为 元类一词仅表示用于创建类的内容。换句话说，它是一个类的类。元类用于创建类，就像对象是类的实例一样，类是元类的实例。在python中，类也被视为对象。
答案 22 :(得分：-2)
元类只不过是模型类的简单内部类，例如： 在 Django 或 python 中
class Author(models.Model):
name = models.CharField(max_length=50)
email = models.EmailField()
class Meta:
abstract = True
这里，如果abstract = True，这个模型将是一个抽象基类。元类会改变你的基类的行为。
答案 23 :(得分：-5)
元类是一种类，它定义类的行为方式，或者我们可以说类本身是元类的实例。