Python学习——面向对象之元类

文章目录

  • 什么是元类
  • 类的创建过程--元类的引出
  • 自定义元类
    • `__init__()`、`__new__()`、`__call__()`魔术方法
    • 自定义元类使用`__call__`
    • 自定义元类使用`__new__`
    • 自定义元类总结
  • 练习,使用元类实现单例模式

元类属于python面向对象编程的深层魔法,在写这篇文章时,我也只是一知半解,只是明白了元类是什么,怎么实现一个元类,但是我不明白为什么需要元类,什么情况下需要使用元类,元类的特性都能干些什么?一连串的疑问,摆在我的面前,无法消化,希望我在写完这篇文章的时候,能够解答这些疑问,在以后的工作中,我能明确的知道我为什么要使用元类,以及怎样使用元类。
在参考别人的博客中,我觉得这篇文章浅显易懂:https://segmentfault.com/a/1190000011447445

什么是元类

刚学Python的时候,就总是听到Python中一切皆对象,貌似java也这么说,我就这样相信了,那就一切皆对象吧!毕竟我还知道对象是怎么回事;当我看到元类的时候,我意识到“一切皆对象”没那么简单。
元类:用我的意思理解就是产生类的类、类的祖先,Python中所有类的产生都是直接或间接通过元类生成
但我更喜欢这样的解释:中国道家哲学,道生一,一生二,二生三,三生万物。

  • 道 即是 type元类
  • 一 即是 metaclass(元类,或者叫类生成器,继承自type)
  • 二 即是 class(类,或者叫实例生成器,由metaclass生成)
  • 三 即是 instance(实例对象,由class生成)
  • 万物 即是实例的各种属性与方法,我们平常使用python时,调用的就是它们。

类的创建过程–元类的引出

看以下类的定义以及实例化过程

class OldboyTeacher(object): school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)t1=OldboyTeacher('egon',18)print(type(t1)) #查看对象t1的类是<class '__main__.OldboyTeacher'>print(type(OldboyTeacher)) # 结果为<class 'type'>,证明是调用了type这个元类而产生的OldboyTeacher,即默认的元类为type

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

所有的对象都是实例化都是调用类而得到的(调用类的过程称为类的实例化),比如对象t1是调用类OldboyTeacher得到的;如果一切皆为对象,那么类OldboyTeacher本质也是一个对象,既然所有的对象都是调用类得到的,那么OldboyTeacher必然也是调用了一个类得到的,这个类就称为元类;
元类——>类——>对象 的实例化过程如下图

可是我没看见调用元类生成OldboyTeacher的过程啊,在哪里?
问题就出在关键字'class'这里了,class关键字在帮我们创建类时,必然帮我们调用了元类OldboyTeacher=type(…)
那调用type时传入的参数是什么呢?咱好好想想,要创建一个类需要哪些参数,我自己凭空想到的是类名、基类,但实际还有一个;创建类的三大参数:

  • 类名:class_name=‘OldboyTeacher’
  • 基类们:class_bases=(object,)
  • 类的名称空间:class_dic,类的名称空间是执行类体代码而得到的,以字典形式保存

调用type时会依次传入以上三个参数,class关键字帮我们创建一个类应该细分为以下四个过程:

自定义元类

一个类没有声明自己的元类,默认元类就是type,除了使用内置元类type,我们也可以通过继承type来自定义元类,然后使用metaclass关键字参数为一个类指定元类

class Mymeta(type): #只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类    pass# OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})class OldboyTeacher(object,metaclass=Mymeta):     school='oldboy'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the oldboy to learn Python' %self.name)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在进一步研究元类之前,有必要说明一下__init__()__new__()__call__()这三个魔术方法的区别与用途。为什么呢,因为我在研究元类的时候,在这个__new__(),这里卡了很久,傻傻的弄不明白,所以必须在这里写清楚,有助于元类的研究

__init__()__new__()__call__()魔术方法

  • __new__:方法负责创建一个实例对象,在对象被创建的时候调用该方法,它是一个类方法。__new__方法在返回一个实例之后,会自动的调用__init__方法,对实例进行初始化。如果__new__方法不返回值,或者返回的不是实例,那么它就不会自动的去调用__init__方法。依照Python官方文档的说法,__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple), 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。
  • __init__: 方法负责将该实例对象进行初始化,在对象被创建之后调用该方法,在__new__方法创建出一个实例后对实例属性进行初始化。__init__方法可以没有返回值。
  • __call__:调用对象的时候执行,方式是:“对象()”。

__init____new__最主要的区别在于:

  • __init__通常用于初始化一个新实例,控制这个初始化的过程,比如添加一些属性, 做一些额外的操作,发生在类实例被创建完以后。它是实例级别的方法,此处的实例:既可以是类也可以是对象。
  • __new__ 通常用于控制生成一个新实例类的过程。它是类级别的方法。
  • __call__ 通常用于控制生成一个新实例对象的过程。它是对象级别的方法。
