深入理解 python 元类

一、什么的元类

# 思考：
#     Python 中对象是由实例化类得来的，那么类又是怎么得到的呢？
# 疑问：
#     python 中一切皆对象，那么类是否也是对象？如果是，那么它又是那个类实例化而来的呢？

class student(object):
    def __init__(self):
        pass

jmz = student()

print(type(jmz))  # <class '__main__.student'>   实例化student 得来的
print(type(student))    # <class 'type'>   

# 说明student类 是实例化type得来的。但任然是类
# 总结：  元类即类的类。  type 就是Python中的默认元类
# 元类===》类====》对象 （对象是实例化类得来的，类是实例化元类得来的）

二、类的产生过程

　　2.1 类的三大关键组成部分

　　1、类名

　　2、类的基类们

　　3、类的名称空间

　　2.2 type讲解

 　　在Python中type 函数有两种完全不同 的用法，一个是用来返回对象的类，一个则是动态的创建类。（我知道，根据传入参数的不同，同一个函数拥有两种完全不同的用法是一件很傻的事情，但这在Python中是为了保持向后兼容性）

　　2.3 type的两种用法

# type用法一： 查看对象的类
class dog(object):
    def __init__(self):
        pass
    def eat(self):
        print('dog eating...')

dog1 = dog()
dog1.eat()          # dog eating...
print(type(dog1))   # <class '__main__.dog'>
print(dog.__dict__)
# {'__module__': '__main__', '__init__': <function dog.__init__ at 0x00000000021B9950>, 'eat': <function dog.eat at 0x00000000021B99D8>, '__dict__': <attribute '__dict__' of 'dog' objects>, '__weakref__': <attribute '__weakref__' of 'dog' objects>, '__doc__': None}

# type 用法二： 创建动态类
def __init__(self):
    pass
def eat(self):
    print("cat eating...")
cat = type('cat',(object,),{"__init__":__init__,"eat":eat})

cat1 = cat()
cat1.eat()          # cat eating...
print(type(cat1))  # <class '__main__.cat'>
print(cat.__dict__)
# {'__init__': <function __init__ at 0x00000000004D1EA0>, 'eat': <function eat at 0x00000000022D9A60>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'cat' objects>, '__weakref__': <attribute '__weakref__' of 'cat' objects>, '__doc__': None}

# 分析：
#     1、dog 类 与cat类功能基本一致，只是实现方式不同，一个使用了class 定义了类，一个使用了type产生了一个类
#     2、dog类与cat类实例化方式一样，
#     3、产生对象后的调用对象方法一样
#     4、__dict__ 类的内容基本一致

# 总结：
#     class 关键字的底层实现就是做了与type方法一样的事

 

　　2.4、 class关键字底层实现

#1 拿到类名class_name="cat"
#2 拿到基类们class_bases=(object,)
#3 拿到名称空间 class_dic={...}
#4 调用元类产生cat类，
cat=type(class_name,class_bases,class_dic)

三、元类的使用

　　3.1 自定义元类

　　　　Python 中默认元类就是type，所以要自定义元类就需要继承元类，继承元类的类任然是元类 

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

class Mymeta(type):   # 继承type元类
    def __init__(self,class_name,class_bases,class_dict):
        if not class_name.istitle():
            raise TypeError('类的名称首字母必须大写')
        if not class_dict.get('__doc__'):
            raise TypeError('类的定义必须要有参数')
        super(Mymeta, self).__init__(class_name, class_bases, class_dict)


# 使用mateclass
class People(object,metaclass=Mymeta):       # ===》 People = type("People",(object,),{名称空间})
    '''
    这是一个关于人的类
    '''
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def do(self,thing):
        print("%s 正在做%s"%self.name,thing)

　　3.2 自定义元类产生类

　　　通过对于元类的创建，我们可以做到控制元类，约束类的创造。

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

class Mymeta(type):   # 继承type元类
    def __init__(self,class_name,class_bases,class_dict):  # class_name="People",class_bases=(object,),class_dict={名称空间}
        if not class_name.istitle():
            raise TypeError('类的名称首字母必须大写')
        if not class_dict.get('__doc__'):
            raise TypeError('类的定义必须要有参数')
        super(Mymeta, self).__init__(class_name, class_bases, class_dict)


# 使用mateclass
class People(object,metaclass=Mymeta):       # ===》 People = type("People",(object,),{名称空间})
    '''
    这是一个关于人的类
    '''
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def do(self,thing):
        print("%s 正在做%s"%self.name,thing)

　　

　　3.3 __call__ 方法

　　　　对象是由类调用产生的，对象被当成方法调用，会触发类的__call__方法　　　　

class teacher(object):
    __addr ="上海校区"
    def __init__(self,name):
        self.name = name
    def select_class(self):
        pass
    def __call__(self, *args, **kwargs):   # 对象当成方法调用时会触发类的__call__ 方法执行
        print("对象调用触发")
        print(args)
        print(kwargs)


egon = teacher('egon')
egon(23,"男",school = "oldboy")   
# 对象调用触发
# (23, '男')
# {'school': 'oldboy'}

　　　

