如何将字典的值设置为对另一个字典的值的引用？

Question

对于我正在制作的游戏，我想创建一个对象，该对象的属性可以设置为另一个对象的属性（例如，door.locked = lock.locked）。 当我更新第二个对象的属性（在本例中为lock ）时，第一个对象（ door ）的相应属性也应更新。 这样，解锁锁也将解锁门。 我目前使用字典来实现此功能，如下所示：

class Lock():
    def __init___(self, locked = True):
        self.attributes = {'locked': locked}

    def toggleLock():
        self.attributes.update({'locked': not self.attributes['locked']})

class Door():
    def __init__(self, locked = False):
        self.attributes = {'locked': locked}

然后，我应该能够做到这一点：

>>>lock1 = Lock(locked = True)
>>>door1 = Door(locked = lock1.attributes['locked'])
>>>
>>>lock1.attributes['locked']
True
>>>door1.attributes['locked']
True
>>>
>>>lock1.toggleLock()
>>>lock1.attributes['locked']
False
>>>door1.attributes['locked']
False

但是，当我调用toggleLock()方法时，锁的状态会更改，而门的状态不会更改。 字典是可变的，所以在lock1的情况下door1的字典不应该更新吗？
我将如何实施它以使其起作用？

Answer 1

在您的代码中，您实际上并没有共享同一本字典，而是在Door的构造函数中创建了一个新字典，请尝试执行以下操作：

class Door():
    def __init__(self, attributes):
        self.attributes = attributes

然后这样称呼它：

>>>lock1 = Lock(locked = True)
>>>door1 = Door(lock1.attributes)

编辑：

如果您想拥有不同的字典并且仅共享值，那么您可能希望将值包装在一个类中，然后共享它的一个实例：

class SharedValue(object):
    def __init__(self, val):
        self.value = val

class Lock():
    def __init___(self, locked = True):
        self.attributes = {'locked': SharedValue(locked)}

    def toggleLock():
        self.attributes['locked'].value = not self.attributes['locked'].value

class Door():
    def __init__(self, locked = False):
        if not isinstance(locked, SharedValue):
            locked = SharedValue(locked)
        self.attributes = {'locked': locked}

然后您可以根据需要创建它，但是使用该值的代码必须更改

>>>lock1 = Lock(locked = True)
>>>door1 = Door(locked = lock1.attributes['locked'])
>>>
>>>lock1.attributes['locked'].value
True
>>>door1.attributes['locked'].value
True

顺便说一句，在特定情况下，您亲自提交给我，我将使Lock成为Door的成员，并通过@property共享属性，并使getter尝试从self.attributes ，如果它不包含密钥，请从self.lock.attribute

EDIT2：

添加不同解决方案的示例：

class Lock():
    def __init__(self, locked = True):
        self.attributes = {'locked': locked}

    def toggleLock(self):
        self.attributes.update({'locked': not self.attributes['locked']})

class Door():
    def __init__(self, lock_object):
        self._attributes = {'color':'Blue'}
        self.lock = lock_object

    def get_attribute(self,key):
        if key in self._attributes:
            return self._attributes[key]
        elif key in self.lock.attributes:
            return self.lock.attributes[key]
        raise KeyError(key)

    @property
    def attributes(self):
        """
        Door's attributes
        """
        # return a new dict that contains the keys of itself, and lock (and possibly more objects)
        a = {}
        a.update(self.lock.attributes)
        a.update(self._attributes)
        return a 

    def __getattr__(self, key):
        #nice addition, makes you able to do things like `if Door.locked:`
        return self.get_attribute(key)

用法示例：

>>>l=Lock()
>>>d=Door(l)
>>>d.locked
True
>>>l.toggleLock()
>>>d.locked
False
>>>d.attributes
{'color': 'Blue', 'locked': False}

Answer 2

做到这一点的一种可能方法（至少是我喜欢的方法）是定义一个Singleton 。 请注意，这对python 2.x有效，我不知道它是否在python 3.x中有效

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args)  # , **kwargs
        return cls._instances[cls]

然后将其元类化为您的锁类

class Lock():
    __metaclass__ = Singleton

    def __init___(self, locked = True):
        self.attributes = {'locked': locked}

    def toggleLock():
        self.attributes.update({'locked': not self.attributes['locked']})

简单来说， Singleton仅允许您创建该对象的一个​​实例。 第一次调用将创建一个新对象，之后的调用将不会创建一个新对象，但会返回您通过第一次调用创建的旧对象。

door_1_status = Lock()  # will create a Lock object
door_2_status = Lock()  # will not crate a new Lock, but return the already created Lock object.

因此，从Lock类创建的所有锁都将共享同一对象，从而具有相同的状态。