monostate 状态_python设计模型-单例模式

cls：类对象

self：实例对象

单例 Singleton: 类只提供一个实例对象修改_init_

class Singleton(object):

def __new__(cls): #负责创造对象实例

if not hasattr(cls, 'instance'):

cls.instance = super(Singleton, cls).__new__(cls)

return cls.instance

s1 = Singleton()

s2 = Singleton()

s1 is s2

#True

2.通过元类的方法

一切皆对象，int的类型的类型是type.

类的定义由它的元类决定。

类A的创建： A = type(name,bases,dict)

name: 类名

bases: 基类名

dict: 属性变量

class MetaSingleton(type):

_instances ={}

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

if cls not in cls._instances:

cls._instances[cls] = super(MetaSingleton,\

cls).__call__(*args,**kwargs)

return cls._instances[cls]

l1 = Logger()

l2 = Logger()

l1 is l2 # True

单态 Monostate：所有实例对象共享相同状态.__dict__ : 存储类的传统通过__init__方法

class Borg:

__shared_state = {"a":1}#类成员,类的__dict__中

def __init__(self):

self.b =2

self.__dict__ = self.__shared_state

self.c = 3#实例

Borg.__dict__

mappingproxy({'__module__': '__main__',

'_Borg__shared_state': {'a': 1},

'__init__': ,

'__dict__': ,

'__weakref__': ,

'__doc__': None})

b1 = Borg()

b1.__dict__

{'a': 1, 'c': 3}

Borg.__dict__

mappingproxy({'__module__': '__main__',

'_Borg__shared_state': {'a': 1, 'c': 3},

'__init__': ,

'__dict__': ,

'__weakref__': ,

'__doc__': None})

b2 = Borg()

b1 is b2 #False

b2.d =5

b1.__dict__

{'a': 1, 'c': 3, 'd': 5}

2. 通过 __new__方法

class Borg:

_shared_state = {}

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

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

obj.__dict__ = cls._shared_state

return obj

b1 = Borg()

b2 = Borg()

b1.a =1

b2.a # 1