　　　　类是由元类调用产生的，那么类被当成方法调用也应该触发元类的__call__方法

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print("我是元类的__call__ 方法，类被调用时触发")
        print(args)
        print(kwargs)


class Student(object,metaclass=Mymeta):   # Student = type("Student",(object,),{})
    pass


Student('jmz',18,school="交大")
# 我是元类的__call__ 方法，类被调用时触发
# ('jmz', 18)
# {'school': '交大'}

　　　　从上面的代码我们可以看出，对象的产生其实就是，调用了类，进而触发了元类的__call__ 方法，

　　　但是调用类产生的是对象，说明元类的__call__ 方法是用来产生对象的。

　　　　说明元类的__call__ 方法就做了下面的几件事

　　　　　　1、创造了一个空对象

　　　　　　2、调用了类的__init__ 方法

　　　　　　3、将参入传入__init__方法中

　　　　　　

　　3.4 自定义元类产生对象

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

class Mymeta(type):  
    def __init__(self,class_name,class_bases,class_dict):
        if not class_name.istitle:
            raise TypeError("类的首字母必须大写")
        if not class_dict.get("__doc__"):
            raise TypeError("类的创建需写入注释说明")

        super(Mymeta,self).__init__(class_name,class_bases,class_dict)

    def __call__(self, *args, **kwargs):   # __call__  是由类调用的，所以self 就是类本身
        # 1、 产生一个空对象
        # 2、 将参数传入类的__init___方法中

        obj = object.__new__(self)   # 产生一个空对象,, __new__ 是object 的静态方法
        self.__init__(obj,*args,**kwargs)  # 调用类的__init__ 方法，self 就是类

        return obj



class Student(object,metaclass=Mymeta):
    '''
    这是学生类
    '''
    __school = "上海交大"
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def get_school(self):
        return self.__school


jmz = Student("jmz",24)
print(jmz.__dict__)
print(jmz.get_school())
# {'name': 'jmz', 'age': 24}
# 上海交大

# 上文解释：
   1、元类的__call__ 方法是由类被调用触发的（即类（），就会触发），
   2、类是实例化元类产生的，也可以说是元类产生的对象就是类，触发元类的__call__ 方法就是由类这个对象调用触发的，所以元类中的self 就是类。
   3、将参数传入类的__init__ 方法其实就是将参数传入元类中self的__init__方法。
   4、调用类的__init__ 方法与调用静态方法相同，该传的参数都要传

四、为什么要使用元类

　　从上面的如何使用元类中，我们可以看出，通过对于元类的定义，我们可以控制类的产生，和对象的产生。

五、单例模式

　　5.1 类实现单例模式

　　　　单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

class mysql(object):
    __instance = None
    def __init__(self):
        pass

    @classmethod
    def get_instance(cls,*args,**kwargs):
        if not cls.__instance:
            cls.__instance = cls(*args,**kwargs)
        return cls.__instance


mysql = mysql.get_instance()
print(mysql)
# <__main__.mysql object at 0x00000000022D7BE0>
mysql = mysql.get_instance()
print(mysql)
# <__main__.mysql object at 0x00000000022D7BE0>


# 说明两个返回的内容地址是一样的，说明只实例化了一次。

　　5.2 元类实现单例模式

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

class Mymeta(type):
    __instance = None
    def __init__(self,class_name,class_bases,class_dict):
        if not class_name.istitle:
            raise TypeError("类的首字母必须大写")
        if not class_dict.get("__doc__"):
            raise TypeError("类的创建需写入注释说明")

        super(Mymeta,self).__init__(class_name,class_bases,class_dict)

    def __call__(self, *args, **kwargs):   # __call__  是由类调用的，所以self 就是类本身
        # 1、 产生一个空对象
        # 2、 将参数传入类的__init___方法中
        if not self.__instance:
            obj = object.__new__(self)   # 产生一个空对象,, __new__ 是object 的静态方法
            self.__init__(obj,*args,**kwargs)  # 调用类的__init__ 方法，self 就是类
            self.__instance = obj
        return self.__instance

class Student(object,metaclass=Mymeta):
    '''
    学生类
    '''
    def __init__(self,name,age,school):
        self.name = name
        self.age = age
        self.school = school

    def learn(self,thing):
        print("%s 正在学习%s"%(self.name,thing))

class Teacher(object,metaclass=Mymeta):
    '''
    老师类
    '''
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def teach(self,):
        print("%s 正在教书中。。。"%self.name)


jmz = Student("jmz",23,"北大")
jmz1 = Student("jmz1",23,"北大")

print(id(jmz),id(jmz1))
# 38853264 38853264


egon = Teacher("egon",24)
egon1 = Teacher("egon1",24)
print(id(egon),id(egon1))
# 31578992 31578992



# 解释
# 1、student 类和 teacher类都是调用元类产生的，不同的类调用元类就好产生不同的内容地址。不同的类也只会定义一次（正常的）
# 2、 对象的产生是有调用了元类的__call__ 方法产生的，所以每次调用都返回相同的对象（单例）。