Python之单例模式

阅读目录

• 一、使用类的方法
• 二、使用装饰器
• 三、使用元类

单例模式基本概念

'''
1、什么是单例模式
    单例模式：基于某种方法实例化多次得到实例是同一个
2、为何用单例模式
    当实例化多次得到的对象中存放的属性都一样的情况，应该将多个对象指向同一个内存地址，即同一个实例
3、如何用
'''

回到顶部

一、使用类的方法

# 单例模式实现一：
""" 定义一个类，由类来调用,完成单例的调用过程"""
#配置文件settings内容：
"""
IP='0.0.0.1'
PORT=3306
"""
import settings
class Mysql:
    __instance=None          #通过数据属性来记录用户调用类的方法实例化的状态，调用前状态为Nnoe
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port
    #在类当中定义了一个类方法
    @classmethod
    def from_conf(cls):              #-----------------------将该方法装饰成由类来调用的方法，类来调用将类自动传入
        if cls.__instance is None:   #-----------------------判断该类是否是首次调用该方法，是则返回True
            cls.__instance=cls(settings.IP,settings.PORT)          #类从配置文件中读参数，实例化出的实例(实例即调用类产生的对象)
        #成立与否都返回，所以再外部返回，不用使用else，重复返回
        return cls.__instance        #-----------------------当该方法是第一次和不是第一次被类调用，则返回的结果均是cls.__instance
#单例模式多次都用返回得到的是同一个内存地址
obj1=Mysql.from_conf()               #-----------------------类来调用被装饰器装饰的该方法，将类当做第一个参数自动传入
obj2=Mysql.from_conf()               #-----------------------实例化没有传参，直接从配置文件读，每次调用该方法，实例化的结果都一样，所以叫做单例
obj3=Mysql.from_conf()               #单列模式的好处就是不用每次都进行传参
print(obj1)
print(obj2)
print(obj3)
print(obj1.__dict__)                  #{'ip': '0.0.0.1', 'port': 3306}-----从配置文件中类直接调用绑定给类的方法得到的结果

obj4=Mysql('10.10.10.11',3307)        #直接调用类来是实例化，进行传参，对产生的对象进行初始化，可以和调用类的方法从配置文件中读得到形同的结果
print(obj4)
print(obj4.__dict__)                   #{'ip': '10.10.10.11', 'port': 3307}，类直接传参，实例化得到的结果

回到顶部

二、使用装饰器

# 单例模式实现二：
"""自定义一个装饰器，由装饰器来完成单例的过程"""
# 实例化的时候不传参，代表触发单例模式
import settings
'''--------------------------------------------------定义一个装饰器--------------------------------------------'''
def singleton(cls):                                      #定义一个单例模式的函数，把类当做形参
    _instance=cls(settings.IP,settings.PORT)             #也可以方法类中cls. _instance=cls(settings.IP,settings.PORT)
    def wrapper(*args,**kwargs):
        if len(args)==0 and len(kwargs)==0: #Mysql不传参时，直接返回调用类拿到settings中的对象，如果调用类传参了，那么我们就返回类直接调用的产生对象的结果
            return _instance                             #cls._instance
        return cls(*args,**kwargs)                       #直接调用类(进行传参，对产生的随行进行初始化)的返回结果
    return wrapper
'''--------------------------------------------------定义一个装饰器--------------------------------------------'''

@singleton           #Mysql=singleton(Mysql) Mysql=wrapper-----没学类之前我们只学类用装饰器装饰函数，现在用自定义装饰器装饰类
class Mysql:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port


obj1=Mysql()                    #单例模式每次调用类不用为其进行传参，就如同为ATM的一些功能加上登录装饰器一样，每次登录执行这些功能，必须先登录
obj2=Mysql()                    #不传参，每次调用时，就会执行自定义装饰器中的代码，就会从配置文件中读取内容：_instance=cls(settings.IP,settings.PORT)
obj3=Mysql()
print(obj1)                    #<__main__.Mysql object at 0x000002375BAC2E80>
print(obj2)                    #<__main__.Mysql object at 0x000002375BAC2E80>
print(obj3)                    #<__main__.Mysql object at 0x000002375BAC2E80>

obj4=Mysql('0.0.0.3',3308)     #直接传参，经过装饰器时，会直接走：cls(*args,**kwargs) ，直接调用Mysql，对产生的对象obj4:进行初始化__init__(self,ip,port)
print(obj4)                    #<__main__.Mysql object at 0x0000023762ADBF98>

回到顶部

三、使用元类

# 单例模式实现三
"""自定义一个元类，通过元类内的__call__来完成单例的过程"""
# 基于元类不传参，从配置文件中读取相同的配置文件，传参则以自己传参的为准
import settings
class Mymeta(type):
    def __init__(self,class_name,class_basess,class_dic):                 #self=Mysql
        super(Mymeta,self).__init__(class_name,class_basess,class_dic)    #继承元类中的属性
        self.__instance=self.__new__(self)                                #造出Mysql的空对象
        self.__init__(self.__instance,settings.IP,settings.PORT)          #对Mysql的空对象从配置文件中传参进行初始化

    def __call__(self, *args, **kwargs):          #会在调用类这个对象是自动触发
        if len(args)==0 and len(kwargs)==0:       #判断如果不传参时，直接返回我们从配置文件中初始会的对象
            return self.__instance                #返回配置文件中初始化的对象
        # 否则即用户进行传参，而不是从配置文件中读取，那么我们就造一个空对象，然后对空对象那个进行初始化
        obj=self.__new__(self)                    #传参的结果：也是想初始化一个空对象
        self.__init__(obj,*args,**kwargs)         #会原封不动的接收调用类这个对象传进来的参数，完成对调用类产生的空对象的初始化
        return obj                                #将初始化的对象返回
class Mysql(object,metaclass=Mymeta):
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port


obj1=Mysql()            #不传参直接调用类，产生对象，此时的对象，已经从配置文件中读取了配置信息，而非是一个空对象
obj2=Mysql()            #每次调用该类读的是同一个配置文件，得到的对象的内存地址也是一样的
obj3=Mysql()
# 以上三者调用均是没有进行传参，调用类这个对象会触发__call__，会判断如果没有进行传参，则直接调用配置文件拿到返回的结果
print(obj1)             #<__main__.Mysql object at 0x000002659486F2E8>
print(obj2)
print(obj3)

obj4=Mysql('0.0.0.3',3308) #直接为类进行传参，进过判断就不会走配置文件了，而是直接造了一个空对象，然后对其进行初始化
print(obj4)             #<__main__.Mysql object at 0x000002659B88BF98>