元类

目录

• 元类
• 1 元类的定义
• 2 查看元类
• 3 class创造类的步骤
• 4 自定义元类来控制类的产生
• 5 属性查找

元类

1 元类的定义

元类就是用来实例化产生类的类,python中默认为type

必须继承type才能是元类,该自定义的元类的类也是type

关系：元类type--->实例化(---->自定义元类--->实例化)---->类（People）---实例化---->对象（obj）

2 查看元类

class A:
    pass

a = A()
print(type(a))
print(type(A))
print(type(int))
print(type(type))
# <class '__main__.A'>
# <class 'type'>
# <class 'type'>
# <class 'type'>

1、type是内置的元类
2、我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生

3 class创造类的步骤

# 类有三大特征：
# 1、类名
class_name="People"
# 2、类的基类
class_bases=(object,)
# 3、执行类体代码拿到类的名称空间
class_dic={}
class_body="""
def __init__(self,name,age):
    self.name=name
    self.age=age

def say(self):
    print('%s:%s' %(self.name,self.name))
"""
exec(class_body,{},class_dic)
print(class_dic)
#{'__init__': <function __init__ at 0x000001BB7E5571F0>, 'say': <function say at 0x000001BB7E557280>}
# 4、调用元类
People=type(class_name,class_bases,class_dic)

# 实现了 不使用class	创造类

4 自定义元类来控制类的产生

class Mymeta(type): # 只有继承了type类的类才是元类
    #           空类,  "People",		 (),		{...}
    def __init__(self,class_name,class_base,class_dict):
        print('run22222222222....')
        print(self)
        print(class_name)
        print(class_base)
        print(class_dict)
        if not class_name.istitle():		
        # 定制,类名首字母不为大写就报错
            raise NameError('类名的首字母必须大写！！！')

    #          当前所在的类，调用类时所传入的参数
    def __new__(cls, *args, **kwargs):
        # 造Mymeta的对象
        print('run1111111111.....')
        # print(cls,args,kwargs)
        # return super().__new__(cls,*args, **kwargs)
        return type.__new__(cls,*args, **kwargs)


People=Mymeta("People",(object,),{...})
# 调用Mymeta发生三件事，调用Mymeta就是type.__call__
# 1、先造一个空对象=>People,调用Mymeta类内的__new__方法
# 2、调用Mymeta这个类内的__init__方法，完成初始化对象的操作
# 3、返回初始化好的对象

其实当我们不写init方法,就会自动使用父类中的init,也就是type中的init方法

new和call方法也是一样

class People(metaclass=Mymeta):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s:%s' %(self.name,self.name))

# 强调：
# 只要是调用类，那么会依次调用
# 1、类内的__new__		若没有则People-->Mymata--->type
# 2、类内的__init__		若没有则People-->Mymata--->type

class Foo:
    def __init__(self,x,y):
        self.x=x
        self.y=y

    #            obj,1,2,3,a=4,b=5,c=6
    def __call__(self,*args,**kwargs):
        print('===>',args,kwargs)
        return 123

obj=Foo(111,222)
# 1 执行new创造空对象obj  2 执行init初始化obj  3 返回obj


res=obj(1,2,3,a=4,b=5,c=6) # res=obj.__call__()
# obj对象能调用了
print(res)

应用：如果想让一个对象可以加括号调用，需要在该对象的类中添加一个方法__call__
总结：
对象()->需要类内的__call__
类()->需要自定义元类内的__call__
自定义元类()->需要内置元类__call__

class Mymeta(type): # 只有继承了type类的类才是元类
    def __call__(self, *args, **kwargs):	# 此处的self为类对象
        # 1、Mymeta.__call__函数内会先调用People内的__new__
        people_obj=self.__new__(self)	# 此处的self为类对象,people_obj为实例化对象
        # 2、Mymeta.__call__函数内会调用People内的__init__
        self.__init__(people_obj,*args, **kwargs)

        # print('people对象的属性：',people_obj.__dict__)
        people_obj.__dict__['xxxxx']=11111
        # 3、Mymeta.__call__函数内会返回一个初始化好的对象
        return people_obj

# 类的产生
# People=Mymeta(三个参数)======>type.__call__========>干了3件事
# 1、type.__call__函数内会先调用Mymeta内的__new__
# 2、type.__call__函数内会调用Mymeta内的__init__
# 3、type.__call__函数内会返回一个初始化好的类对象

class People(metaclass=Mymeta):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s:%s' %(self.name,self.name))

    def __new__(cls, *args, **kwargs):
        # 产生真正的对象
        return object.__new__(cls)

# 类的调用
# obj=People('egon',18) =======>Mymeta.__call__=========>干了3件事
# 1、Mymeta.__call__函数内会先调用People内的__new__
# 2、Mymeta.__call__函数内会调用People内的__init__
# 3、Mymeta.__call__函数内会返回一个初始化好的对象

obj1=People('egon',18)
obj2=People('egon',18)
# print(obj)
print(obj1.__dict__)
print(obj2.__dict__)

5 属性查找

# 属性查找的原则：
# 对象属性:对象->类->父类->object
# 切记：父类 不是 元类
# 类属性: 类-->父类-->object-->自定义元类或type-->type


# 个人理解:实例化对象处于最底层,最多只能找到上面一层,即类层	(元类在类上面一层,无法查找)
# 				类处于中间层,同样能找到到上面一层,即元类层
# 对象--类--元类

class Mymeta(type):
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        obj=self.__new__(self) # StanfordTeacher.__new__
        # obj=object.__new__(self)
        print(self.__new__ is object.__new__) #True
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    # n=333

    # def __new__(cls, *args, **kwargs):
    #     print('Bar.__new__')
    pass

class Foo(Bar):
    # n=222

    # def __new__(cls, *args, **kwargs):
    #     print('Foo.__new__')
    pass

class StanfordTeacher(Foo,metaclass=Mymeta):
    # n=111

    def __init__(self,name,age):
        self.name=name
        self.age=age


obj=StanfordTeacher('lili',18)
print(obj.__dict__)
print(obj.n)		# obj,StanfordTeacher,Foo,Bar,object中都没,报错
print(StanfordTeacher.n)	# StanfordTeacher-->Foo-->Bar-->object-->Mymeta-->type