python - 基于创建对象时传递的不同参数的 Singleton/Borg 模式

Question

我正在使用 borg 模式在对象之间共享状态:

class Borg:
    __shared_state = {}

    def __init__(self):
        self.__dict__ = self.__shared_state

现在假设我想根据创建对象时传递的参数来创建 Borg 类的基于上下文的对象。这是为多个上下文创建 Borg 模式(状态共享)的正确方法吗？

import random
import cPickle

class Borg:
    __shared_state = { }

    def __init__(self,*args,**kwargs):
        context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
        self.__shared_state.setdefault(context_key, {})
        self.__dict__ = self.__shared_state[context_key]
        print(self.__shared_state)

    def set_random_property(self):
        self.num =  str(random.randint(1,100000))



a = Borg(x='ONE')
a.set_random_property()
b = Borg(x = 'TWO')
b.set_random_property()
c = Borg(x = 'TWO')
print('a with ONE has num:{0}'.format(a.num))
print('b with TWO has num:{0}'.format(b.num))
print('c with TWO has num:{0}'.format(c.num))

输出

{7373348246660160089: {}}
{7373348246660160089: {'num': '18322'}, 3334843421982509183: {}}
{7373348246660160089: {'num': '18322'}, 3334843421982509183: {'num': '33084'}}
a with ONE has num:18322
b with TWO has num:33084
c with TWO has num:33084

工作正常。有没有办法即兴创作这种模式？或者对于 python 2.7 有更好的替代方案吗？

Answer 1

不，你用什么我就用什么；使用共享状态的字典。

您可以通过使用 dict.setdefault() 的返回值稍微简化它，而不是忽略它:

def __init__(self, *args, **kwargs):
    context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
    self.__dict__ = self.__shared_state.setdefault(context_key, {})

所有这些都可以封装在元类型中:

class PerArgsBorgMeta(type):
    def __new__(mcls, name, bases, attrs):
        cls = super(PerArgsBorgMeta, mcls).__new__(mcls, name, bases, attrs)
        setattr(cls, '_{}__shared_state'.format(name), {})
        return cls

    def __call__(cls, *args, **kwargs):
        instance = super(PerArgsBorgMeta, cls).__call__(*args, **kwargs)
        context_key = hash('{0}{1}'.format(cPickle.dumps(args),cPickle.dumps(kwargs)))
        state = getattr(cls, '_{}__shared_state'.format(cls.__name__))
        instance.__dict__ = state.setdefault(context_key, {})
        return instance

然后将其用作类的 __metaclass__ 属性:

class SomeBorgClass:
    __metaclass__ = PerArgsBorgMeta

请注意，使用 hash(cPickle.dumps(kwargs)) 仍将为存在冲突的字典创建不同的哈希值:

>>> import cPickle
>>> hash(cPickle.dumps({'a': 42, 'i': 81}))
-7392919546006502834
>>> hash(cPickle.dumps({'i': 81, 'a': 42}))
2932616521978949826

这同样适用于集合。排序(如果必须详尽，则递归排序)可以在这里提供帮助，但要小心，不要在作为值传入的集合与使用的具有相同值的元组之间产生误报。对于其中每一个，都有越来越复杂的解决方法，但在某些时候，您只需要接受限制，而不是使哈希代码更加复杂。