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