五种单例模式----来自脚本之家

本文为大家分享了Python创建单例模式的5种常用方法,供大家参考,具体内容如下

所谓单例,是指一个类的实例从始至终只能被创建一次。

方法1:

如果想使得某个类从始至终最多只有一个实例,使用__new__方法会很简单。Python中类是通过__new__来创建实例的:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

class Singleton(object):

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

    if not hasattr(cls,‘_inst‘):

      cls._inst=super(Singleton,cls).__new__(cls,*args,**kwargs)

    return cls._inst

if __name__==‘__main__‘:

  class A(Singleton):

    def __init__(self,s):

      self.s=s  

  a=A(‘apple‘

  b=A(‘banana‘)

  print id(a),a.s

  print id(b),b.s

结果:

29922256 banana

29922256 banana

通过__new__方法,将类的实例在创建的时候绑定到类属性_inst上。如果cls._inst为None,说明类还未实例化,实例化并将实例绑定到cls._inst,以后每次实例化的时候都返回第一次实例化创建的实例。注意从Singleton派生子类的时候,不要重载__new__。

方法2:

有时候我们并不关心生成的实例是否具有同一id,而只关心其状态和行为方式。我们可以允许许多个实例被创建,但所有的实例都共享状态和行为方式:

?


1

2

3

4

5

6

class Borg(object):

  _shared_state={}

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

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

    obj.__dict__=cls._shared_state

    return obj

将所有实例的__dict__指向同一个字典,这样实例就共享相同的方法和属性。对任何实例的名字属性的设置,无论是在__init__中修改还是直接修改,所有的实例都会受到影响。不过实例的id是不同的。要保证类实例能共享属性,但不和子类共享,注意使用cls._shared_state,而不是Borg._shared_state。

因为实例是不同的id,所以每个实例都可以做字典的key:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

if __name__==‘__main__‘:

  class Example(Borg):

    pass

  a=Example()

  b=Example()

  c=Example()

  adict={}

  j=0

  for i in a,b,c:

    adict[i]=j

    j+=1

  for i in a,b,c:

    print adict[i]

结果:

0

1

2

如果这种行为不是你想要的,可以为Borg类添加__eq__和__hash__方法,使其更接近于单例模式的行为:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

class Borg(object):

  _shared_state={}

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

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

    obj.__dict__=cls._shared_state

    return obj

  def __hash__(self):

    return 1

  def __eq__(self,other):

    try:

      return self.__dict__ is other.__dict__

    except:

      return False

if __name__==‘__main__‘:

  class Example(Borg):

    pass

  a=Example()

  b=Example()

  c=Example()

  adict={}

  j=0

  for i in a,b,c:

    adict[i]=j

    j+=1

  for i in a,b,c:

    print adict[i]

结果:

2

2

2

所有的实例都能当一个key使用了。

方法3

当你编写一个类的时候,某种机制会使用类名字,基类元组,类字典来创建一个类对象。新型类中这种机制默认为type,而且这种机制是可编程的,称为元类__metaclass__ 。

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

class Singleton(type):

  def __init__(self,name,bases,class_dict):

    super(Singleton,self).__init__(name,bases,class_dict)

    self._instance=None

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

    if self._instance is None:

      self._instance=super(Singleton,self).__call__(*args,**kwargs)

    return self._instance

if __name__==‘__main__‘:

  class A(object):

    __metaclass__=Singleton   

  a=A()

  b=A()

  print id(a),id(b)

结果:

34248016 34248016

id是相同的。

例子中我们构造了一个Singleton元类,并使用__call__方法使其能够模拟函数的行为。构造类A时,将其元类设为Singleton,那么创建类对象A时,行为发生如下:

A=Singleton(name,bases,class_dict),A其实为Singleton类的一个实例。

创建A的实例时,A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict).__call__(),这样就将A的所有实例都指向了A的属性_instance上,这种方法与方法1其实是相同的。

 方法4

python中的模块module在程序中只被加载一次,本身就是单例的。可以直接写一个模块,将你需要的方法和属性,写在模块中当做函数和模块作用域的全局变量即可,根本不需要写类。

而且还有一些综合模块和类的优点的方法:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

class _singleton(object):

  class ConstError(TypeError):

    pass

  def __setattr__(self,name,value):

    if name in self.__dict__:

      raise self.ConstError

    self.__dict__[name]=value

  def __delattr__(self,name):

    if name in self.__dict__:

      raise self.ConstError

    raise NameError

import sys

sys.modules[__name__]=_singleton()