class Foo(object): def __new__(cls, *args, **kwargs): #__new__是一个类方法,在对象创建的时候调用,也就是创建类的时候调用 print 'excute __new__' return super(Foo,cls).__new__(cls,*args,**kwargs) def __init__(self,value): #__init__是一个实例方法,在对象创建后调用,对实例属性做初始化 print 'excute __init' self.value = valuef1 = Foo(1)print f1.valuef2 = Foo(2)print f2.value#输出===:excute __new__excute __init1excute __new__excute __init2#====可以看出new方法在init方法之前执行class A(object): def __call__(self): print '__call__ be called'a = A()a()#输出#__call__ be called

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

自定义元类使用__call__

class Mymeta(type):     n=444    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>        obj=self.__new__(self)        self.__init__(obj,*args,**kwargs)        print(self.__new__ is object.__new__) #True        return objclass Bar(object):    n=333    # def __new__(cls, *args, **kwargs):    #     print('Bar.__new__')class Foo(Bar):    n=222    # def __new__(cls, *args, **kwargs):    #     print('Foo.__new__')#此处发生一件极为重要的事情,class关键字创建类,并且使用Mymeta元类创建类:#OldboyTeacher=Mymeta('OldboyTeacher',(Foo,Bar,object),{...})class OldboyTeacher(Foo,metaclass=Mymeta):    n=111    school='oldboy'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the oldboy to learn Python' %self.name)    # def __new__(cls, *args, **kwargs):    #     print('OldboyTeacher.__new__')OldboyTeacher('egon',18) #触发Mymeta的类中的__call__方法的执行,进而执行self.__new__开始查找 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 疑问:class OldboyTeacher(Foo,metaclass=Mymeta)并没有触发__call__ 方法执行,为什么?不是说元类创建类会产生这个调用吗 OldboyTeacher=Mymeta(‘OldboyTeacher’,(Foo,Bar,object),{…}),这是符合__call__ 执行条件啊

class自定义的类也全都是对象(包括object类本身也是元类type的 一个实例,可以用type(object)查看),我们学习过继承的实现原理,如果把类当成对象去看,将下述继承应该说成是:对象OldboyTeacher继承对象Foo,对象Foo继承对象Bar,对象Bar继承对象object。
结合python继承的实现原理+元类重新看属性的查找应该是什么样子呢???
属性查找应该分成两层,一层是对象层(基于c3算法的MRO)的查找,另外一个层则是类层(即元类层)的查找
我们来分析下元类Mymeta中__call__里的self.__new__的查找顺序

Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都没有找到__new__的情况下,会去找object里的__new__,而object下默认就有一个__new__,所以即便是之前的类均未实现__new__,也一定会在object中找到一个,根本不会、也根本没必要再去找元类Mymeta->type中查找__new__

自定义元类使用__new__

class Mymeta(type): #只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类 n=444 def __new__(cls, *args, **kwargs): obj=type.__new__(cls,*args,**kwargs) # 必须按照这种传值方式 print(obj.__dict__) return obj # 只有在返回值是type的对象时,才会触发下面的__init__ #return 123 def __init__(self,class_name,class_bases,class_dic): print('run。。。')#OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})#啊,此处触发了__new__方法的执行class OldboyTeacher(object,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)print(type(Mymeta)) #<class 'type'>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 疑问:class OldboyTeacher(object,metaclass=Mymeta)触发__new__ 方法执行,为什么?不是说元类创建类会产生这个调用吗 OldboyTeacher=Mymeta(‘OldboyTeacher’,(object,),{…}),这是符合__call__ 执行条件啊,可是Mymeta里面没有__call__ 方法啊?

自定义元类总结

以上两节的疑问,还没有解决,经过多番查证,class OldboyTeacher(object,metaclass=Mymeta),这种定义方式,触发的Mymeta调用方式如下:
Mymeta.__new__(cls, name, bases, attrs)
__new__()方法接收到的参数依次是:

  • 当前准备创建的类的对象;
  • 类的名字;
  • 类继承的父类集合;
  • 类的方法集合。

这就解决我的疑问了;然后再仔细分析总结如下:

  • 使用__new__方法实现自定义元类,控制的是基于这个元类创建类实例的过程
  • 使用__call__方法实现自定义元类,控制的是基于这个元类已创建的类实例,后续创建对象的过程

至于这两种方式在什么场景下使用,我也不知道,等待时间的沉淀吧!
至少此时我知道,要实现ORM框架,貌似需要控制类的创建,那应该是使用__new__ 的方式实现元类吧,好吧,期待下一篇的ORM框架。

练习,使用元类实现单例模式

