Python学习笔记：单例模式

单例模式：一个类不管实例化多少次，返回的都是同一个实例，例如：a1=A(), a2=A(), a3=A()，a一、a2和a3其实都是同一个对象，即print(a1 is a2)和print(a2 is a3)都会打印True。

实现方式：有两种方式，一种是使用元类metaclass控制类实例化时的对象，另外一种是使用类的__new__方法控制类返回的对象，推荐使用元类的方式，由于__new__一般是用来改变类结构的。

注：关于元类和单例模式，本文只是贴了两个简单的示例代码和本身的一些心得，想要更加深刻的学习，这里有一篇博客讲得很详细https://www.cnblogs.com/tkqasn/p/6524879.html

 

元类实现单例模式（Python3.6）：

 1 class Singleton(type):
 2     def __init__(cls, *args, **kwargs):
 3         cls.__instance = None
 4         super().__init__(*args, **kwargs)
 5 
 6     def __call__(cls, *args, **kwargs):
 7         if cls.__instance is None:
 8             cls.__instance = super().__call__(*args, **kwargs)
 9 
10         return cls.__instance
11 
12 
13 class MySingleton(metaclass=Singleton):
14     def __init__(self, val):
15         self.val = val
16         print(self.val)
17 
18 
19 hello = MySingleton('hello')
20 hi = MySingleton('hi')
21 print(hello is hi)
22 
23 ----------输出结果----------
24 hello
25 True

• metaclass：Python3中metaclass是经过指定metaclass实现的，Python2中是经过指定类变量__metaclass__来实现的，但原理都是同样的。
• type：Python中全部的类都是type类的实例，即一个类（还未实例化）的定义，其实就是type类（Python内建元类）的实例。以下的打印能够更加直观的理解这一点：

  >>> int.__class__
  <class 'type'>
  >>> num = 3
  >>> num.__class__
  <class 'int'>
  >>> num.__class__.__class__
  <class 'type'>
  >>> 
  >>> 
  >>> class A:
      pass
  
  >>> A.__class__
  <class 'type'>
  >>> a = A()
  >>> a.__class__
  <class '__main__.A'>
  >>> a.__class__.__class__
  <class 'type'>
  >>> 

   

• __call__：当调用一个实例时，即执行实例加括号的形式，就会调用该实例的__call__方法，若是没有定义（须要本身定义），则会报错。例如a=A()，a()就会调用a的__call__方法。
• 代码执行流程：第一步执行MySingleton时（即没加括号的部分），进行元类的实例化，即MySingleton=Singleton()，Singleton的实例化和普通类同样会先执行__new__返回该类的实例，而后自动执行该实例的__init__方法进行初始化，此示例中的初始化方法给该实例赋予了一个值为None的__instance变量；第二步执行MySingleton('hello')时，进行类的实例化，即MySingleton('hello')=Singleton()('hello')，这里就会调用到Singleton的__call__方法了，而super().__call__即调用type的__call__方法，这时候就和普通类实例化同样会调用MySingleton的__new__和__init__方法了。
• 原理：因为每次实例化MySingleton时都会先调用metaclass中的__call__方法，因此只有第一次实例化时才会执行MySingleton的__new__和__init__，后面的实例化都只会返回第一次实例化好的实例，因此致使的结果就是不管进行多少次实例化，都给你返回同一个实例，固然就只有单例了（因此“输出结果”中就没有打印“hi”了） 。
• cls和self：Singleton的编写，在eclipse中提示须要写成self，在PyCharm中提示须要写成cls，由于参数self是约定表明实例自己，但在这里type的实例就是类，因此推荐写成cls。

 

__new__实现单例模式（Python3.6）：

 1 class MySingleton:
 2     def __init__(self, val):
 3         self.val = val 
 4         print(self.val) 
 5         print(self.__dict__)
 6 
 7     def __new__(cls, *args, **kwargs):
 8         if not hasattr(cls, '_instance'):
 9             cls._instance = super().__new__(cls)
10 
11         return cls._instance
12 
13 
14 hello = MySingleton('hello')
15 hi = MySingleton('hi')
16 print(hello is hi)
17 
18 
19 -----------输出结果--------------
20 hello
21 {'val': 'hello'}
22 hi
23 {'val': 'hi'}
24 True

• 原理：经过给类定义一个类变量，指向本类的一个实例，每次实例化调用__new__的时候都返回这个类变量，能够看到数据结果打印的是True，因此天然就是单例了。
• 缺点：每次实例化虽然都是同一个实例，可是每次实例化都会调用一次__init__方法，致使这个实例会随着每次初始化而改变，因此不推荐这种方式来实现单例，由于__new__方法通常是用来改变类结构的。
• hasattr：类中的私有变量，即加了双下划线的变量，在__dict__中会加上一个“_classname”前缀，因此若是这里使用__instance的话，hasattr(cls, '__instance')会一直返回False，由于这里已经不是__instance了，而是_MySingleton__instance。