python并不会对sys.modules进行检查以确保他们是模块对象,我们利用这一点将模块绑定向一个类对象,而且以后都会绑定向同一个对象了。

将代码存放在single.py中:

?


1

2

3

>>> import single

>>> single.a=1

>>> single.a=2

ConstError

>>> del single.a

ConstError

方法5:

最简单的方法:

?


1

2

3

class singleton(object):

  pass

singleton=singleton()

将名字singleton绑定到实例上,singleton就是它自己类的唯一对象了。

以上就是Python单例模式的实现方式详细介绍,希望对大家的学习有所帮助。

原文地址:https://www.cnblogs.com/xiesibo/p/8449676.html

时间: 2024-10-09 22:53:05

五种单例模式----来自脚本之家的相关文章

五种单例模式

今天算是完完整整把老高的单例模式看了,差不多也懂了,个别不懂的再补吧,下面介绍一下5种单例模式: 饿汉式实现:线程安全,调用效率高.但是,不能延时加载. 懒汉式实现:线程安全,调用效率不高.但是,可以延时加载. 双重检测锁式:由于JVM底层内部模型原因,偶尔会出现问题,不建议使用. 静态内部类式:线程安全,调用效率高,可以延时加载. 枚举式:线程安全,调用效率高.但是,不能延时加载(避免反射和反序列化的漏洞). 以下先介绍一下5种单例模式: 饿汉式实现: /** *单例模式:饿汉模式 *线程安全

Java中的五种单例模式实现方法

[代码] Java中的五种单例模式实现方法 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 package s

五种单例模式实现

核心作用: 保证一个类只有一个实例,并向外提供一个访问该实例的访问点. 常见场景: 数据库连接池的设计一般也是单例模式 在Servlet编程中,每个Servlet也是单例模式 在Spring中,默认创建的bean也是单例模式 ...... 优点: 1.由于每个类只创建一个实例,大大减少了内存的开销. 2.单例模式提供全局访问点,可以实现共享资源访问. 常见的五种单例模式实现方法: 饿汉式(线程安全,效率高,不能延迟加载) 懒汉式(线程安全,效率不高,可以延迟加载) DCL懒汉式(线程安全,效率还

快速理解Java中的五种单例模式

解法一:只适合单线程环境(不好) package test; /** * @author xiaoping * */ public class Singleton { private static Singleton instance=null; private Singleton(){ } public static Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance;

详细讲述MySQL中的子查询操作 (来自脚本之家)

继续做以下的前期准备工作: 新建一个测试数据库TestDB: ? 1 create database TestDB; 创建测试表table1和table2: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 CREATE TABLE table1 (   customer_id VARCHAR(10) NOT NULL,   city VARCHAR(10) NOT NULL,   PRIMARY KEY(customer_id) )ENGINE=INNODB DEFAULT CH

常见的五种单例模式实现方式

--主要: 饿汉式(线程安全,调用效率高,但是不能延时加载) 懒汉式(线程安全,调用效率低,但是可以延时加载) --其他: 双重检测锁式(由于JVM底层内部模型原因,偶尔会出现问题,不建议使用) 静态内部类式(线程安全,调用效率高,可以延时加载) 枚举式(线程安全,调用效率高,不能延时加载) -- 如何选用? 单例对象   占用   资源 少,不需要   延时加载:  枚举式   好于  饿汉式 单例对象   占用   资源 大, 需要   延时加载:   静态内部类式   好于   懒汉式 引

用python执行 js代码__来自脚本之家

安装依赖 首先安装依赖:Boost, 这一步网上的大部分教程都差不多,也是必须的; 1 2 3 sudo apt-get install scons sudo apt-get install libboost-dev libboost-thread-dev sudo apt-get install libboost-system-dev libboost-python-dev 安装PyV8 网上的大部分教程均是使用svncheckout出V8,PyV8的代码,然后再设置什么V8的目录为V8_HO

C# 单例模式的五种写法

C# 单例模式的五种写法及优劣分析,见下文: [单例模式及常见写法](http://blog.csdn.net/jiankunking/article/details/50867050)

单例模式的五种写法

首先来明确一个问题,那就是在某些情况下,有些对象,我们只需要一个就可以了,比如,一台计算机上可以连好几个打印机,但是这个计算机上的打印程序只能有一个,这里就可以通过单例模式来避免两个打印作业同时输出到打印机中,即在整个的打印过程中我只有一个打印程序的实例. 简单说来,单例模式(也叫单件模式)的作用就是保证在整个应用程序的生命周期中, 任何一个时刻,单例类的实例都只存在一个(当然也可以不存在). package singleton; /** * @author lei * 单例模式的五种写法: *