# 单例:即单个实例,指的是同一个类实例化多次的结果指向同一个对象,用于节省内存空间# 如果我们从配置文件中读取配置来进行实例化,在配置相同的情况下,就没必要重复产生对象浪费内存了#settings.py文件内容如下HOST='1.1.1.1'PORT=3306#方式一:定义一个类方法实现单例模式import settingsclass Mysql:    __instance=None    def __init__(self,host,port):        self.host=host        self.port=port    @classmethod    def singleton(cls):        if not cls.__instance:            cls.__instance=cls(settings.HOST,settings.PORT)        return cls.__instanceobj1=Mysql('1.1.1.2',3306)obj2=Mysql('1.1.1.3',3307)print(obj1 is obj2) #Falseobj3=Mysql.singleton()obj4=Mysql.singleton()print(obj3 is obj4) #True#方式二:定制元类实现单例模式import settingsclass Mymeta(type):    def __init__(self,name,bases,dic): #定义类Mysql时就触发        # 事先先从配置文件中取配置来造一个Mysql的实例出来        self.__instance = object.__new__(self)  # 产生对象        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化对象        # 上述两步可以合成下面一步        # self.__instance=super().__call__(*args,**kwargs)        super().__init__(name,bases,dic)    def __call__(self, *args, **kwargs): #Mysql(...)时触发        if args or kwargs: # args或kwargs内有值            obj=object.__new__(self)            self.__init__(obj,*args,**kwargs)            return obj        return self.__instanceclass Mysql(metaclass=Mymeta):    def __init__(self,host,port):        self.host=host        self.port=portobj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化,所有的实例应该指向一个内存地址obj2=Mysql()obj3=Mysql()print(obj1 is obj2 is obj3)obj4=Mysql('1.1.1.4',3307)#方式三:定义一个装饰器实现单例模式import settingsdef singleton(cls): #cls=Mysql    _instance=cls(settings.HOST,settings.PORT)    def wrapper(*args,**kwargs):        if args or kwargs:            obj=cls(*args,**kwargs)            return obj        return _instance    return wrapper@singleton # Mysql=singleton(Mysql)class Mysql:    def __init__(self,host,port):        self.host=host        self.port=portobj1=Mysql()obj2=Mysql()obj3=Mysql()print(obj1 is obj2 is obj3) #Trueobj4=Mysql('1.1.1.3',3307)obj5=Mysql('1.1.1.4',3308)print(obj3 is obj4) #False
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
(0)

相关推荐

  • 关于def __init__(self)的一些知识点

    def __init__(self)在Python里面很常见,Python中的self在Python中的类Class的代码中,常看到函数中的第一个参数,都是self.以及Class中的函数里面,访问对 ...

  • Python学习——面向对象高级之反射

    反射 hasattr getattr setattr delattr 模块与函数反射 对象魔术方法 __getattr__(self, name) __setattr__(self, name) __ ...

  • Python学习——面向对象高级之描述符

    什么是描述符 描述符有什么用 描述符触发执行条件以及访问优先级 类属性优先级大于数据描述符 数据描述符优先级大于实例属性 实例属性优先级大于非数据描述符 描述符使用 描述符使用陷阱 如何检测一个对象是 ...

  • Python学习——面向对象之ORM

    文章目录 前述 表格设计 用户表结构 电影表结构 公告表结构 表格对应的类设计 字段类 字符串类字段 数值字段类 用户表类 电影表类 公告类 元类设计 Models基类 Models的元类ModelM ...

  • Python学习—面向对象编程基础篇

    python面向对象编程已经学完了,有必要进行一下记录总结,加深一下理解,不然似懂非懂容易忘记:面向对象的知识点很多,其中面向对象的高级篇:元类,需要另外一篇博客来写,最后还要手撸一个简单版本的ORM ...

  • Python是面向对象还是过程?Python学习

    面向过程和面向对象是一种编程思想,那么Python开发是面向过程.函数还是对象呢?在这里,小编告诉大家,Python既支持面向对象,也可以支持面向过程. 虽然说Python是一种解释型语言,但它从一开 ...

  • 说说Python中元类是什么?

    公众号新增加了一个栏目,就是每天给大家解答一道Python常见的面试题,反正每天不贪多,一天一题,正好合适,只希望这个面试栏目,给那些正在准备面试的同学,提供一点点帮助! 小猿会从最基础的面试题开始, ...

  • Python字符编码有几类?Python学习教程

    刚开始学习Python,肯定少不了基础知识的了解,比如说字符编码,那么你知道Python常见字符编码有哪些吗?我们一起来看看Python字符编码的常用种类吧. 第一种:ASCII码.是基于拉丁字母的一 ...

  • python学习——类中为什么要定义__init__()方法

    python学习--类中为什么要定义__init__()方法 geerniya 2017-08-22 21:12:41 36244 收藏 188 分类专栏: python 文章标签: python 版 ...

  • python语言学习:python语言学习中的定义类、定义函数、封装api等详细攻略

    python语言学习:python语言学习中的定义类.定义函数.封装api等详细攻略 python语言学习中的定义类 1.定义类的结构形式 class LSTMRNN(object): # __ini ...