设计模式之单例模式（Python实现）

最新推荐文章于 2024-10-02 21:44:47 发布

pipipippipipipipip

最新推荐文章于 2024-10-02 21:44:47 发布

阅读量128

点赞数

文章标签：设计模式 Python

本文链接：https://blog.csdn.net/weixin_43182689/article/details/90899841

版权

单例模式

通常情况下，我们定义一个类，这个类可以实例化很多个不同的对象，这些对象互不相同

class Person:
    def __init__(self, name):
        self.name = name

p1 = Person('zyp')
p2 = Person("zyp")

print(p1.name, p2.name)
print(p1)
print(p2)
print(p1 is p2)

zyp zyp
<__main__.Person object at 0x000001A250FC6390>
<__main__.Person object at 0x000001A250FC6320>
False

通过上个例子可以看出，尽管实例化时传入的参数一样时，实例化后的对象还是不一样的。
如果我们想让这些实例化出来的对象要一样，这个时候就需要使用设计模式中的–单例设计模式

单例设计模式

目的 —— 让类创建的对象，在系统中只有唯一的一个实例
每一次执行类名() 返回的对象，内存地址是相同的
Python中实现单例模式需要借助__new__方法，所以我们要先了解__new__方法

`new`方法

使用类名() 创建对象时，Python 的解释器首先会调用 __new__ 方法为对象分配空间
__new__ 是一个由 object 基类提供的内置的静态方法，主要作用有两个：
1. 在内存中为对象分配空间
2. 返回对象的引用
__init__方法的主要作用有两个
1. 对象初始化
2. 定义实例属性
__new__和__init__两个方法共同实现了像c++中的构造方法的作用。
Python的解释器获得对象的引用后，将引用作为第一个参数，传递给 __init__ 方法
重写 new 方法的代码非常固定！
- 重写 __new__ 方法一定要 return super().__new__(cls)
- 否则 Python 的解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法
- 注意：__new__ 是一个静态方法，在调用时需要主动传递 cls 参数

class Player(object):
    def __new__(cls, *args, **kwargs):
        print("__new__方法被调用，为对象分配内存空间")
        
        return super().__new__(cls)
    
    def __init__(self):
        print("__init__实例化对象")
        
player = Player()


# __new__方法不返回内容，
class Error(object):
    def __new__(cls, *args, **kwargs):
        print("__new__方法被调用")
        
    def __init__(self):
        print("__init__方法被调用")

e = Error()

__new__方法被调用，为对象分配内存空间
__init__实例化对象
__new__方法被调用

Python 中的单例

单例 —— 让类创建的对象，在系统中只有唯一的一个实例
定义一个类属性，初始值是 None，用于记录单例对象的引用
重写 __new__ 方法
如果类属性 is None，调用父类方法分配空间，并在类属性中记录结果
返回类属性中记录的对象引用

# 1. 判断类属性是否为None
# 2. 调用父类方法，为第一个对象分配内存空间
# 3. 返回类属性保存的对象引用

class Player(object):
    instance = None
    
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance


player1 = Player()
player2 = Player()

print(player1)
print(player2)

<__main__.Player object at 0x000001A250FC6240>
<__main__.Player object at 0x000001A250FC6240>

上面的例子仅修改__new__方法，但是在每次在每次使用类名() 创建对象时，Python 的解释器都会自动调用两个方法：
- __new__ 分配空间
- __init__ 对象初始化
对__new__ 方法改造之后，每次都会得到第一次被创建对象的引用；但是：初始化方法还会被再次调用

# 初始化方法被调用了两次
# 第二次调用的初始化方法会修改第一次初始化的值，因为他们的内存地址是一样的
class Player(object):
    instance = None
    
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance
    
    def __init__(self, name):
        self.name = name
        
p1 = Player('111')
print(p1.name)

p2 = Player('222')
print(p1.name)
print(p2.name)

111
222
222

只执行一次初始化工作的解决办法

定义一个类属性 init_flag 标记是否执行过初始化动作，初始值为 False
在 __init__ 方法中，判断 init_flag，如果为 False 就执行初始化动作
然后将 init_flag 设置为 True
这样，再次自动调用 __init__ 方法时，初始化动作就不会被再次执行了

class Player(object):
    instance = None
    init_flag = False
    
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance
    
    def __init__(self, name):
        # 如果已经初始化过，则直接返回
        # 没有初始化则将进行初始化，并将初始化标记置为True
        if self.__class__.init_flag == True:
            return
        else:
            self.name = name
            self.__class__.init_flag = True
        
        
# 初始化方法只调用一次
# 只记录第一次初始化的值
p1 = Player('111')
print(p1.name)

p2 = Player('222')
print(p1.name)
print(p2.name)