单例模式

存在的意义：放到同一个地，方便所有人共同操作 ，

• 使用函数装饰器实现单例
• 使用类装饰器实现单例
• 使用__new__关键字实现单例
• 使用metaclass实现单例

 

 

# 函数装饰器

def singletion(cls):
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]

    return inner


@singletion
class Cls:
    def __init__(self):
        pass


cls1 = Cls()
cls2 = Cls()
print(id(cls1) == id(cls2))

 

 

# 类装饰器

class Singletion:
    def __init__(self,cls):
        self._cls = cls
        self._instance = {}

    def __call__(self, *args, **kwargs):
        if self._cls not in self._instance:
            self._instance[self._cls] = self._cls()
        return self._instance[self._cls]


@Singletion
class Cls2:
    def __init__(self):
        pass


cls1 = Cls2()
cls2 = Cls2()
print(id(cls2) == id(cls1))

 

 

 

# new metaclass关键字

简单说：元类（metaclass）通过__metaclass__方法创建了类，而类通过__new__开辟了实例的内存地址

 

# __new__

class Single:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance

    def __init__(self):
        pass


s1 = Single()
s2 = Single()
print(id(s1) == id(s2))

 

 

# __metaclass__

def func(self):
    print("do sth")


Klass = type("Klass", (), {"func": func})
c = Klass()


class Singletion(type):
    _instance = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instance:
            cls._instance[cls] = super(Singletion, cls).__call__(*args, **kwargs)
        return cls._instance[cls]


class Cl3(metaclass=Singletion):
    pass


cls1 = Cl3()
cls2 = Cl3()
print(id(cls1) == id(cls2))