元类
#一切皆对象：类实际上一个一个对象
#Person类也是个对象，那他一定是由一个类实例化得到，这个类，就叫元类
#type是内置的一个元类，所有的类都是由type实例化得到
#产生类的类，叫元类
class Person:
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
p=Person('nick')
# a=Person
# p1=a('nick')
# print(p1.name)
如何找元类？
# print(type(p))
#同理:type类是产生所有类的元类
# print(type(Person))
print(type(dict))
print(type(list))
print(type(str))
print(type(object))
print(type(type))
class 底层原理
#class 类名 会把类构造出来，实际上是：元类实例化产生类这个对象，类实例化产生对象，一定是: 类名()#Person 类是由type实例化产生，传一堆参数
#class 底层就是调用type来实例化产生类（对象）
#type() 调用类的__init__方法？？？
#type(object_or_name, bases, dict)
object_or_name：类的名字，是个字符串
bases：是它的所有父类，基类，是一个元组
dict:名称空间,是一个字典
l={}
exec('''
school='oldboy'
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
''',{},l)
Person=type('Person',(object,),l)
或者
def __init__(self,name):
self.name=name
Person=type('Person',(object,),{'school':'oldboy','__init__':__init__})
#print(Person.__dict__)
#print(Person.__bases__)
# p=Person('nick')
# print(p.name)
# print(p.__dict__)
# class Person:
# school='oldboy'
# def __init__(self,name):
# self.name=name
# def score(self):
# print('分数是100')
# a=Person
#
# p=Person('nick')
exec()的用法
# l={}
# exec('''
# school='oldboy'
# def __init__(self,name):
# self.name=name
# def score(self):
# print('分数是100')
# ''',{},l)
# print(l)
# g={ 'x':1,'y':2}
# l={}
# exec('''
# global x
# x=100
# z=200
# m=300
# ''',g,l)
# print(g)
# print(l)
# x=1
# y=2
# def test():
# global x
# x = 100
# z = 200
# m = 300
通过元类来控制类的产生
自定义元类来控制类的产生，可以控制类名,可以控制类的继承父类,控制类的名称空间
自定义元类必须继承type,写一个类继承type 这种类都叫元类
class Mymeta(type):
def __init__(self,name,bases,dic):
# self 就是Person类
print(name)
print(bases)
print(dic)
#练习一:加限制 控制类名必须以sb开头
if not name.startswith('sb'):
raise Exception('类名没有以sb开头')
class Person(object,metaclass=Mymeta): #metaclass=Mymeta 指定这个类生成的时候,用自己写的Mymeta这个元类
'''
注释
'''
school='oldboy'
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
p=Person()
#练习二:类必须加注释
class Mymeta(type):
def __init__(self,name,bases,dic):
print(self.__dict__['__doc__'])
doc=self.__dict__['__doc__']
if not doc:
#没有加注释
raise Exception('你的类没有加注释')
class Person(object,metaclass=Mymeta):
'''
我加了注释
'''
school='oldboy'
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
通过元类控制类的调用过程
#要使用到__call__
#控制类的调用过程,本质上在控制:对象的产生
class Mymeta(type):
def __call__(self, *args, **kwargs):
print('xxx')
return 1
class Person(object,metaclass=Mymeta):
school='oldboy'
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
p=Person('nick')
print(p.name)
#打印xxx，并且p没有name属性
class Person():
school='oldboy'
def __init__(self,name):
self.name=name
def score(self):
print('分数是100')
def __call__(self, *args, **kwargs):
print('xxxx')
p=Person('nick') #自动触发init的执行
p() #先触发元类的__call__，也就是说__call__实例化的对象或者实例化的类加括号调用时才会触发__call__
#__new__方法
#练习:把对象中的所有属性都设置成私有
分析
class Mymeta(type):
def __call__(self, *args, **kwargs):
#self 是Person这个类
# print(args)
# print(kwargs)
# return self(*args) #这里不行,会递归
#实例化产生一个Person类的对象,借助__new__来产生,需要把类传过去,才能产生对象
#obj 是Person类的对象,只不过是空的
obj=object.__new__(self) #或者 obj=self.__new__(self)
#调用__init__方法完成初始化
#类来调用__init__方法,就是个普通函数,有几个参数就穿几个惨
self.__init__(obj,*args, **kwargs)
#对象来调用__init__方法,对象的绑定方法,会把自身穿过来
obj.__init__(*args, **kwargs)
print(obj)
return obj
class Person(object, metaclass=Mymeta):
school = 'oldboy'
def __init__(self, name):
self.name = name
def score(self):
print('分数是100')
p = Person(name='nick')
print(p)
print(p.name)
#把对象所有的属性都变成私有
class Mymeta(type):
def __call__(self, *args, **kwargs):
obj=object.__new__(self)
obj.__init__(*args, **kwargs)
# print(obj.__dict__)
obj.__dict__={ '_%s__%s'%(self.__name__,k):v for k,v in obj.__dict__.items()}
# print(obj.__dict__)
return obj
class Person(object, metaclass=Mymeta):
school = 'oldboy'
def __init__(self, name):
self.name = name
def score(self):
print('分数是100')
p = Person(name='nick')
print(p.__dict__)
print(p.name)
# print(p)
# print(p.name)
有了元类之后的属性查找
对象最高查找到object
类最高查找到type