现在我又遇到了同样的问题，出于某些原因，我决定避免使用装饰器、工厂和元类。我是这样做的:

主文件

def _alt(func):
    import functools
    @functools.wraps(func)
    def init(self, *p, **k):
        if hasattr(self, "parent_initialized"):
            return
        else:
            self.parent_initialized = True
            func(self, *p, **k)

    return init


class Parent:
    # Empty dictionary, shouldn't ever be filled with anything else
    parent_cache = {}

    def __new__(cls, n, *args, **kwargs):

        # Checks if object with this ID (n) has been created
        if n in cls.parent_cache:

            # It was, return it
            return cls.parent_cache[n]

        else:

            # Check if it was modified by this function
            if not hasattr(cls, "parent_modified"):
                # Add the attribute
                cls.parent_modified = True
                cls.parent_cache = {}

                # Apply it
                cls.__init__ = _alt(cls.__init__)

            # Get the instance
            obj = super().__new__(cls)

            # Push it to cache
            cls.parent_cache[n] = obj

            # Return it
            return obj

示例类

class A(Parent):

    def __init__(self, n):
        print("A.__init__", n)


class B(Parent):

    def __init__(self, n):
        print("B.__init__", n)

在使用

>>> A(1)
A.__init__ 1  # First A(1) initialized 
<__main__.A object at 0x000001A73A4A2E48>
>>> A(1)      # Returned previous A(1)
<__main__.A object at 0x000001A73A4A2E48>
>>> A(2)
A.__init__ 2  # First A(2) initialized
<__main__.A object at 0x000001A7395D9C88>
>>> B(2)
B.__init__ 2  # B class doesn't collide with A, thanks to separate cache
<__main__.B object at 0x000001A73951B080>

警告:你不应该初始化父类，它会与其他类冲突——除非你在每个子类中定义了单独的缓存，这不是我们想要的。 警告:以Parent为祖父母的类似乎行为怪异。(未经证实的)

在网上试试!

在大多数知名的OO语言中，像SomeClass(arg1, arg2)这样的表达式将分配一个新实例，初始化实例的属性，然后返回该实例。

在大多数知名的OO语言中，“初始化实例的属性”部分可以通过定义构造函数来为每个类定制，构造函数基本上就是在新实例上操作的代码块(使用提供给构造函数表达式的参数)，以设置所需的任何初始条件。在Python中，这对应于类的__init__方法。

Python的__new__就是类似的“分配新实例”部分的每个类自定义。当然，这允许您做一些不寻常的事情，比如返回一个现有的实例，而不是分配一个新实例。所以在Python中，我们不应该认为这部分涉及到分配;我们所需要的只是__new__从某个地方提供一个合适的实例。

但这仍然只是工作的一半，Python系统无法知道有时你想在之后运行工作的另一半(__init__)，有时你不想。如果你想要这种行为，你必须明确地说出来。

通常，你可以重构，这样你只需要__new__，或者你不需要__new__，或者让__init__在一个已经初始化的对象上表现不同。但如果你真的想这样做，Python实际上允许你重新定义“作业”，这样SomeClass(arg1, arg2)就不一定会调用__new__后跟__init__。要做到这一点，你需要创建一个元类，并定义它的__call__方法。

A metaclass is just the class of a class. And a class' __call__ method controls what happens when you call instances of the class. So a metaclass' __call__ method controls what happens when you call a class; i.e. it allows you to redefine the instance-creation mechanism from start to finish. This is the level at which you can most elegantly implement a completely non-standard instance creation process such as the singleton pattern. In fact, with less than 10 lines of code you can implement a Singleton metaclass that then doesn't even require you to futz with __new__ at all, and can turn any otherwise-normal class into a singleton by simply adding __metaclass__ = Singleton!

class Singleton(type):
    def __init__(self, *args, **kwargs):
        super(Singleton, self).__init__(*args, **kwargs)
        self.__instance = None
    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            self.__instance = super(Singleton, self).__call__(*args, **kwargs)
        return self.__instance

然而，这可能比在这种情况下真正被保证的更深层的魔法!

我认为这个问题的简单答案是，如果__new__返回一个与类类型相同的值，__init__函数将执行，否则它不会执行。在这种情况下，您的代码返回A._dict('key')，它与cls是同一个类，因此将执行__init__。

__new__是静态类方法，而__init__是实例方法。 __new__必须先创建实例，所以__init__可以初始化它。注意，__init__以self作为参数。在你创造实例之前，没有自我。

现在，我猜想，您正在尝试用Python实现单例模式。有几种方法可以做到这一点。

此外，从Python 2.6开始，您可以使用类装饰器。

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
  ...

One should look at __init__ as a simple constructor in traditional OO languages. For example, if you are familiar with Java or C++, the constructor is passed a pointer to its own instance implicitly. In the case of Java, it is the this variable. If one were to inspect the byte code generated for Java, one would notice two calls. The first call is to an "new" method, and then next call is to the init method (which is the actual call to the user defined constructor). This two step process enables creation of the actual instance before calling the constructor method of the class which is just another method of that instance.

现在，在Python中，__new__是一个用户可以访问的附加功能。由于Java的类型化特性，它没有提供这种灵活性。如果一种语言提供了这种功能，那么__new__的实现者可以在返回实例之前在该方法中做很多事情，包括在某些情况下为不相关的对象创建一个全新的实例。而且，这种方法也适用于Python中的不可变类型。

@AntonyHatchkins回答的更新，您可能需要为元类型的每个类创建一个单独的实例字典，这意味着您应该在元类中使用__init__方法来使用该字典初始化类对象，而不是使它在所有类中都是全局的。

class MetaQuasiSingleton(type):
    def __init__(cls, name, bases, attibutes):
        cls._dict = {}

    def __call__(cls, key):
        if key in cls._dict:
            print('EXISTS')
            instance = cls._dict[key]
        else:
            print('NEW')
            instance = super().__call__(key)
            cls._dict[key] = instance
        return instance

class A(metaclass=MetaQuasiSingleton):
    def __init__(self, key):
        print 'INIT'
        self.key = key
        print()

我已经继续使用__init__方法更新了原始代码，并将语法更改为Python 3符号(在类参数中无参数调用super和元类，而不是作为属性)。

无论哪种方式，这里的重点是，如果找到键，您的类初始化器(__call__方法)将不会执行__new__或__init__。这比使用__new__干净得多，如果你想跳过默认的__init__步骤，则需要标记对象。