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