python元类学不学_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的类是print(type(OldboyTeacher)) # 结果为，证明是调用了type这个元类而产生的OldboyTeacher，即默认的元类为type1
2
3
4
5
6
7
8
9
10
11
12
13
141
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
121
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 called1
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
321
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= 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
301
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)) #1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
231
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) #False1
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
821
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