将“ self”更改为同一对象的另一个实例？

Question

我想创建一个类，并且所有对象都需要具有唯一的标识符key ，并且如果我尝试使用先前存在的键创建该对象的新实例，则该实例应与已存在的实例相同。

与单例类相似，但是在这种情况下，不是一个类，有很多但有所不同。

我的第一个方法是

class Master:
    existent = {}
    def __init__(self, key, value=None):
        try:
            self = Master.existent[key]
            return 
        except KeyError:
            Master.existent[key] = self
        # Rest of the __init__ method

但是当我比较两个对象时，例如A = Master('A', 0)和B = Master('B', 0) ， B不共享它应该具有的任何属性，如果Master类有任何_method （单个下划线），它也不会出现。

知道我该怎么做吗？

我认为这与“工厂方法模式”相似，但是我仍然很难找到相似之处或如何以优雅的形式实现。

编辑：

该类基本上有两个专有属性，仅此而已，但是很多事情都将I​​nherit和/或包含此实例作为类型，我认为我可以做到的简单方法是从与所述key对应的现有实例中提取属性，并为其分配属性从事实，他们将有相同的新实例和滥用hash输出和在equal运营商将根据校验值，这样我可以使用的行为==并且is没有问题的运营商。

这个想法解决了我的问题，但总的来说，我认为这可能是一个常见或有趣的场景，可以解决。

Answer 1

我认为您不能使用__init__()方法来执行此操作，因为调用该方法时已经创建了该类的新实例。 您可能需要创建一个工厂类型的方法，例如：

class Master:
    existent = {}
    init_OK = False

    def __init__(self, key, value=None):
        if not Master.init_OK:
            raise Exception('Direct call to Master() is not allowed')
        Master.init_OK = False
        self.key = key
        self.value = value
        Master.existent[key] = self

    @staticmethod
    def make(key, value=None):
        try:
            inst = Master.existent[key]
        except:
            Master.init_OK = True
            inst = Master(key, value=value)
        return inst

Answer 2

您可以使用__new__方法进行处理。 除非要创建具有新键的新对象，否则不要调用__init__ ，并且可以在调用__init__之前先使用__new__来检查键是否唯一。

class Master(object):

    instances = {}
    def __new__(cls, key, value=None):
        if key in Master.instances:
            return Master.instances[key]
        else:
            instance = super(Master, cls).__new__(cls)
            Master.instances[key] = instance
            return instance

    def __init__(self, key, value=None):
        self.value = value

然后您可以使用创建对象

>>> A = Master('A',0)
>>> B = Master('B',0)
>>> C = Master('A',1)

由于A和C具有相同的密钥，因此它们将指向同一对象，并且实际上将是同一实例。 由于C与A具有相同的密钥，因此它会更新其值。

>>> print(A.value)
1

对A任何新更改都将在C看到，反之亦然。

>>> A.value = 5
>>> print(C.value)
5

但是，改变A和C不会影响B ，和改变B不会影响A或C 。

编辑：

如果要复制值而不是实例，则可以将值存储在Master.instances词典中，然后检查键是否已经有值。

class Master(object):

    instances = {}
    def __init__(self, key, value=None):
        if key in Master.instances:
            self.value = Master.instances[key]
        else:
            self.value = value
            Master.instances[key] = value

>>> A = Master('A',0)
>>> C = Master('A',1)
>>> print(C.value)
0

Answer 3

受A Kruger回答的启发，我有另一个建议的解决方案，它以__new__方法的使用为__new__ 。 该答案的主要区别在于无需创建内部__Master类。 调用Master()时会自动调用__new__方法，并且该方法应返回Master类的实例。 在我的回答中， __new__方法返回一个新实例（如果需要），但如果可能的话，从existent字典中返回一个实例。 请注意，用户照常访问Master类，即，他们仅调用Master('A', 0) 。 通过使Master类扩展object成为可能。

这是代码：

class Master(object):
    existent = {}

    def __init__(self, key, value=None):
        self.key = key
        self.value = value
        if not key in Master.existent:
            Master.existent[key] = self

    def __new__(cls, *args, **kwargs):
        key = args[0]
        if key in Master.existent:
            return Master.existent[key]
        else:
            return super(Master, cls).__new__(cls)

    def __str__(self):
        return('id: ' + str(id(self)) + ', key=' + str(self.key) + ', value=' + str(self.value))

A = Master('A', 0)
print('A = ' + str(A))
B = Master('A', 1)
print('\nAfter B created:')
print('B = ' + str(B))
print('A = ' + str(A))
B.value = 99
print('\nAfter B modified:')
print('B = ' + str(B))
print('A = ' + str(A))
C = Master('C', 3)
print('\nC = ' + str(C))

这是输出：

A = id: 140023450750200, key=A, value=0

After B created:
B = id: 140023450750200, key=A, value=1
A = id: 140023450750200, key=A, value=1

After B modified:
B = id: 140023450750200, key=A, value=99
A = id: 140023450750200, key=A, value=99

C = id: 140023450750256, key=C, value=3

请注意， A和B具有相同的id （它们是相同的对象）。 还要注意，对A或B更改会相互影响，因为它们是同一对象。