元类

python中一切皆对象，那么你定义的类也一定是对象，是某一个类实例化得到的，这个累我们就称为元类，如何找到元类呢

class People:
	def __init__(self,name,age):
		self.name=name
		self.age=age

print(type(People))  # 结果为<class 'type'>，证明是调用了type这个元类而产生的People，即默认的元类为type)

class关键字在帮我们创建类时，必然帮我们调用了元类People=type(...)，那People调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是
1、类名class_name='StanfordTeacher'
2、基类们class_bases=(object,)
3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的

调用type时会依次传入以上三个参数
综上，class关键字帮我们创建一个类应该细分为以下四个过程：

1. 拿到类名class_name='People'
2. 拿到类的基类class_bases=(object,)
3. 执行类体代码，拿到类的名称空间class_dict={...}
4. 通过元类实例化得到类People=type(class_name='People',class_bases=(object,),class_dict={...})

自定义元类控制类的创建

一个类没有声明自己的元类，默认是type，除了使用内置元类type，我们也可以通过继承type来自定义元类，然后使用metaclass关键字参数为一个类指定元类

class Mymeta(type):   # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    pass
    
class Teacher(object,metaclass=Mymeta): 
    school='Qinghua'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print('%s says welcome to Qinghua' %self.name)

自定义元类可以控制类的产生过程，类的产生过程其实就是元类的调用过程,即Teacher=Mymeta('Teacher',(object,),{...})，调用Mymeta会先产生一个空对象Teacher，然后连同调用Mymeta括号内的参数一同传给Mymeta下的__init__方法，完成初始化，

class Mymeta(type): 
    def __init__(self,class_name,class_bases,class_dic):
        # print(self)  # <class '__main__.StanfordTeacher'>
        # print(class_bases)  # (<class 'object'>,)
        # print(class_dic)  # {'__module__': '__main__', '__qualname__': 'Teacher', 'school': 'Qinghua', '__init__': <function Teacher.__init__ at 0x102b95ae8>, 'say': <function Teacher.say at 0x10621c6a8>}
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能

        if class_name.islower():
            raise TypeError('类名%s请修改为驼峰体' %class_name)

        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('类中必须有文档注释，并且文档注释不能为空')

# Teacher=Mymeta('Teacher',(object),{...})
class Teacher(object,metaclass=Mymeta): 
    """
    类Teacher的文档注释
    """
    school='Qinghua'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to Qinghua' %self.name)

自定义元类控制类Teacher的调用

__call__方法在调用对象时自动触发,调用对象的返回值就是__call__方法的返回值

class Mymeta(type):  
    def __call__(self, *args, **kwargs):
        print(self)  # <class '__main__.Teacher'>
        print(args)  # ('lili', 18)
        print(kwargs)  # {}
        return 123

class Teacher(object,metaclass=Mymeta):
    school='Qinghua'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print('%s says welcome to Qinghua' %self.name)

# 调用Teacher就是在调用Teacher类中的__call__方法
# 然后将Teacher传给self,溢出的位置参数传给*，溢出的关键字参数传给**
t1=Teacher('lili',18)
print(t1) # 123

调用t1=Teacher('lili',18)发生三件事：

1. 产生一个空对象obj
2. 调用__init__方法初始化对象obj
3. 返回初始化好的obj

Teacher类中的__call__方法也应该做这三件事

class Mymeta(type): 
    def __call__(self, *args, **kwargs): 
        # 1、调用__new__产生一个空对象obj
        obj=self.__new__(self) # 此处的self是类Teacher，必须传参，代表创建一个Teacher的对象obj
        # 2、调用__init__初始化空对象obj
        self.__init__(obj,*args,**kwargs)
        # 3、返回初始化好的对象obj
        return obj

class Teacher(object,metaclass=Mymeta):
    school='Qinghua'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

t1=Teacher('lili',18)
print(t1.__dict__)  # {'name': 'lili', 'age': 18}

上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用Teacher的过程，比如将Teacher的对象的所有属性都变成私有的

class Mymeta(type):
    def __call__(self, *args, **kwargs):  # 传进去的是Teacher类
        obj=self.__new__(self)   # Teacher类的父类new方法创建Teacher类
        self.__init__(obj,*args,**kwargs)  # Teacher类进行初始化
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}  # 将Teacher类的属性进行私有化
        return obj

class Teacher(object,metaclass=Mymeta):
    school='Qinghua'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print('%s says welcome to Qinghua' %self.name)

t1=Teacher('lili',18)
print(t1.__dict__)  # {'_Teacher__name': 'lili', '_Teacher__age': 18}

继承+元类——属性的查找

假设现在存在以下继承关系：对象Teacher继承对象Foo，对象Foo继承对象Bar，对象Bar继承对象object

上面的内容可以看出来，类其实也可以被当作对象来看，那么属性的查找也应该是按照继承的原理来的：Teacher->Foo->Bar->object->Mymeta->type

于是属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，另外一个层则是类层（即元类层）的查找

查找顺序：
1、先对象层：Teacher->Foo->Bar->object
2、然后元类层：Mymeta->type

单例模式

单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

单例模式的要点有三个：

• 一是某个类只能有一个实例
• 二是它必须自行创建这个实例
• 三是它必须自行向整个系统提供这个实例

方式一:借助new方法
这个方式不唯一，但是本质都是借助_instance标记状态，根据状态进行判断

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            orig=super(Singleton,cls)
            cls._instance=orig.__new__(cls,*args,**kwargs)
        return cls._instance

class MyClass(Singleton):
    a=1

one=MyClass()
two=MyClass()

# one和two完全相同，可以用id()，==，is检查
print(one.a)    # 1
print(id(one))  # 2565285375728
print(id(two))  # 2565285375728
print(one == two)   # True
print(one is two)   # True

方式二：定制元类实现单例模式

"""
class Singleton中的__init__在Myclass声明的时候被执行Myclass=Singleton()
Myclass()执行时，最先执行父类的__call__方法（object,Singleton都作为Myclass的父类，
根据深度优先算法，会执行Singleton中的__call__()，Singleton中的__call__()写了单例模式）
"""
class Singleton(type):

    def __init__(self, name, bases, dict):
        super(Singleton,self).__init__(name,bases, dict)
        self._instance = None

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super(Singleton,self).__call__(*args, **kwargs)
        return self._instance

class MyClass(object,metaclass=Singleton):
    a = 1

one=MyClass()
two=MyClass()
print(id(one))  # 1553247294800
print(id(two))  # 1553247294800
print(one == two)   # True
print(one is two)   # True

方式三:定义一个装饰器实现单例模式

def singleton(cls, *args, **kwargs):
    instances = {}
    
    def _singleton():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return _singleton

@singleton
class MyClass3(object):
    a = 1

one = MyClass3()
two = MyClass3()

print(id(one))  # 2880466769232
print(id(two))  # 2880466769232
print(one == two)   # True
print(one is two)   # True

class Singleton(object):
    __instance=None

    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if Singleton.__instance is None:
            Singleton.__instance=object.__new__(cls,*args, **kwargs)
        return Singleton.__instance

one=Singleton()
two=Singleton()
print(id(one))  # 2488569943376
print(id(two))  # 2488569943376
print(one == two)   # True
print(one is two)   # True

还有一种办法，我们都知道模块在导入的时候只导入一次，也就是说将你想要的内容放在一个py文件中，在你需要的时候直接进行导入，也是单例模式的一种实现方式