单例模式的实现

单例模式实现的多种方式

在类中借助绑定类的方法

class C1:
    __instancce = None

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def singleton(cls):  # 在类中创建一个绑定类的方法，类在调用的时候会自动传入
        if not cls.__instancce:
            cls.__instancce = cls('jason', 18)  # 产生一个对象赋值给__instance
        return cls.__instancce


obj1 = C1.singleton()
obj2 = C1.singleton()
print(id(obj1), id(obj2))  # 两个id相同的证明只有一个对象产生

借助元类产生单例模式

class MyType(type):
    def __init__(cls, what, bases=None, dict=None):  # 产生类的时候调用
        cls.__instance = cls.__new__(cls)  # 产生类的时候就有一个自定义的对象
        cls.__init__(cls.__instance, 'jason', 18)
        super().__init__(what, bases, dict)

    def __call__(cls, *args, **kwargs):
        if args or kwargs:  # 如果调用类加括号，括号里面有值走这里
            obj = cls.__new__(cls)
            cls.__init__(obj, *args, **kwargs)
            return obj
        return cls.__instance  # 括号里面没有值，直接将产生类的时候定义好的对象返回赋值，这样保证类加括号没值调用的时候，返回的永远都是同一个对象


class Mysql(metaclass=MyType):
    def __init__(self, name, age):
        self.name = name
        self.age = age


obj1 = Mysql()
obj2 = Mysql()
print(id(obj1), id(obj2))

基于模块的单例模式

"""提前产生一个对象，之后导模块使用"""
class C1:
    def __init__(self, name):
        self.name = name

obj = C1('jason')

基于装饰器的单例模式

def outer(cls):
    _instance = cls('jason', 18)  # 生成一个对象_instance

    def inner(*args, **kwargs):
        if args or kwargs:  # 如果inner没值，也是就是Mysql加阔无没填
            obj = cls(*args, **kwargs)
            return obj
        return _instance

    return inner


@outer
class Mysql:
    def __init__(self, host, port):
        self.host = host
        self.port = port


obj1 = Mysql()  # 产生类的时候没值，证明不会走装饰器里面args或者kwargs有值的
obj2 = Mysql()
obj3 = Mysql()
print(obj1 is obj2 is obj3)  # True