Python--元类

一、元类介绍

一切源自于一句话:python中一切皆为对象。让我们先定义一个类,然后逐步分析

class StanfordTeacher(object):
    school='Stanford'

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

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

所有的对象都是实例化或者说调用类而得到的(调用类的过程称为类的实例化),比如对象t1是调用类StanfordTeacher得到的

t1=StanfordTeacher('lili',18)
print(type(t1)) #查看对象t1的类是<class '__main__.StanfordTeacher'>

如果一切皆为对象,那么类StanfordTeacher本质也是一个对象,既然所有的对象都是调用类得到的

那么StanfordTeacher必然也是调用了一个类得到的,这个类称为元类

print(type(StanfordTeacher))
# 结果为<class 'type'>,证明是调用了type这个元类而产生的StanfordTeacher,即默认的元类为type

在这里插入图片描述

二、class关键字创建类的流程分析

用class关键字定义的类本身也是一个对象,负责产生该对象的类称之为元类(元类可以简称为类的类),内置的元类为type

class关键字在帮我们创建类时,必然帮我们调用了元类StanfordTeacher = type(参数 1,参数2,参数3),那调用type时传入的参数是什么呢?必然是类的关键组成部分,一个类有三大组成部分

参数1、类名 class_name=‘StanfordTeacher’

参数2、基类 class_bases=(object,)

参数3、类的名称空间 class_dic,类的名称空间是执行类体代码而得到的

调用type时会依次传入以上三个参数—type( ‘StanfordTeacher’,(object,),{…} )

综上,class关键字帮我们创建一个类应该细分为以下四个过程:

1、拿到类名 'StanfordTeache

2、拿到他的基类们;

3、执行类体代码,拿到类的名称空间;

4、调用元类返回对象(返回的对象就是我们需要的“类”) :StanfordTeache = type( class_name, class_bases, class_dict )

三、自定义元类

一个类没有声明自己的元类,默认他的元类就是type,除了使用内置元类type,我们也可以通过继承type来自定义元类,这样我们用 class 关键字生成的元类使用的就是我们自定义的元类

class 类名( 继承的类名, … , metaclass = 自定义的元类名(默认为 type) ) :

由 class 关键字创建一个类的四个步骤,只有最后一步调用元类生成类是无法修改的;比如:传入的类名必须首字母大写,不大写就报错, 为了实现这样的需求,元类显然是不能满足的

需求:

传入的类名必须首字母大写,不大写就报错;类中必须有文档注释,并且文档注释不能为空

步骤分析:

1、需求分析-----People类,满足类名首字母必须大写;

2、首先需要自定义元类 Mymeta, 这样 class 类名(metaclass = Mymeta)就会对 类名首字母判断

3、使用 class 关键字创建类,相当于 类名 = Mymeta ( ‘类名’ , (需要继承的基类们,) , { 类体代码执行后的名称空间 } )

4、调用 Mymeta 类—发生"三件事":

​ 生成一个空对象,调用_ _ init _ _ 方法初始化对象,这个对象当做返回值

5、由于 Mymeta 类传入了三个参数,所以需要在 _ _ init _ _ 方法,要传入这三个参数以及空对象

6、在 _ _ init _ _ 方法中 对传入的参数进行 需求的自定义

""" 自定义元类 """
class Mymeta(type): #只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类
    def __init__(self,class_name,class_bases,class_dic):
        # self.class_name = class_name
        # self.class_bases = class_bases
        # self.class_dic = class_dic
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能

        
        if not class_name.istitle():
            raise TypeError('类名%s请修改为首字母大写' %class_name)

        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('类中必须有文档注释,并且文档注释不能为空')

在这里插入图片描述
在这里插入图片描述

四、 _ _ new _ _ 方法

调用一个类会发生"三件事",其中第一件就是–产生一个空对象,那么这个空对象是怎么产生的呢?

在调用类的时候,会首先自动触发 _ _ new _ _方法,执行里面的代码,在触发 init 方法

在这里插入图片描述

所以,可以推断出 执行 init 方法之前,肯定已经有方法执行完毕了

此时,我们重写 new 方法, 首先方法里什么都不写,直接执行,查看结果

class Mymeta(type):  # 只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类
    def __init__(self, class_name, class_bases, class_dic):
        print(self)
        print(class_bases)
        print(self.__bases__)
    
    def __new__(cls, *args, **kwargs):
        pass


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

在这里插入图片描述

结果中 init 方法下的打印都没有执行,就直接结束了,而我们直到,new 方法是用来早一个空对象的,如果什么都没有返回,那么 init 方法也就不会调用,并且这个返回值也不能随便返回,必须要是造好的对象

这个对象需要重用元类 type 的new 方法造出来,并且会自动继承 object 类,等等的一些内置的属性都会造好

class Mymeta(type):  # 只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类
    def __init__(self, class_name, class_bases, class_dic):
        print(self)
        print(class_bases)
        print(self.__bases__)

    def __new__(cls, *args, **kwargs):
        print('Mymeta--new')
        return super().__new__(cls, *args, **kwargs)


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

在这里插入图片描述

那么,现在调用一个自定义类 Mymeta 的前两步:

先调用 Mymeta 的 new 方法生成一个对象,这对象是通过 type 元类的 new 方法生成的,并且 new 方法最终返回了这个对象;

