元类
什么是元类
元类是类的类,是类的模板(就如对象的模板是类一样)
元类的实例为类,类的实例为对象
元类是用来产生类的
动态语言和静态语言最大的不同,就是函数和类的定义,不是编译时定义的,是运行时动态创建的
__new__()
我们之前说类实例化第一个调用的是__init__,但__init__其实不是实例化一个类的时候第一个被调用 的方法。当使用 Persion(name, age) 这样的表达式来实例化一个类时,最先被调用的方法 其实是 __new__方法。
__new__方法接受的参数虽然也是和__init__一样,但__init__是在类实例创建之后调用,而 __new__方法正是创建这个类实例的方法。
class A:
pass
class B(A):
def __new__(cls):
print("__new__方法被执行")
def __init__(self):
print("__init__方法被执行")
b = B()
__new__方法被执行
__call__()
当类中有__call__方法时,实例对象直接加括号,会执行这个方法,你拿到的实例对象就是它返回的
class zx():
def __call__(self,name,age):
print(name)
print(age)
zx125=zx()
zx125("wl",18)
wl
18
内置函数type()
type()函数既可以返回一个对象的类型,又可以创建出新的类型
创建一个新的class时需要传入3个参数:
1.class的名称
2.继承父类的集合(元组)
3.函数名和函数对象的键值对(字典)
通过type()函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()函数创建出class。
def speank(self):
print("llllllllllll")
zx=type("zx",(object,),dict(say=speank))
zx1=zx()
zx1.say()
print(type(zx1))
print(type(zx))
llllllllllll
内置函数exec()
执行字符串的代码,当成python解释器,把代码丢给解释器解释
exec(s,g,l)
g表示当前的一个全局名称空间,当前的一个l局部名称空间,代码解析完毕,会按属性是全局和局部,放入以上参数
例1
cmd = """
x=1
print('exec函数运行了')
def func(self):
pass
"""
class_dic = {}
# 执行cmd中的代码,然后把产生的名字丢入class_dic字典中
exec(cmd, {}, class_dic)
print(class_dic)
{'x': 1, 'func': }
例2
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
y = 20
m={'x':1,'y': 2}
w={'y': 3, 'z': 4}
exec(expr)
exec(expr,m)
exec(expr,m,w)
print(w)
60
33
34
{'y': 3, 'z': 30, 'sum': 34}
元类
class关键字
例1 理解class关键字
可见这时候已经生成了一个zx类对象了,zx的属性字典已经被写入了,那么这个过程中到底发生了什么呢?接下来我们慢慢拆解
class Mytype(type):
pass
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
print(zx.__dict__)
{'__module__': '__main__', '__dict__': , '__weakref__': , '__doc__': None}
例2
创建一个对象,说到底就是用了,上面介绍的方法__init(),__new__(),__call()这三个方法,真正创建对象的只有type()这个内置方法。下面直接进入主题,直接重写元类的三个方法。
1.首先,会运行到class Mytype(type)同理可得,这个时候会生成一个Mytype对象,这是一个关键,自定义的元类创建好了,下面生产类对象就靠它了,这个元类的产生过程是修改不了的,因为是c实现的
2.然后就和例1一样zx=Mytype("zx",(object,),{}),接下来就是三个方法的运用了。首先是Mytype后面加的括号,所以去执行type的__call__()方法
3.然后看一下__call__()方法的参数self, *args, **kwargs,有个self,这个self就是第一步创建的那个Mytype对象,然后会依次执行self.__new__()和self.__init__()方法,也就是Mytype中的这两个方法,这两个方法的作用,主要就是创建对象,给对象填入相关的属性,而__call__()主要就是对操作的封装,然后返回组装完成的类对象
4.我们看到结果,只打印了new,但是按上面的步骤,不是还应该打印一个init的吗?别急,在看打印生成的对象zx它竟然是个None,所以其中必要蹊跷,发生了什么呢?其实过程还是和上面一样的,只不过我们重写了方法,导致运行到__new__()的时候,这个方法,返回了一个None,这怎么行呢?所以当返回值返回到__call__()的时候,导致直接出了异常,方法中断了,但是没有打印异常,是因为源码做了处理,返回了一个None
class Mytype(type):
def __init__(self,*args, **kwargs):
print("init")
def __call__(self, *args, **kwargs):
print("call")
def __new__(cls, *args, **kwargs):
print("new")
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
print(zx)
new
None
例3 实现创建类对象
出现了这样的问题当然要解决他呢!首先要注意类对象是由自定义元类生成的,实例对象是由类对象生成的,这两种情况的方法执行流程是相同的,但是有些细节的偏差
1.我把打印结果移到了,__init__()方法去了,但是发现执行这个方法的时候,我们想要的zx类对象其实已经创建好了,这就是主要的区别,生成类对象,和属性填充等操作都会放在__new__()里面,而创建实例对象的时候,一些添加属性的过程,则会放到__init__()里面
2.在__new__()方法中,我创建对象用的方法是type.__new__(cls,*args, **kwargs),为啥呢?因为我们自定义元类的时候,如果没有重写__new__()方法是时候,他就找不到这个方法,这个时候当然就是去父类找这个方法,那Mytype的父类是谁呢?就是type,其实原理是一样的
3.我们成功自定义了元类,并且拿到了zx类对象,我们可以发现整个过程我们都是可以控制的,自定义元类给我们极大的操作过程,那么接下来我们来操作一下实例对象生成的过程
class Mytype(type):
def __init__(self,*args, **kwargs):
print(self)
print(self.__dict__)
print("init")
def __call__(self, *args, **kwargs):
print("call")
def __new__(cls, *args, **kwargs):
# print(cls)
# return object.__new__(cls)
return self.__new__(cls,*args, **kwargs)
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
{'__module__': '__main__', '__dict__': , '__weakref__': , '__doc__': None}
init
例4 实例对象的创建过程
这里我把Mytype的__init__()和__new__()方法去掉,让他直接调用默认的方法就行,这里不研究类对象的生成了
1.首先来查看打印结果,一个为空,这就是上面所说的区别,在创建实例对象的时候,使用的是不是type的__new__方法,而是,找zx继承类,一般都是创建一个空对象,除非你自定义一个父类,从写它的__new__()方法
2.创建完了一个空对象,然后调用__init__()方法给他进行填值,最后我们拿到了自己想要的实例对象了
class Mytype(type):
def __call__(self, *args, **kwargs):
obj=self.__new__(self, *args, **kwargs)
print(obj.__dict__)
obj.__init__( *args, **kwargs)
return obj
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
def __init__(self,name,age):
self.name=name
self.age=age
def run(self):
print("runrun")
ha=zx("小明",18)
print(ha.__dict__)
{}
{'name': '小明', 'age': 18}
总结
1.一切皆对象
2.注意自定义元类的特殊性,他是父类是type,在创建类对象的时候他的__new__()方法,直接把创建对象和添加属性字典的操作都完成了
3.注意对象+()调用的是,元类!的__call()方法,默认元类都是type
4.太难了,太绕了,记一下,容易忘
__new__()一共接收4个参数(也可以使用位置形参接收)
底层就是调用了type()方法
分别为:
1.当前准备创建的类对象;
2.类的名字
3.类继承的父类集合
4.类的方法集合