Python的6种方式实现单例模式

发布时间:2022-03-22 09:46:35 人气:34 作者:多测师

  单例模式是一个软件的设计模式,为了保证一个类,无论调用多少次产生的实例对象,都是指向同一个内存地址,仅仅只有一个实例(只有一个对象)。

  实现单例模式的手段有很多种,但总的原则是保证一个类只要实例化一个对象,下一次再实例的时候就直接返回这个对象,不再做实例化的操作。所以这里面的关键一点就是,如何判断这个类是否实例化过一个对象 。

  这里介绍两类方式:

  一类是通过模块导入 的方式;

  一类是通过魔法方法 判断的方式;

  # 基本原理:

  - 第一类通过模块导入的方式,借用了模块导入时的底层原理实现。

  - 当一个模块(py文件)被导入时,首先会执行这个模块的代码,然后将这个模块的名称空间加载到内存。

  - 当这个模块第二次再被导入时,不会再执行该文件,而是直接在内存中找。

  - 于是,如果第一次导入模块,执行文件源代码时实例化了一个类,那再次导入的时候,就不会再实例化。

  - 第二类主要是基于类和元类实现,在'对象'的魔法方法中判断是否已经实例化过一个对象

  - 这类方式,根据实现的手法不同,又分为不同的方法,如:

  - 通过类的绑定方法;通过元类;通过类下的__new__;通过装饰器(函数装饰器,类装饰器)实现等。

  下面分别介绍这几种不同的实现方式,仅供参考实现思路,不做具体需求。

  通过模块导入

  # cls_singleton.py

  class Foo(object):

  pass

  instance = Foo()

  # test.py

  import cls_singleton

  obj1 = cls_singleton.instance

  obj2 = cls_singleton.instance

  print(obj1 is obj2)

  # 原理:模块第二次导入从内存找的机制

  通过类的绑定方法

  class Student:

  _instance = None# 记录实例化对象

  def __init__(self, name, age):

  self.name = name

  self.age = age

  @classmethod

  def get_singleton(cls, *args, **kwargs):

  if not cls._instance:

  cls._instance = cls(*args, **kwargs)

  return cls._instance

  stu1 = Student.get_singleton('jack', 18)

  stu2 = Student.get_singleton('jack', 18)

  print(stu1 is stu2)

  print(stu1.__dict__, stu2.__dict__)

  # 原理:类的绑定方法是第二种实例化对象的方式,

  # 第一次实例化的对象保存成类的数据属性 _instance,

  # 第二次再实例化时,在get_singleton中判断已经有了实例对象,直接返回类的数据属性 _instance

  通过魔法方法__new__

  class Student:

  _instance = None

  def __init__(self, name, age):

  self.name = name

  self.age = age

  def __new__(cls, *args, **kwargs):

  # if cls._instance:

  # return cls._instance# 有实例则直接返回

  # else:

  # cls._instance = super().__new__(cls)# 没有实例则new一个并保存

  # return cls._instance# 这个返回是给是给init,再实例化一次,也没有关系

  if not cls._instance:# 这是简化的写法,上面注释的写法更容易提现判断思路

  cls._instance = super().__new__(cls)

  return cls._instance

  stu1 = Student('jack', 18)

  stu2 = Student('jack', 18)

  print(stu1 is stu2)

  print(stu1.__dict__, stu2.__dict__)

  # 原理:和方法2类似,将判断的实现方式,从类的绑定方法中转移到类的__new__中

  # 归根结底都是 判断类有没有实例,有则直接返回,无则实例化并保存到_instance中。

Python的6种方式实现单例模式

  通过元类

  class Mymeta(type):

  def __init__(cls, name, bases, dic):

  super().__init__(name, bases, dic)

  cls._instance = None# 将记录类的实例对象的数据属性放在元类中自动定义了

  def __call__(cls, *args, **kwargs):# 此call会在类被调用(即实例化时触发)

  if cls._instance:# 判断类有没有实例化对象

  return cls._instance

  else:# 没有实例化对象时,控制类造空对象并初始化

  obj = cls.__new__(cls, *args, **kwargs)

  obj.__init__(*args, **kwargs)

  cls._instance = obj# 保存对象,下一次再实例化可以直接返回而不用再造对象

  return obj

  class Student(metaclass=Mymeta):

  def __init__(self, name, age):

  self.name = name

  self.age = age

  stu1 = Student('jack', 18)

  stu2 = Student('jack', 18)

  print(stu1 is stu2)

  print(stu1.__dict__, stu2.__dict__)

  # 原理:类定义时会调用元类下的__init__,类调用(实例化对象)时会触发元类下的__call__方法

  # 类定义时,给类新增一个空的数据属性,

  # 第一次实例化时,实例化之后就将这个对象赋值给类的数据属性;第二次再实例化时,直接返回类的这个数据属性

  # 和方式3的不同之处1:类的这个数据属性是放在元类中自动定义的,而不是在类中显示的定义的。

  # 和方式3的不同之处2:类调用时触发元类__call__方法判断是否有实例化对象,而不是在类的绑定方法中判断

  函数装饰器

  def singleton(cls):

  _instance_dict = {}# 采用字典,可以装饰多个类,控制多个类实现单例模式

  def inner(*args, **kwargs):

  if cls not in _instance_dict:

  _instance_dict[cls] = cls(*args, **kwargs)

  return _instance_dict.get(cls)

  return inner

  @singleton

  class Student:

  def __init__(self, name, age):

  self.name = name

  self.age = age

  # def __new__(cls, *args, **kwargs):# 将方法3的这部分代码搬到了函数装饰器中

  # if not cls._instance:

  # cls._instance = super().__new__(cls)

  # return cls._instan

  stu1 = Student('jack', 18)

  stu2 = Student('jack', 18)

  print(stu1 is stu2)

  print(stu1.__dict__, stu2.__dict__)

  类装饰器

  class SingleTon:

  _instance_dict = {}

  def __init__(self, cls_name):

  self.cls_name = cls_name

  def __call__(self, *args, **kwargs):

  if self.cls_name not in SingleTon._instance_dict:

  SingleTon._instance_dict[self.cls_name] = self.cls_name(*args, **kwargs)

  return SingleTon._instance_dict.get(self.cls_name)

  @SingleTon# 这个语法糖相当于Student = SingleTon(Student),即Student是SingleTon的实例对象

  class Student:

  def __init__(self, name, age):

  self.name = name

  self.age = age

  stu1 = Student('jack', 18)

  stu2 = Student('jack', 18)

  print(stu1 is stu2)

  print(stu1.__dict__, stu2.__dict__)

  # 原理:在函数装饰器的思路上,将装饰器封装成类。

  # 程序执行到与语法糖时,会实例化一个Student对象,这个对象是SingleTon的对象。

  # 后面使用的Student本质上使用的是SingleTon的对象。

  # 所以使用Student('jack', 18)来实例化对象,其实是在调用SingleTon的对象,会触发其__call__的执行

  # 所以就在__call__中,判断Student类有没有实例对象了。

  以上内容为大家介绍了Python的6种方式实现单例模式,希望对大家有所帮助,如果想要了解更多Python相关知识,请关注多测师。https://www.e70w.com/xwzx/

返回列表
在线客服
联系方式

热线电话

17727591462

上班时间

周一到周五

二维码
线