Answers:
元类是类的类。类定义类的实例(即对象)的行为,而元类定义类的行为。类是元类的实例。
虽然在Python中,您可以对元类使用任意可调用对象(例如Jerub演示),但是更好的方法是使其成为实际的类。type
是Python中常见的元类。type
它本身是一个类,并且是它自己的类型。您将无法type
纯粹使用Python 重新创建类似的东西,但是Python有点作弊。要在Python中创建自己的元类,您实际上只想将其子类化type
。
元类最常用作类工厂。当通过调用类创建对象时,Python通过调用元类来创建一个新类(执行“ class”语句时)。因此,将元类与普通方法__init__
和__new__
方法结合使用,可以使您在创建类时做“额外的事情”,例如使用某些注册表注册新类或将其完全替换为其他类。
class
执行该语句时,Python首先将class
语句的主体作为普通代码块执行。生成的名称空间(一个dict)保存了将来类的属性。通过查看要成为类的基类(继承了元类),要成为__metaclass__
的类(如果有)的属性或__metaclass__
全局变量来确定元类。然后使用该类的名称,基数和属性调用该元类以实例化它。
但是,元类实际上定义了类的类型,而不仅仅是它的工厂,因此您可以使用它们做更多的事情。例如,您可以在元类上定义常规方法。这些元类方法就像类方法,因为它们可以在没有实例的情况下在类上调用,但是它们也不像类方法,因为它们不能在类的实例上被调用。type.__subclasses__()
是type
元类上方法的示例。您还可以定义正常的“魔力”的方法,如__add__
,__iter__
和__getattr__
,执行或如何变化的类的行为。
这是点滴的汇总示例:
def make_hook(f):
"""Decorator to turn 'foo' method into '__foo__'"""
f.is_hook = 1
return f
class MyType(type):
def __new__(mcls, name, bases, attrs):
if name.startswith('None'):
return None
# Go over attributes and see if they should be renamed.
newattrs = {}
for attrname, attrvalue in attrs.iteritems():
if getattr(attrvalue, 'is_hook', 0):
newattrs['__%s__' % attrname] = attrvalue
else:
newattrs[attrname] = attrvalue
return super(MyType, mcls).__new__(mcls, name, bases, newattrs)
def __init__(self, name, bases, attrs):
super(MyType, self).__init__(name, bases, attrs)
# classregistry.register(self, self.interfaces)
print "Would register class %s now." % self
def __add__(self, other):
class AutoClass(self, other):
pass
return AutoClass
# Alternatively, to autogenerate the classname as well as the class:
# return type(self.__name__ + other.__name__, (self, other), {})
def unregister(self):
# classregistry.unregister(self)
print "Would unregister class %s now." % self
class MyObject:
__metaclass__ = MyType
class NoneSample(MyObject):
pass
# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)
class Example(MyObject):
def __init__(self, value):
self.value = value
@make_hook
def add(self, other):
return self.__class__(self.value + other.value)
# Will unregister the class
Example.unregister()
inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()
print inst + inst
class Sibling(MyObject):
pass
ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__
__metaclass__
Python 3不支持。在Python 3中class MyObject(metaclass=MyType)
,请使用python.org/dev/peps/pep-3115和以下答案。
在理解元类之前,您需要掌握Python的类。Python从Smalltalk语言中借用了一个非常特殊的类概念。
在大多数语言中,类只是描述如何产生对象的代码段。在Python中也是如此:
>>> class ObjectCreator(object):
... pass
...
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>
但是类比Python中更多。类也是对象。
是的,对象。
一旦使用关键字class
,Python就会执行它并创建一个对象。指令
>>> class ObjectCreator(object):
... pass
...
在内存中创建一个名称为“ ObjectCreator”的对象。
这个对象(类)本身具有创建对象(实例)的能力,这就是为什么它是一个类。
但是,它仍然是一个对象,因此:
例如:
>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
... print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>
由于类是对象,因此您可以像创建任何对象一样即时创建它们。
首先,您可以使用class
以下方法在函数中创建一个类:
>>> def choose_class(name):
... if name == 'foo':
... class Foo(object):
... pass
... return Foo # return the class, not an instance
... else:
... class Bar(object):
... pass
... return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>
但这并不是那么动态,因为您仍然必须自己编写整个类。
由于类是对象,因此它们必须由某种东西生成。
使用class
关键字时,Python会自动创建此对象。但是,与Python中的大多数事情一样,它为您提供了一种手动进行操作的方法。
还记得功能type
吗?好的旧函数可以让您知道对象的类型:
>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>
嗯,type
具有完全不同的功能,它也可以动态创建类。type
可以将类的描述作为参数,并返回一个类。
(我知道,根据传递给它的参数,同一个函数可以有两种完全不同的用法是很愚蠢的。由于在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__
任何__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将使用元类来创建class Foo
。
小心点,这很棘手。
您class Foo(object)
先编写,但Foo
尚未在内存中创建类对象。
Python将__metaclass__
在类定义中查找。如果找到它,它将使用它来创建对象类Foo
。如果没有,它将
type
用于创建类。
读几次。
当您这样做时:
class Foo(Bar):
pass
Python执行以下操作:
中有__metaclass__
属性Foo
吗?
如果是的话,在内存中创建一个类对象(我说的是类对象,陪在我身边在这里),名称Foo
使用是什么__metaclass__
。
如果Python找不到__metaclass__
,它将__metaclass__
在MODULE级别查找a ,然后尝试执行相同的操作(但仅适用于不继承任何内容的类,基本上是老式的类)。
然后,如果根本找不到任何对象__metaclass__
,它将使用Bar
的(第一个父对象)自己的元类(可能是默认值type
)创建类对象。
请注意,该__metaclass__
属性将不会被继承,父(Bar.__class__
)的元类将被继承。如果Bar
使用的__metaclass__
是创建的属性Bar
与type()
(不是type.__new__()
),子类不会继承该行为。
现在最大的问题是,您可以输入__metaclass__
什么?
答案是:可以创建类的东西。
什么可以创建一个类?type
,或任何继承或使用它的内容。
设置元类的语法在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()
}
return super(UpperAttrMetaclass, cls).__new__(
cls, clsname, bases, uppercase_attrs)
哦,在python 3中,如果您使用关键字参数进行此调用,例如:
class Foo(object, metaclass=MyMetaclass, kwarg1=value1):
...
它将在元类中转换为使用它:
class MyMetaclass(type):
def __new__(cls, clsname, bases, dct, kwargs1=default):
...
而已。实际上,关于元类的更多信息了。
使用元类编写代码的复杂性背后的原因不是因为元类,而是因为您通常使用元类依靠自省,操纵继承以及诸如var之类的变量来做扭曲的事情__dict__
。
实际上,元类对于进行黑魔法特别有用,因此也很复杂。但就其本身而言,它们很简单:
既然__metaclass__
可以接受任何可调用对象,那么为什么要使用一个类,因为它显然更复杂?
这样做有几个原因:
UpperAttrMetaclass(type)
,您会知道接下来会发生什么__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
define __metaclass__
并使用了一些魔术,这些魔术将使Person
您使用简单语句定义的对象变成与数据库字段的复杂挂钩。
Django通过公开一个简单的API并使用元类,从该API重新创建代码来完成幕后的实际工作,使看起来复杂的事情变得简单。
首先,您知道类是可以创建实例的对象。
实际上,类本身就是实例。元类的。
>>> class Foo(object): pass
>>> id(Foo)
142630324
一切都是Python中的对象,它们都是类的实例或元类的实例。
除了type
。
type
实际上是它自己的元类。这不是您可以在纯Python中复制的东西,而是通过在实现级别上作弊来完成的。
其次,元类很复杂。您可能不希望将它们用于非常简单的类更改。您可以使用两种不同的技术来更改类:
99%的时间您需要班级变更,最好使用这些。
但是在98%的时间中,您根本不需要更改班级。
models.Model
它没有使用__metaclass__
,而是class Model(metaclass=ModelBase):
引用了一个ModelBase
类,该类随后执行了上述的元类魔术。很棒的帖子!这里的Django的源:github.com/django/django/blob/master/django/db/models/...
__metaclass__
属性将不会被继承,而父(Bar.__class__
)的元类将被继承。如果Bar
使用的__metaclass__
是Bar
使用type()
(而不是type.__new__()
)创建的属性,则子类将不会继承该行为。>>-您/某人能否更详细地说明这段内容?
Now you wonder why the heck is it written in lowercase, and not Type?
-很好,因为它是用C语言实现的-这是相同的原因,defaultdict是小写而OrderedDict(在python 2中)是正常的CamelCase
请注意,此答案适用于2008年编写的Python 2.x,元类在3.x中略有不同。
元类是使“类”工作的秘诀。新样式对象的默认元类称为“类型”。
class type(object)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
元类带有3个参数。' 名称 ',' 基数 '和' 字典 '
这是秘密的开始。在此示例类定义中查找名称,基数和字典来自何处。
class ThisIsTheName(Bases, Are, Here):
All_the_code_here
def doesIs(create, a):
dict
让我们定义一个元类,该元类将演示“ class: ” 如何调用它。
def test_metaclass(name, bases, dict):
print 'The Class Name is', name
print 'The Class Bases are', bases
print 'The dict has', len(dict), 'elems, the keys are', dict.keys()
return "yellow"
class TestName(object, None, int, 1):
__metaclass__ = test_metaclass
foo = 1
def baz(self, arr):
pass
print 'TestName = ', repr(TestName)
# output =>
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName = 'yellow'
现在,一个实际上意味着含义的示例将自动使列表中的变量在类上设置为“属性”,并设置为“无”。
def init_attributes(name, bases, dict):
if 'attributes' in dict:
for attr in dict['attributes']:
dict[attr] = None
return type(name, bases, dict)
class Initialised(object):
__metaclass__ = init_attributes
attributes = ['foo', 'bar', 'baz']
print 'foo =>', Initialised.foo
# output=>
foo => None
请注意,Initialised
通过拥有元类而获得的不可思议的行为init_attributes
不会传递到的子类上Initialised
。
这是一个更具体的示例,显示了如何子类化“类型”以创建一个在创建类时执行操作的元类。这很棘手:
class MetaSingleton(type):
instance = None
def __call__(cls, *args, **kw):
if cls.instance is None:
cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
return cls.instance
class Foo(object):
__metaclass__ = MetaSingleton
a = Foo()
b = Foo()
assert a is b
其他人则解释了元类如何工作以及它们如何适合Python类型系统。这是它们可以用来做什么的一个例子。在我编写的测试框架中,我想跟踪定义类的顺序,以便以后可以按此顺序实例化它们。我发现使用元类执行此操作最简单。
class MyMeta(type):
counter = 0
def __init__(cls, name, bases, dic):
type.__init__(cls, name, bases, dic)
cls._order = MyMeta.counter
MyMeta.counter += 1
class MyType(object): # Python 2
__metaclass__ = MyMeta
class MyType(metaclass=MyMeta): # Python 3
pass
子类的任何内容都MyType
将获得一个class属性_order
,该属性记录定义类的顺序。
__init__(self)
说type(self)._order = MyBase.counter; MyBase.counter += 1
?
元类的一种用途是自动向实例添加新的属性和方法。
例如,如果您查看Django模型,则其定义看起来有些混乱。似乎您只是在定义类属性:
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
但是,在运行时,Person对象充满了各种有用的方法。请参阅源代码中一些惊人的元类。
我认为ONLamp对元类编程的介绍写得很好,尽管已经有好几年历史了,但它对该主题却提供了非常好的介绍。
http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html(存档于https://web.archive.org/web/20080206005253/http://www.onlamp。 com / pub / a / python / 2003/04/17 / metaclasses.html)
简而言之:类是创建实例的蓝图,元类是创建类的蓝图。很容易看出,在Python中,类也必须是一流的对象才能启用此行为。
我从来没有自己写过书,但是我认为可以在Django框架中看到元数据类的最佳用法之一。模型类使用元类方法来启用声明性样式,以编写新模型或表单类。当元类创建类时,所有成员都可以自定义类本身。
剩下要说的是:如果您不知道什么是元类,则不需要它们的可能性为99%。
什么是元类?你用它们做什么?
TLDR:元类实例化并定义类的行为,就像类实例化并定义实例的行为一样。
伪代码:
>>> Class(...)
instance
上面看起来应该很熟悉。好吧,它Class
来自哪里?它是一个元类的实例(也是伪代码):
>>> Metaclass(...)
Class
在实际代码中,我们可以传递默认的元类,type
实例化一个类并获得一个类所需的一切:
>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace
<class '__main__.Foo'>
类是实例,而元类是实例。
当我们实例化一个对象时,我们得到一个实例:
>>> object() # instantiation of class
<object object at 0x7f9069b4e0b0> # instance
同样,当我们使用默认的元类显式定义一个类时type
,我们将其实例化:
>>> type('Object', (object,), {}) # instantiation of metaclass
<class '__main__.Object'> # instance
换句话说,类是元类的实例:
>>> isinstance(object, type)
True
换句话说,元类是类的类。
>>> type(object) == type
True
>>> object.__class__
<class 'type'>
当您编写一个类定义并由Python执行时,它使用一个元类来实例化该类对象(而该对象又将被用于实例化该类的实例)。
正如我们可以使用类定义来更改自定义对象实例的行为一样,我们可以使用元类类定义来更改类对象的行为。
它们可以用来做什么?从文档:
元类的潜在用途是无限的。已探索的一些想法包括日志记录,接口检查,自动委派,自动属性创建,代理,框架和自动资源锁定/同步。
然而,除非绝对必要,否则通常鼓励用户避免使用元类。
例如,当您编写类定义时,
class Foo(object):
'demo'
您实例化一个类对象。
>>> Foo
<class '__main__.Foo'>
>>> isinstance(Foo, type), isinstance(Foo, object)
(True, True)
这与在功能上调用type
适当的参数并将结果分配给该名称的变量相同:
name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)
请注意,一些东西会自动添加到__dict__
,即名称空间:
>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>,
'__module__': '__main__', '__weakref__': <attribute '__weakref__'
of 'Foo' objects>, '__doc__': 'demo'})
在这两种情况下,我们创建的对象的元类都是type
。
(关于类内容的注释__dict__
:__module__
是因为类必须知道它们的定义位置,而 因为我们没有定义__dict__
,__weakref__
所以存在__slots__
–如果定义,__slots__
我们将在实例中节省一些空间,例如我们可以禁止__dict__
并__weakref__
排除它们,例如:
>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})
>>> Baz.__dict__
mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})
...但是我离题了。)
type
像其他任何类定义一样扩展:这是默认__repr__
的类:
>>> Foo
<class '__main__.Foo'>
默认情况下,我们在编写Python对象时可以做的最有价值的事情之一就是为其提供良好的支持__repr__
。当我们打电话时,help(repr)
我们知道对a有一个好的测试__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__
名称空间例如,如果我们想知道类的方法以什么顺序创建,则可以提供一个有序的dict作为类的名称空间。如果这样做是在Python 3中实现的,我们将使用__prepare__
该方法返回该类的名称空间dict:
from collections import OrderedDict
class OrderedType(Type):
@classmethod
def __prepare__(metacls, name, bases, **kwargs):
return OrderedDict()
def __new__(cls, name, bases, namespace, **kwargs):
result = Type.__new__(cls, name, bases, dict(namespace))
result.members = tuple(namespace)
return result
和用法:
class OrderedMethodsObject(object, metaclass=OrderedType):
def method1(self): pass
def method2(self): pass
def method3(self): pass
def method4(self): pass
现在,我们记录了这些方法(和其他类属性)的创建顺序:
>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')
请注意,此示例改编自文档 - 标准库中的新枚举可实现此目的。
因此,我们要做的是通过创建一个类实例化一个元类。我们也可以像对待其他任何类一样对待元类。它具有方法解析顺序:
>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)
而且它大致正确repr
(除非找到能够表示函数的方法,否则我们将无法再评估它):
>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})
Python 3更新
(在这一点上)元类中有两个关键方法:
__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
__set_name__(cls, name)
在描述符(ValidateType
)中使用以在描述符中设置名称(self.name
在本例中也是self.attr
)。添加该属性是为了不必针对此特定的通用案例深入元类(请参阅PEP 487)。
__call__()
创建类实例时元类方法的作用如果您已经完成Python编程超过几个月,那么您最终会发现以下代码:
# define a class
class SomeClass(object):
# ...
# some definition here ...
# ...
# create an instance of it
instance = SomeClass()
# then call the object as if it's a function
result = instance('foo', 'bar')
当您__call__()
在类上实现magic方法时,后者是可能的。
class SomeClass(object):
# ...
# some definition here ...
# ...
def __call__(self, foo, bar):
return bar + foo
__call__()
当类的实例用作可调用对象时,将调用该方法。但是,正如我们从前面的答案中看到的那样,类本身是元类的实例,因此,当我们使用该类作为可调用对象时(即,当我们创建它的实例时),实际上是在调用其元类的__call__()
方法。在这一点上,大多数Python程序员有些困惑,因为有人告诉他们在创建这样的实例时instance = SomeClass()
要调用其__init__()
方法。有些谁已经挖一个深一点知道,之前__init__()
有__new__()
。好吧,今天,在__new__()
元类出现之前,另一层真相被揭示出来了__call__()
。
让我们从创建类实例的角度专门研究方法调用链。
这是一个元类,它准确记录实例创建之前和实例返回之前的时间。
class Meta_1(type):
def __call__(cls):
print "Meta_1.__call__() before creating an instance of ", cls
instance = super(Meta_1, cls).__call__()
print "Meta_1.__call__() about to return instance."
return instance
这是使用该元类的类
class Class_1(object):
__metaclass__ = Meta_1
def __new__(cls):
print "Class_1.__new__() before creating an instance."
instance = super(Class_1, cls).__new__(cls)
print "Class_1.__new__() about to return instance."
return instance
def __init__(self):
print "entering Class_1.__init__() for instance initialization."
super(Class_1,self).__init__()
print "exiting Class_1.__init__()."
现在让我们创建一个实例 Class_1
instance = Class_1()
# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.
# Class_1.__new__() before creating an instance.
# Class_1.__new__() about to return instance.
# entering Class_1.__init__() for instance initialization.
# exiting Class_1.__init__().
# Meta_1.__call__() about to return instance.
请注意,上面的代码除了记录任务之外实际上没有做任何其他事情。每个方法将实际工作委托给其父级的实现,从而保留默认行为。由于type
是Meta_1
的父类(type
是默认的父元类),并考虑了上面输出的排序顺序,因此我们现在可以知道什么是伪实现type.__call__()
:
class type:
def __call__(cls, *args, **kwarg):
# ... maybe a few things done to cls here
# then we call __new__() on the class to create an instance
instance = cls.__new__(cls, *args, **kwargs)
# ... maybe a few things done to the instance here
# then we initialize the instance with its __init__() method
instance.__init__(*args, **kwargs)
# ... maybe a few more things done to instance here
# then we return it
return instance
我们可以看到metaclass' __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
元类是一个告诉应该如何创建(某些)其他类的类。
在这种情况下,我将元类视为解决问题的方法:我遇到了一个非常复杂的问题,可能可以用其他方法解决,但我选择使用元类来解决。由于其复杂性,它是我编写的为数不多的模块之一,其中模块中的注释超过了已编写的代码量。这里是...
#!/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(obj)
函数获取对象的类型。
在type()
一类是它的元类。
要使用元类:
class Foo(object):
__metaclass__ = MyMetaClass
type
是它自己的元类。类的类是元类-类的主体是传递给用于构造类的元类的参数。
在这里,您可以了解有关如何使用元类自定义类构造的信息。
type
实际上是一个metaclass
创建另一个类的类。大多数metaclass
是的子类type
。所述metaclass
接收new
类作为其第一个参数,如下面所提到提供访问与细节类对象:
>>> class MetaClass(type):
... def __init__(cls, name, bases, attrs):
... print ('class name: %s' %name )
... print ('Defining class %s' %cls)
... print('Bases %s: ' %bases)
... print('Attributes')
... for (name, value) in attrs.items():
... print ('%s :%r' %(name, value))
...
>>> class NewClass(object, metaclass=MetaClass):
... get_choch='dairy'
...
class name: NewClass
Bases <class 'object'>:
Defining class <class 'NewClass'>
get_choch :'dairy'
__module__ :'builtins'
__qualname__ :'NewClass'
Note:
注意,该类在任何时候都没有实例化。创建类的简单动作触发了metaclass
。
Python类本身就是其元类的对象(例如,实例)。
默认元类,当您将类确定为:
class foo:
...
元类用于将规则应用于整个类集。例如,假设您正在构建一个ORM来访问数据库,并且希望每个表中的记录属于映射到该表的类(基于字段,业务规则等),并可能使用元类例如,连接池逻辑由所有表中的所有记录类别共享。另一个用途是支持外键的逻辑,该外键涉及多个记录类别。
当您定义元类时,您将子类化,并且可以覆盖以下魔术方法来插入您的逻辑。
class somemeta(type):
__new__(mcs, name, bases, clsdict):
"""
mcs: is the base metaclass, in this case type.
name: name of the new class, as provided by the user.
bases: tuple of base classes
clsdict: a dictionary containing all methods and attributes defined on class
you must return a class object by invoking the __new__ constructor on the base metaclass.
ie:
return type.__call__(mcs, name, bases, clsdict).
in the following case:
class foo(baseclass):
__metaclass__ = somemeta
an_attr = 12
def bar(self):
...
@classmethod
def foo(cls):
...
arguments would be : ( somemeta, "foo", (baseclass, baseofbase,..., object), {"an_attr":12, "bar": <function>, "foo": <bound class method>}
you can modify any of these values before passing on to type
"""
return type.__call__(mcs, name, bases, clsdict)
def __init__(self, name, bases, clsdict):
"""
called after type has been created. unlike in standard classes, __init__ method cannot modify the instance (cls) - and should be used for class validaton.
"""
pass
def __prepare__():
"""
returns a dict or something that can be used as a namespace.
the type will then attach methods and attributes from class definition to it.
call order :
somemeta.__new__ -> type.__new__ -> type.__init__ -> somemeta.__init__
"""
return dict()
def mymethod(cls):
""" works like a classmethod, but for class objects. Also, my method will not be visible to instances of cls.
"""
pass
无论如何,这两个是最常用的钩子。元分类功能强大,而元数据分类的用途清单也不是详尽无遗。
type()函数可以返回对象的类型或创建新的类型,
例如,我们可以使用type()函数创建一个Hi类,而无需在Hi(object)类中使用这种方式:
def func(self, name='mike'):
print('Hi, %s.' % name)
Hi = type('Hi', (object,), dict(hi=func))
h = Hi()
h.hi()
Hi, mike.
type(Hi)
type
type(h)
__main__.Hi
除了使用type()动态创建类之外,您还可以控制类的创建行为并使用元类。
根据Python对象模型,类是对象,因此该类必须是另一个特定类的实例。默认情况下,Python类是类型类的实例。也就是说,类型是大多数内置类的元类和用户定义类的元类。
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
class CustomList(list, metaclass=ListMetaclass):
pass
lst = CustomList()
lst.add('custom_list_1')
lst.add('custom_list_2')
lst
['custom_list_1', 'custom_list_2']
当我们在元类中传递关键字参数时,Magic将会生效,它指示Python解释器通过ListMetaclass创建CustomList。new(),此时,我们可以例如修改类定义,并添加新方法,然后返回修改后的定义。
除了已发布的答案,我可以说a metaclass
定义了一个类的行为。因此,您可以显式设置您的元类。每当Python获得关键字时,class
它就会开始搜索metaclass
。如果未找到,则使用默认的元类类型创建类的对象。使用该__metaclass__
属性,可以设置metaclass
您的类:
class MyClass:
__metaclass__ = type
# write here other method
# write here one more method
print(MyClass.__metaclass__)
它将产生如下输出:
class 'type'
当然,您可以创建自己的类metaclass
来定义使用您的类创建的任何类的行为。
为此,metaclass
必须继承默认类型类,因为这是主要的metaclass
:
class MyMetaClass(type):
__metaclass__ = type
# you can write here any behaviour you want
class MyTestClass:
__metaclass__ = MyMetaClass
Obj = MyTestClass()
print(Obj.__metaclass__)
print(MyMetaClass.__metaclass__)
输出将是:
class '__main__.MyMetaClass'
class 'type'
在面向对象的编程中,元类是一个类,其实例是类。就像普通类定义某些对象的行为一样,元类定义某些类及其实例的行为。术语“元类”仅表示用于创建类的内容。换句话说,它是一个类的类。元类用于创建类,因此就像对象是类的实例一样,类是元类的实例。在python中,类也被视为对象。
这是其用途的另一个示例:
metaclass
更改其实例(类)的功能。class MetaMemberControl(type):
__slots__ = ()
@classmethod
def __prepare__(mcs, f_cls_name, f_cls_parents, # f_cls means: future class
meta_args=None, meta_options=None): # meta_args and meta_options is not necessarily needed, just so you know.
f_cls_attr = dict()
if not "do something or if you want to define your cool stuff of dict...":
return dict(make_your_special_dict=None)
else:
return f_cls_attr
def __new__(mcs, f_cls_name, f_cls_parents, f_cls_attr,
meta_args=None, meta_options=None):
original_getattr = f_cls_attr.get('__getattribute__')
original_setattr = f_cls_attr.get('__setattr__')
def init_getattr(self, item):
if not item.startswith('_'): # you can set break points at here
alias_name = '_' + item
if alias_name in f_cls_attr['__slots__']:
item = alias_name
if original_getattr is not None:
return original_getattr(self, item)
else:
return super(eval(f_cls_name), self).__getattribute__(item)
def init_setattr(self, key, value):
if not key.startswith('_') and ('_' + key) in f_cls_attr['__slots__']:
raise AttributeError(f"you can't modify private members:_{key}")
if original_setattr is not None:
original_setattr(self, key, value)
else:
super(eval(f_cls_name), self).__setattr__(key, value)
f_cls_attr['__getattribute__'] = init_getattr
f_cls_attr['__setattr__'] = init_setattr
cls = super().__new__(mcs, f_cls_name, f_cls_parents, f_cls_attr)
return cls
class Human(metaclass=MetaMemberControl):
__slots__ = ('_age', '_name')
def __init__(self, name, age):
self._name = name
self._age = age
def __getattribute__(self, item):
"""
is just for IDE recognize.
"""
return super().__getattribute__(item)
""" with MetaMemberControl then you don't have to write as following
@property
def name(self):
return self._name
@property
def age(self):
return self._age
"""
def test_demo():
human = Human('Carson', 27)
# human.age = 18 # you can't modify private members:_age <-- this is defined by yourself.
# human.k = 18 # 'Human' object has no attribute 'k' <-- system error.
age1 = human._age # It's OK, although the IDE will show some warnings. (Access to a protected member _age of a class)
age2 = human.age # It's OK! see below:
"""
if you do not define `__getattribute__` at the class of Human,
the IDE will show you: Unresolved attribute reference 'age' for class 'Human'
but it's ok on running since the MetaMemberControl will help you.
"""
if __name__ == '__main__':
test_demo()
的metaclass
是强大的,有很多东西(如猴子魔术),你可以用它做,但要小心,这可能只知道给你。
在Python中,一个类是一个对象,就像其他任何对象一样,它是“某物”的实例。这种“东西”就是所谓的元类。这个元类是一种特殊的类,它创建其他类的对象。因此,元类负责创建新类。这使程序员可以自定义类的生成方式。
要创建一个元类,通常要重写new()和init()方法。可以重写new()来更改对象的创建方式,而可以重写init()来更改对象的初始化方式。元类可以通过多种方式创建。一种方法是使用type()函数。当使用3个参数调用type()函数时,它将创建一个元类。参数是:
创建元类的另一种方法包括“元类”关键字。将元类定义为简单类。在继承的类的参数中,传递metaclass = metaclass_name
元类可以在以下情况下专门使用:
请注意,在python 3.6中__init_subclass__(cls, **kwargs)
,引入了新的dunder方法来替换元类的许多常见用例。创建定义类的子类时调用is。参见python docs。
class A(type):pass<NEWLINE>class B(type,metaclass=A):pass<NEWLINE>b.__class__ = b