將“ 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更改會相互影響，因為它們是同一對象。