元类、属性方法

元类

一切都源自于一句话：一切皆为对象

什么是元类？

元类就是用来实例化产生类的类

关系：元类---实例化---->类（People）---实例化---->对象（obj）

　　

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

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


print(People.__dict__)

如何得到对象

obj=调用类()
obj=People('egon',18)
print(type(obj))

　　

如果说类也是对象
People=调用类(。。。)

查看内置的元类：

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

print(type(People))
print(type(int))

　　

class关键字创造类People的步骤

分为四个步骤，其中前3个步骤涉及类的三大特征：

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)

4）调用元类

People=type(class_name,class_bases,class_dic)

如何自定义元类来控制类的产生

class Mymeta(type): # 只有继承了type类的类才是元类

    #            空对象,"People",(),{...}

​    def __init__(self,x,y,z):
​        print('run22222222222....')
​        print(self)

        # print(x)

        # print(y)

        # print(z)

        # print(y)

        # if not x.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. 返回初始化好的对象

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 __

2）类内的__ init __

__ call __

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)

# print(obj) # obj.__str__

res=obj(1,2,3,a=4,b=5,c=6) # res=obj.__call__()
print(res)

应用：如果想让一个对象可以加括号调用，需要在该对象的类中添加一个方法call
总结：

• 对象()->类内的call
• 类()->自定义元类内的call
• 自定义元类()->内置元类call

自定义元类控制类的调用=》类的对象的产生

class Mymeta(type): # 只有继承了type类的类才是元类
    def __call__(self, *args, **kwargs):

        # 1、Mymeta.__call__函数内会先调用People内的__new__

​        people_obj=self.__new__(self)

        # 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__)

　　

属性查找

属性查找的原则：对象-》类-》父类
切记：父类 不是 元类

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)

# print(StanfordTeacher.n)