元类允许我们拦截并扩展类创建----提供了一个API以插入在一条class语句结束时运行的二维逻辑，尽管是以与装饰器不同的方式。
类是类型的实例
<li>在Python3.0中，用户定义的类对象是名为type的对象的实例，type本身是一个类
<li>类型由派生自type的类定义
<li>用户定义的类是类型类的实例
<li>用户定义的类产生他们自己的实例的类型
1、元类是Type的子类
2、type是产生用户定义的类的一个类
3、类对象是type类的一个实例，或一个子类
4、实例对象产生自一个类
Class语句协议
当Python遇到一条class语句，它会运行其嵌套的代码块以创建其属性----所有在嵌套代码块的顶层分配的名称都产生结果类对象中的属性。在一条class语句的末尾，并且在运行了一个命名空间词典中的所有嵌套代码之后，它调用type对象来创建class对象
class = type(classname,superclass,attrbutedict)
type对象反过来定义一个call运算符重载方法，当调用type对象的时候，该方法运行两个其他的方法：
type.new(typeclass,classname,superclasses,attributedict)
type.init(class,classname,superclasses,attributedict)
new方法创建并返回一个新的class对象，并且随后init方法初始化了新创建的对象
例如
class Spam(Eggs):
data = 1
def meth(self,arg):
pass
Python将会从内部运行嵌套的代码来创建该类的两个属性(data和meth)，然后在class语句的末尾调用type对象，产生class对象：
spam = type('Spam',(Eggs,),{'data':1,'meth':meth,'__module__':'__main__'})
声明元类
class Spam(metaclass=Meta):
pass
当以这种方式声明的时候，创建类对象的调用在class语句的底部运行，修改为调用元类而不是默认的type:
class = Meta(classname,superclass,attributedict)
由于元类是type的一个子类，所以type类的__call__把创建和初始化新的类对象的调用委托给元类
Meta.__new__(Meta,classname,superclass,attributedict)
Meta.__init__(class,classname,superclass,attributedict)
------------------------------
class Spam(Eggs,metaclass = Meta):
data = 1
def meth(self,arg):
pass
"""
这条class语句的末尾，Python内部运行如下的代码来创建class对象
Spam = Meta('Spam',(Eggs,),{'data':1,'meth':meth,'__module__':'__main__'})
"""
基本元类
#-*-coding:UTF-8-*-
class MetaOne(type):
def __new__(meta,classname,supers,classdict):
print('In MetaOne.new',classname,supers,classdict,sep='n..')
return type.__new__(meta,classname,supers,classdict)
def __init__(Class,classname,supers,classdict):
print('In MetaOne init',classname,supers,classdict,sep='n...')
print(list(Class.__dict__.keys()))
class Eggs:
pass
print('making class')
class Spam(Eggs,metaclass = MetaOne):
data = 1
def meth(self,arg):
pass
if __name__ == '__main__':
print('making instance')
X = Spam()
print('data:',X.data)
>>>
>>>
making class
In MetaOne.new #元类处理类
..Spam
..(<class '__main__.Eggs'>,)
..{'__qualname__': 'Spam', 'meth': <function Spam.meth at 0x0060A150>, '__module__': '__main__', 'data': 1}
In MetaOne init
...Spam
...(<class '__main__.Eggs'>,)
...{'__qualname__': 'Spam', 'meth': <function Spam.meth at 0x0060A150>, '__module__': '__main__', 'data': 1}
['meth', '__module__', '__doc__', 'data']
making instance #类用来处理实例
data: 1
###
Spam继承自Eggs并且是MetaOne的一个实例，在我们真正创建一个实例之前---元类用来处理类，并且类用来处理实例。通常__new__创建并返回了类对象，__init__初始化了已经创建了类。
其他元类编程技巧
1>使用简单的工厂函数
实际上任何可调用对象都可以用作一个元类，只要它接收传递的参数并且返回与目标兼容的一个对象。
def MetaFunc(classname,supers,classdict):
print('In MetaFunc: ',classname,supers,classdict,sep='n...')
return type(classname,supers,classdict)
class Eggs:
pass
print('making class')
class Spam(Eggs,metaclass = MetaFunc):
data = 1
def meth(self,arg):
pass
if __name__ == '__main__':
print('making instance')
X = Spam()
print('data:',X.data)
###
当在声明Spam类时，在class语句的末尾，即
metaclass = MetaFunc
即调用
class = MetaFunc(classname,supers,classdict)
传递
MetaFunc('Spam',(Eggs,),{'data':1,'meth':meth,'__module__':'__main__'})
2>用元类重载类创建调用
#-*-coding:UTF-8-*-
"""
一个元类的元类
"""
class SuperMeta(type):
def __call__(meta,classname,supers,classdict):
print('In SuperMeta.call:',classname,supers,classdict,sep='n..')
return type.__call__(meta,classname,supers,classdict)
class SubMeta(type,metaclass=SuperMeta):
def __new__(meta,classname,supers,classdict):
print('In SubMeta.new: ',classname,supers,classdict,sep='n...')
return type.__new__(meta,classname,supers,classdict)
def __init__(Class,classname,supers,classdict):
print('In SubMeta init: ',classname,supers,classdict,sep='n...')
print('...init class object: ',list(Class.__dict__.keys()))
class Eggs:
pass
print('making class')
class Spam(Eggs,metaclass=SubMeta):
data = 1
def meth(self,arg):
pass
if __name__ == '__main__':
print('Makig instance')
X = Spam()
print('data: ',X.data)
>>>
making class
In SuperMeta.call:
..Spam
..(<class '__main__.Eggs'>,)
..{'__qualname__': 'Spam', '__module__': '__main__', 'data': 1, 'meth': <function Spam.meth at 0x0061A150>}
In SubMeta.new:
...Spam
...(<class '__main__.Eggs'>,)
...{'__qualname__': 'Spam', '__module__': '__main__', 'data': 1, 'meth': <function Spam.meth at 0x0061A150>}
In SubMeta init:
...Spam
...(<class '__main__.Eggs'>,)
...{'__qualname__': 'Spam', '__module__': '__main__', 'data': 1, 'meth': <function Spam.meth at 0x0061A150>}
...init class object: ['__doc__', '__module__', 'data', 'meth']
Makig instance
data: 1
###
把上文中的__call__函数放在SubMeta中是不行的。
同时__new__是一定要存在的
3>用常规类重载类创建调用
class SuperMeta:
def __call__(self,classname,supers,classdict):
print('In SuperMeta.call: ',classname,supers,classdict,sep='n...')
Class = self.__New__(classname,supers,classdict)
self.__Init__(Class,classname,supers,classdict)
return Class
class SubMeta(SuperMeta):
def __New__(self,classname,supers,classdict):
return type(classname,supers,classdict)
def __Init__(self,Class,classname,supers,classdict):
print('In SubMeta.new',classname,supers,classdict)
print('..init class object: ',list(Class.__dict__.keys()))
class Eggs:pass
class Spam(Eggs,metaclass=SubMeta()):
data = 1
def meth(self,arg):
pass
print('making instance')
if __name__ == '__main__':
x = Spam()
print(x.data)
注意2和3的不同
实例与继承的关系
<li>元类继承自type类。元类是用class语句编写的，并遵从OOP模型。元类通常重新定义type类的new和init。以定制类创建和初始化，但是，如果他们希望直接捕获类末尾的创建调用的话，也可以重新定义call
<li>元类声明由子类继承。在用户定义的类中，metaclass=M声明由该类的子类继承，因此，对于在超类链中继承了这一声明的每个类的构建，该元类都将运行。
<li>元类属性没有由子类实例继承。元类声明指定了一个实例关系，和继承不同。由于类是元类的实例，所以元类中定义的行为应用于类，而不是类随后的实例。实例从他们的类和超类中获取行为，而不是从元类中。实例属性查找通常搜索实例及其所有类的dict字典
向类中添加方法
def eggsfunc(obj):
return obj.value * 4
def hamfunc(obj,value):
return value+' ham'
class Extender(type):
"""
添加额外的方法。这里可以添加条件判断执行不同的方法
"""
def __new__(meta,classname,supers,classdict):
classdict['eggs'] = eggsfunc
classdict['ham'] = hamfunc
return type.__new__(meta,classname,supers,classdict)
class Client1(metaclass=Extender):
def __init__(slef,value):
slef.value = value
def spam(slef):
return slef.value * 2
if __name__ == '__main__':
x = Client1('Ni!')
print(x.spam())
print(x.eggs())
###
继承也可以为类添加相同的两个方法。然而元类结构支持更多的动态行为。可以在__new__方法中执行判断，执行不同的方法
网友评论