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

主文件

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__随后在返回的对象上运行。也就是说，你不能使用__new__来阻止__init__被运行。即使你从__new__返回之前创建的对象，它也会被__init__一次又一次地初始化。

下面是单例模式的通用方法，它扩展了上面的vartec答案并修复了它:

def SingletonClass(cls):
    class Single(cls):
        __doc__ = cls.__doc__
        _initialized = False
        _instance = None

        def __new__(cls, *args, **kwargs):
            if not cls._instance:
                cls._instance = super(Single, cls).__new__(cls, *args, **kwargs)
            return cls._instance

        def __init__(self, *args, **kwargs):
            if self._initialized:
                return
            super(Single, self).__init__(*args, **kwargs)
            self.__class__._initialized = True  # Its crucial to set this variable on the class!
    return Single

完整的故事在这里。

另一种方法，实际上涉及__new__，是使用类方法:

class Singleton(object):
    __initialized = False

    def __new__(cls, *args, **kwargs):
        if not cls.__initialized:
            cls.__init__(*args, **kwargs)
            cls.__initialized = True
        return cls


class MyClass(Singleton):
    @classmethod
    def __init__(cls, x, y):
        print "init is here"

    @classmethod
    def do(cls):
        print "doing stuff"

请注意，使用这种方法，你需要用@classmethod装饰你的所有方法，因为你永远不会使用MyClass的任何真实实例。

当实例化一个类时，首先调用__new__()来创建类的实例，然后调用__init__()来初始化实例。

__new__ ():

调用它来创建类cls. ...的新实例 如果在对象构造期间调用__new__()，它返回一个 实例，则新实例的__init__()方法将为 像__init__(self[，…])一样调用，…

__init__ ():

在实例创建后调用(通过__new__())，… 因为__new__()和__init__()在构造对象时一起工作 (__new__()来创建它,__init__()来定制它),…

例如，在实例化Teacher类时，首先调用__new__()来创建Teacher类的实例，然后调用__init__()来初始化实例，如下所示:

class Teacher:
    def __init__(self, name):
        self.name = name
        
class Student:
    def __init__(self, name):
        self.name = name

obj = Teacher("John") # Instantiation

print(obj.name)

输出如下:

<class '__main__.Teacher'>
John

并且，使用Teacher类实例的__new__()，我们可以创建Student类的实例，如下所示:

# ...

obj = Teacher("John")
print(type(obj))
print(obj.name)

obj = obj.__new__(Student) # Creates the instance of "Student" class
print(type(obj))

现在，创建了Student类的实例，如下所示:

<class '__main__.Teacher'>
<__main__.Teacher object at 0x7f4e3950bf10>
<class '__main__.Student'> # Here

接下来，如果我们尝试从Student类的**实例中获取name变量的值，如下所示:

obj = Teacher("John")
print(type(obj))
print(obj.name)

obj = obj.__new__(Student)
print(type(obj))
print(obj.name) # Tries to get the value of "name" variable

发生以下错误是因为Student类的实例还没有被__init__()初始化:

AttributeError: 'Student'对象没有属性'name'

因此，我们初始化Student类的实例，如下所示:

obj = Teacher("John") 
print(type(obj))
print(obj.name)

obj = obj.__new__(Student)
print(type(obj))
obj.__init__("Tom") # Initializes the instance of "Student" class
print(obj.name)

然后，我们可以从Student类的实例中获取name变量的值，如下所示:

<class '__main__.Teacher'>
John
<class '__main__.Student'>
Tom # Here

然而，我有点困惑，为什么__init__总是在__new__之后被调用。

我认为c++的类比在这里是有用的:

__new__只是为对象分配内存。对象的实例变量需要内存来保存它，这就是步骤__new__要做的。 __init__将对象的内部变量初始化为特定的值(可以是默认值)。

__new__应该返回一个新的类的空白实例。然后调用__init__来初始化该实例。你没有在__new__的“NEW”情况下调用__init__，所以它是为你调用的。调用__new__的代码不会跟踪__init__是否在特定实例上被调用，也不应该跟踪，因为你在这里做了一些非常不寻常的事情。

你可以在__init__函数中为对象添加一个属性，以表明它已被初始化。检查该属性是否作为__init__中的第一个属性存在，如果已经存在，则不要继续进行任何操作。