然后再调用了 Mymeta 的 init 方法初始化这个对象 ( 一般情况下要重用 type 元类的 init 方法,以上的代码只为了突出 new 方法 )

那么,就还剩下最后一步 – 返回这个对象。此时,需要思考一下:

该由谁返回?是new 方法的返回值当做调用类的最终返回值,还是 init,亦或是别的方法?

还有一个最底层的问题:为什么会先调用 new,在调用 init?是谁在控制这个流程的运行?

五、_ _ call _ _方法

调用类就是调用类的 _ _ call _ _方法,类调用后的运行逻辑,其实都是 call 方法来控制的

call 方法的应用

如果想让一个 对象 可以加括号 调用,那么需要在该对象的类中加入 call 方法,这个对象调用后的返回值就是 call 方法的返回值

在这里插入图片描述

在这里插入图片描述

由此,我们可以解决调用自定义元类 Mymeta 的最后一步返回对象的问题。

调用自定义元类 Mymeta 就是调用 type 元类的 call 方法,所以调用 Mymeta 的返回值就是使用 type 的 call 方法最终的返回值,并且这个 type 元类的 call 方法并不建议去自定义,在这里就不在过多介绍

注意:并不是继承了父类就是调用父类,这里 Mymeta 与 type 元类是特例,区别调用类与继承类

总结:类的产生与调用

1、对象 ( ) -----> 调用 类. _ _ call _ _

2、类 ( ) -----> 调用自定义元类. _ _ call _ _

3、自定义元类 ( ) -----> 调用type元类. _ _ call _ _

类的产生:

People = Mymeta ( 参数 1,2,3)—>自定义元类加括号调用 Mymeta ( ) -----> 调用type元类. _ _ call _ _方法

type元类. _ _ call _ _方法做了三件事:

1、type元类. _ _ call _ _方法 调用自定义元类 Mymeta 内的 new 方法,造出一个空对象;

2、type元类. _ _ call _ _方法 调用自定义元类 Mymeta 内的 init 方法,初始化这个对象;

3、type元类. _ _ call _ _方法 会返回这个初始化好的对象;

类的调用:

obj = People(参数…)—> People 类加括号调用 -----> 调用自定义元类 Mymeta . _ _ call _ _方法

自定义元类 Mymeta . _ _ call _ _方法做了三件事:

1、 Mymeta . _ _ call _ _方法 调用自定义元类 People 类内的 new 方法,造出一个空对象;

2、 Mymeta . _ _ call _ _方法 调用自定义元类People 类内的 init 方法,初始化这个对象;

3、 Mymeta . _ _ call _ _方法 会返回这个初始化好的对象;

在这里插入图片描述

在这里插入图片描述

生成一个对象的完整代码

class Mymeta(type):

    def __new__(cls, *args, **kwargs):
        print('type 调用了 Mymeta 的 new 方法--生成一个空对象,即 People 类')
        "这里调用的是 type 的 new 方法,传入参数需要注意全部传会 type 元类"
        return super().__new__(cls, *args, **kwargs)


    def __init__(self, class_name, class_bases, class_dic):
        print('初始化这个对象--- People 类,给 People 类添加额外的功能')
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能
        # 自定义的类的功能
        if not class_name.istitle():
            raise TypeError('类名%s请修改为首字母大写' % class_name)

        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('类中必须有文档注释,并且文档注释不能为空')


    # 传入 Mymeta的参数:People, 以及传入People的参数
    def __call__(self, *args, **kwargs):
        """
        self---<class '__main__.People'>
        :param args: (1,)
        :param kwargs: {'y': 2}
        :return: 返回最终初始化好的代码
        """
        print('调用了 Mymeta 的 call 方法')
        # 调用 People 类里的 __new__方法,生成空对象
        People_obj = self.__new__(self, *args, **kwargs)
        # 调用 People 类里的 __init__方法,初始化空对象,注意:第一个传入的参数是生成好的空对象
        self.__init__(People_obj, *args, **kwargs)
        # 给 People 类生成的对象 obj 添加额外的功能
        print("给 People 类生成的对象 obj 添加额外的功能")
        People_obj.__dict__["新增一个属性"] = None
        # 返回初始化好的对象
        return People_obj


class People(metaclass=Mymeta):
    """People 类的注释"""

    # 产生 People 类真正的对象
    def __new__(cls, *args, **kwargs):
        # 在这里就可以定制功能
        print('生成 People 类的空对象')
        print('传入的位置参数', args)
        print('传入的位置参数', kwargs)
        # 调用所继承的父类的__new__方法,这里就是 object 类,一定要传入 cls(当前这个类)
        "这里要区别于自定义元类的 new 方法,自定义元类调用的是 type 的 new 方法,传入参数是不一样的"
        return super().__new__(cls)


    def __init__(self, x, y=None):
        print("初始化 People 类的对象")
        self.x = x
        self.y = y
        print("初始化 People 类的对象结束")


# 调用People 类生成对象---> People()= Mymeta.__call__()
obj = People(1, y=2)
print('最终的对象字典:', obj.__dict__)

在这里插入图片描述

  • 14
    点赞
  • 28
    收藏
  • 打赏
    打赏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:1024 设计师:我叫白小胖 返回首页
评论 3

打赏作者

本木夕丶Lu

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值