python的单例模式

2023-01-31 05:01:15 python 模式
python单例模式
所谓单例，就是保证一个类仅有一个实例。所有引用（实例、对象）拥有相同的状态（属性）和行为（方法）；
同一个类的所有实例天然拥有相同的行为（方法）；
只需要保证同一个类的所有实例具有相同的状态（属性）即可；
所有实例共享属性的最简单最直接的方法就是__dict__属性指向（引用）同一个字典（dict）
 
单例模式动机
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在打印的任务；一个系统中只能有一个串口管理器或文件系统；一个系统只能有一个计时工具或ID生成器。如在window是中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪个才是真实的状态。因为有时确保系统中某个对象的唯一性（即一个类只有一个实例）非常重要。
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能阻止我们实例化多个对象。一个更好的方法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
单例模式要点
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。
从具体实现角度来说，就是一下三点：
一是单例模式的类只提供私有的构造函数；
二是类定义中含有一个该类的静态私有对象；
三是该类提供了一个静态的共有的函数用于创建或获取它本身的静态私有对象。

实现单例模式方法1：

  1. #/usr/bin/Python 
  2. #-*- encoding=utf-8 -*-    
  3.  
  4. #方法1,实现__new__方法    
  5. #并在将一个类的实例绑定到类变量_instance上,    
  6. #如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回    
  7. #如果cls._instance不为None,直接返回cls._instance    
  8. class Singleton(object):   
  9.     def __new__(cls, *args, **kw):   
  10.         if not hasattr(cls, '_instance'):   
  11.             orig = super(Singleton, cls)   
  12.             cls._instance = orig.__new__(cls, *args, **kw)   
  13.         return cls._instance   
  14.    
  15. class MyClass(Singleton):   
  16.     a = 1   
  17.    
  18. one = MyClass()   
  19. two = MyClass()   
  20.    
  21. two.a = 3   
  22. print one.a   
  23. #3    
  24. #one和two完全相同,可以用id(), ==, is检测    
  25. print id(one)   
  26. #29097904    
  27. print id(two)   
  28. #29097904    
  29. print one == two   
  30. #True    
  31. print one is two   
  32. #True    

实现单例模式方法2：

  1. #方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)    
  2. #同一个类的所有实例天然拥有相同的行为(方法),    
  3. #只需要保证同一个类的所有实例具有相同的状态(属性)即可    
  4. #所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)    
  5. #可参看:Http://code.activestate.com/recipes/66531/    
  6. class Borg(object):   
  7.     _state = {}   
  8.     def __new__(cls, *args, **kw):   
  9.         ob = super(Borg, cls).__new__(cls, *args, **kw)   
  10.         ob.__dict__ = cls._state   
  11.         return ob   
  12.    
  13. class MyClass2(Borg):   
  14.     a = 1   
  15.    
  16. one = MyClass2()   
  17. two = MyClass2()   
  18.    
  19. #one和two是两个不同的对象,id, ==, is对比结果可看出    
  20. two.a = 3   
  21. print one.a   
  22. #3    
  23. print id(one)   
  24. #28873680    
  25. print id(two)   
  26. #28873712    
  27. print one == two   
  28. #False    
  29. print one is two   
  30. #False    
  31. #但是one和two具有相同的（同一个__dict__属性）,见:    
  32. print id(one.__dict__)   
  33. #30104000    
  34. print id(two.__dict__)   
  35. #30104000    

实现单例模式方法3：

  1. #方法3:本质上是方法1的升级（或者说高级）版    
  2. #使用__metaclass__（元类）的高级python用法    
  3. class Singleton2(type):   
  4.     def __init__(cls, name, bases, dict):   
  5.         super(Singleton2, cls).__init__(name, bases, dict)   
  6.         cls._instance = None   
  7.     def __call__(cls, *args, **kw):   
  8.         if cls._instance is None:   
  9.             cls._instance = super(Singleton2, cls).__call__(*args, **kw)   
  10.         return cls._instance   
  11.    
  12. class MyClass3(object):   
  13.     __metaclass__ = Singleton2   
  14.    
  15. one = MyClass3()   
  16. two = MyClass3()   
  17.    
  18. two.a = 3   
  19. print one.a   
  20. #3    
  21. print id(one)   
  22. #31495472    
  23. print id(two)   
  24. #31495472    
  25. print one == two   
  26. #True    
  27. print one is two   
  28. #True    

实现单例模式方法4：

  1. #方法4:也是方法1的升级（高级）版本,    
  2. #使用装饰器(decorator),    
  3. #这是一种更pythonic,更elegant的方法,    
  4. #单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的    
  5. def singleton(cls, *args, **kw):   
  6.     instances = {}   
  7.     def _singleton():   
  8.         if cls not in instances:   
  9.             instances[cls] = cls(*args, **kw)   
  10.         return instances[cls]   
  11.     return _singleton   
  12.   
  13. @singleton   
  14. class MyClass4(object):   
  15.     a = 1   
  16.     def __init__(self, x=0):   
  17.         self.x = x   
  18.    
  19. one = MyClass4()   
  20. two = MyClass4()   
  21.    
  22. two.a = 3   
  23. print one.a   
  24. #3    
  25. print id(one)   
  26. #29660784    
  27. print id(two)   
  28. #29660784    
  29. print one == two   
  30. #True    
  31. print one is two   
  32. #True    
  33. one.x = 1   
  34. print one.x   
  35. #1    
  36. print two.x   
  37. #1   

 

相关文章