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的类是<class '__main__.OldboyTeacher'>
print(type(OldboyTeacher)) 
# 结果为<class 'type'>，证明是调用了type这个元类而产生的OldboyTeacher，即默认的元类为type

所有的对象都是实例化都是调用类而得到的（调用类的过程称为类的实例化），比如对象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)

在进一步研究元类之前，有必要说明一下__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 = value

f1 = Foo(1)
print f1.value
f2 = Foo(2)
print f2.value

#输出===：
excute __new__
excute __init
1
excute __new__
excute __init
2
#====可以看出new方法在init方法之前执行

class A(object):
    def __call__(self):
        print "__call__ be called"
a = A()
a()
#输出
#__call__ be called 

自定义元类使用__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 obj
class 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__开始查找 

• 疑问：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'>

• 疑问：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 settings
class 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.__instance

obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True

#方式二：定制元类实现单例模式
import settings
class 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.__instance

class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)
obj4=Mysql('1.1.1.4',3307)

#方式三:定义一个装饰器实现单例模式
import settings
def 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=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False