• 设计模式是前任工作的总结和提炼，通常，被人们广泛流传的设计模式都是针对某一特定问题的成熟的解决方案
  • 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性

 

  • 目的：让某一个类创建的实例对象，在整个应用程序中只有唯一的一个实例对象而且该对象易于外界访问，从而方便对实例个数的控制并节约系统资源
  • 每一次执行 类名() 返回的对象，内存地址是相同的

 

  • 音乐播放器对象
  • 回收站对象
  • 打印机对象
  • …..

 

  • 提问：如何保证一个类只有一个实例并且这个实例易于被访问呢？
  • 不使用单例模式：定义一个全局变量可以确保对象随时都可以被访问，但不能防止实例化多个对象
  • 单例模式的出现：类自己负责只能创建一个实例对象，可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法 

 

使用 类名() 创建对象时，Python 的解释器首先会调用 __new__ 方法为对象分配内存空间

 

  1. class PoloBlog:
  2.     def __new__(cls, *args, **kwargs):
  3.         print("分配内存地址啦")
  5.     def __init__(self):
  6.         print("初始化对象...")
  9. blog = PoloBlog()
  10. print(blog)
  13. # 输出结果
  14. 分配内存地址啦
  15. None

哎，为什么打印对象是 None，而且没有调用到 __init__ 方法呢？？下面讲解！

 

__new__ 是一个由 object 基类提供的内置的静态方法

 

  • 在内存中为实例对象分配空间
  • 返回对象的引用给 Python 解释器

Python 的解释器获得对象的引用后，将对象的引用作为第一个参数，传递给 __init__ 方法

 

  • 重写的代码是固定的
  • 重写 __new__ 方法一定要在最后 return super().__new__(cls) 
  • 如果不 return（像上面代码栗子一样），Python 的解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法（__init__）
  • 重点：__new__ 是一个静态方法，在调用时需要主动传递 cls 参数 
  1. class PoloBlog:
  2.     def __new__(cls, *args, **kwargs):
  3.         # 1、自动调用 __new__
  4.         print("分配内存地址啦")
  5.         # 2、为对象分配空间得到的引用赋值给 instance
  6.         instance = super().__new__(cls)
  7.         print(id(instance))
  8.         # 3、返回对象引用给 Python 解释器
  9.         return instance
  11.     def __init__(self):
  12.         print("初始化对象...")
  13.         print(id(self))
  16. blog = PoloBlog()
  19. # 输出结果
  20. 分配内存地址啦
  21. 4363809888
  22. 初始化对象...
  23. 4363809888

可以看到打印的两个内存地址是同一个哦：证明 __new__ 分配的对象引用的确传给了 __init__ 方法的 self 参数

 

  1. class PoloBlog:
  2.     def __new__(cls, *args, **kwargs):
  3.         print("分配内存地址啦")
  4.         instance = super().__new__(cls)
  5.         return instance
  7.     def __init__(self):
  8.         print("初始化对象...")
  11. blog = PoloBlog()
  12. blog1 = PoloBlog()
  14. print(id(blog))
  15. print(id(blog1))
  18. # 输出结果
  19. 4449363040
  20. 4449361984

很明显，两个对象各有自己的内存地址；单纯的重写 __new__ 方法并不能实现单例模式

 

单例：在整个应用程序中只有唯一的一个实例对象

  1. 定义一个类属性，来保存单例对象的引用
  2. 重写 __new__ 方法
  3. 如果类属性 is None，则调用父类方法分配内存空间，并赋值给类属性
  4. 如果类属性已有对象引用，则直接返回

 

  1. # 单例模式
  2. class PoloBlog:
  3.     instance = None
  5.     def __new__(cls, *args, **kwargs):
  6.         # 1、判断类属性是否为 None
  7.         if cls.instance is None:
  8.             # 2、为空，调用父类方法，给对象分配内存空间，并赋值给类属性
  9.             cls.instance = super().__new__(cls)
  11.         # 3、如果不为空，则直接返回类属性保存的对象引用
  12.         return cls.instance
  14.     def __init__(self):
  15.         pass
  18. blog = PoloBlog()
  19. blog1 = PoloBlog()
  20. blog2 = PoloBlog()
  21. print(id(blog), id(blog1), id(blog2))
  24. # 输出结果
  25. 4336982096 4336982096 4336982096

可以看到创建的三个实例对象其实都是同一个，这就是单例模式！

 

在每次使用类名()创建对象时，Python 的解释器都会自动调用两个方法

  • __new__ 分配空间
  • __init__ 对象初始化

上面所说的单例模式，是针对 __new__ 方法进行重写的，创建多个实例对象都会得到同一个实例对象

但是：初始化方法还是会被多次调用

  1. class PoloBlog:
  2.     instance = None
  4.     def __new__(cls, *args, **kwargs):
  5.         if cls.instance is None:
  6.      
  7.             cls.instance = super().__new__(cls)
  9.         return cls.instance
  11.     def __init__(self):
  12.         print("yep")
  15. blog = PoloBlog()
  16. blog1 = PoloBlog()
  17. blog2 = PoloBlog()
  20. # 输出结果
  21. yep
  22. yep
  23. yep

 

其也很简单，和单例模式的解决思路差不多

  1. 定义一个类属性标记是否执行过初始化动作，初始值为 False
  2. 在 __init__ 方法中，判断类属性，如果 False，则执行初始化动作，然后设置为 True
  3. 如果 True 则直接跳过不执行
  1. # 单例模式
  2. class PoloBlog:
  3.     instance = None
  4.     init_flag = None
  6.     def __new__(cls, *args, **kwargs):
  7.         if cls.instance is None:
  8.  
  9.             cls.instance = super().__new__(cls)
  11.         return cls.instance
  13.     def __init__(self):
  14.         # 1、判断是否为 True，因为是实例方法，所以调用类属性要通过类对象
  15.         if PoloBlog.init_flag:
  16.             # 2、如果 True，直接跳过不执行后续初始化动作
  17.             return
  18.         # 3、如果 False，则执行
  19.         print("初始化动作")
  20.         # 4、修改 init_flag
  21.         PoloBlog.init_flag = True
  24. blog = PoloBlog()
  25. blog1 = PoloBlog()
  26. blog2 = PoloBlog()
  29. # 输出结果
  30. 初始化动作

 

版权声明：本文为poloyy原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/poloyy/p/15236309.html