元类总结
type只传一个参数有什么用
打印对象的类型
print(type(1))
class底层原理
通过type类来实例化,得到类
def __init__(self,name):
self.name=name
Person=type('Person',(object,),{'x':1,'__init__':__init__})
p=Person('lqz')
print(Person.__dict__)
print(p.__dict__) #{'name': 'lqz'}
print(p.x)
#等同于
class Person(object):
x=1
def __init__(self,name):
self.name=name
p=Person('lqz')
print(Person.__dict__)
print(p.__dict__)
print(p.x)
exec
执行字符串的代码,当成python解释器
ss='''
x=1
print(x)
'''
g={}
l={}
exec(ss,g,l)
print(l)
#1
#{'x': 1}
自定义元类
继承type
class Mymeta(type):
def __init__(self,name,bases,dic):
#self 是Person 这个类(对象)
#在这个位置,其实self也就说Person这个类,内部已经有东西了,名称空间已经有东西了
#所以在这个地方,可以通过dic来判断名称空间
#也可以直接通过self.__dict__/self.属性 来判断
a=dic.get('name')
if not a :
raise Exception('没有name属性,不能创建')
# def __call__(self, *args, **kwargs):
# pass
class Person(metaclass=Mymeta): #Person=Mymeta('Person',(object,),{...}) Mymeta类实例化,会把三个参数传到Mymeta的__init__方法中
# class Person(): #Person=Mymeta('Person',(object,),{...}) Mymeta类实例化,会把三个参数传到Mymeta的__init__方法中
def __init__(self,name):
self.name=name
raise Exception('就不让你创建')
p=Person('lqz') #自动触发Person类__init__的执行
# 总结:可以通过自定义元类,重写__init__方法来控制类的产生
通过元类控制类的调用过程,实例化产生对象的过程
class Mymeta(type):
def __call__(self, *args, **kwargs):
#该方法必须返回一个对象(类对象),这个地方返回什么 p=Person('lqz') p就是什么
#返回一个真正的Person类的对象
#第一步:产生一个空对象
#object.__new__(self) 传一个参数,传类,就会产生一个该类的空对象
#obj是Person类的空对象
obj=object.__new__(self)
# print(self.__new__ is object.__new__) # True
#第二步:初始化该对象,把初始值放到对象中
#obj是Person类的空对象 obj.__init__ 调用自己的绑定方法,也就说Person类中写的__init__方法
obj.__init__(*args, **kwargs)
#还可以类来调用
# Person.__init__(obj,*args, **kwargs)
# self.__init__(obj,*args, **kwargs)
# print(obj.name)
#第三步:把该对象返回
return obj
class Person(metaclass=Mymeta):
# class Person():
def __init__(self,name):
self.name=name
def __call__(self, *args, **kwargs):
print('xxx')
p=Person('lqz')
print(p.name)
print(p)
# 原来的理解Person('lqz') 会调用Person类的__init__的方法
# 这个位置会调用元类的__call__方法,所以在__call__方法中调用了Person __init__方法,来完成对象的初始化
p()
模板:控制对象的产生
class Mymeta(type):
def __call__(self, *args, **kwargs):
obj=object.__new__(self)
obj.__init__(*args,**kwargs)
return obj
class Person(metaclass=Mymeta):
def __init__(self,name):
self.name=name
def __call__(self, *args, **kwargs):
print('xxx')
p=Person('lqz')
自定义一个元类,定义一个类,继承字典,使其具备点取值和赋值功能,通过元类控制对象的产生,把所有对象的属性都放到attr字典中,属性全删除
例如:di=Mydic(name='lqz',age=18)
di的名称空间中没有name和age属性,但是有attr字典属性,字典包含{'name':'lqz','age':18}
class Mymeta(type):
def __call__(self, name, age):
obj=object.__new__(self)
obj.__dict__['attr']={'name':name,'age':age}
return obj
class Person(metaclass=Mymeta):
def __init__(self,name,age):
self.name=name
self.age=age
p=Person('lqz',18)
print(p.__dict__)
print(p.attr['name'])
赠送元类
#object.__new__
class Person():
def __init__(self,name,age):
print('__init__')
self.name=name
self.age=age
def __new__(cls,*args,**kwargs):
print('__new__')
#生成一个Person类的空对象
return object.__new__(cls)
p=Person('lqz',19)
print(p)
#object.__new__ 传哪个类就得到哪个类的空对象
p=object.__new__(Person)
print(p)
#__new__和__init__的区别
__new__ 创建空对象
__init__ 初始化空对象
#object.__new__(Person) :生成Person类的对象 空的
#type.__new__(cls,name,bases,dic) :生了cls这个类对象,里面有东西
元类中
#__init__:控制类的产生,在__new__之后
#__call__:对着对象的产生
#__new__:控制类产生最根上,其实本质最根上也不是它,是type的__call__,但是我们控制不了了
class Mymeta(type):
def __init__(self,name,bases,dic):
#self 是Person类,Person类中有名称空间之类的了
# print('xxxxxxx')
# print(args)
# print(kwargs)
# print(name)
# print(bases)
# print(dic)
pass
# self.name='xxxxxxx'
def __new__(cls, name,bases,dic):
# print(name)
# print(bases)
# print(dic)
#产生空对象(空类),在这里面生成的并不是空类,是有数据的类了
#如何完成类的初始化,并且把name,bases,dic这些东西放入
# return type.__new__(cls,name,bases,dic)
dic2={'attr':{}}
for k,v in dic.items():
#加入这一句,类名称空间中带__的就不会放到attr中
if not k.startswith('__'):
dic2['attr'][k]=v
print('-------',dic2)
return type.__new__(cls,name,bases,dic2)
class Person(metaclass=Mymeta): # Person=Mymeta(name,bases,dic) 调用type的__call__,内部调用了Mymeta.__new__,又掉Mymeta的__init__
school='oldboy'
age=10
def __init__(self,name,age):
self.name=name
self.age=age
print(Person.__dict__)
print(Person.attr['school'])
# p=Person('nick',18)