某些属性唯一的Python类实例

Question

Suppose I want to create instances of my class freely, but if I instantiate with the same argument, I want to get the same unique instance representing that argument. For example:

a = MyClass('Instance 1');
b = MyClass('Instance 2');
c = MyClass('Instance 1');

I would want a == c to be True , based on the unique identifier I passed in.

Note:

(1) I'm not talking about manipulating the equality operator-- I want a to really be the same instance as c .

(2) This is intended as library code, so uniqueness has to be enforced -- we can't just count on users doing the right thing (whatever that is).

Is there a canonical way of achieving this? I run into this pattern all the time, but I usually see solutions involving shadow classes, meant for only internal instantiation. I think I have a cleaner solution, but it does involve a get() method, and I'm wondering if I can do better.

Answer 1

I'd use a metaclass. This solution avoids calling __init__() too many times:

class CachedInstance(type):
    _instances = {}
    def __call__(cls, *args):
        index = cls, args
        if index not in cls._instances:
            cls._instances[index] = super(CachedInstance, cls).__call__(*args)
        return cls._instances[index]

class MyClass(metaclass=CachedInstance):
    def __init__(self, name):
        self.name = name

a = MyClass('Instance 1');
b = MyClass('Instance 2');
c = MyClass('Instance 1');
assert a is c
assert a is not b

Reference and detailed explanation: https://stackoverflow.com/a/6798042/8747

Answer 2

This can be done (assuming that args are all hashable)

 class MyClass:

     instances = {}

     def __new__(cls, *args):
          if args in cls.instances:
               return cls.instances[args]
          self = super().__new__(cls)
          cls.instances[args] = self
          return self

a = MyClass('hello')
b = MyClass('hello')
c = MyClass('world')

a is b and a == b and a is not c and a != c  # True

---

is is the python operator that shows two objects are the same instance. == falls back to is on objects where it is not overidden.

---

As pointed out in the comments, this can be a bit troubling if you have an __init__ with side effects. Here's an implementation that avoids that:

class Coord:

     num_unique_instances = 0
     _instances = {}

     def __new__(cls, x, y):

         if (x, y) in cls._instances:
              return cls._instances[x, y]

         self = super().__new__(cls)

         # __init__ logic goes here  -- will only run once
         self.x = x
         self.y = y
         cls.num_unique_instances += 1
         # __init__ logic ends here

         cls._instances[x, y] = self
         return self

     # no __init__ method