再深入一点!

CPython中泛型类的类型是type，它的基类是Object(除非你显式地定义了另一个基类，比如元类)。低级调用的序列可以在这里找到。第一个调用的方法是type_call，然后调用tp_new和tp_init。

这里有趣的部分是tp_new将调用对象的(基类)new方法object_new，该方法执行tp_alloc (PyType_GenericAlloc)，为对象分配内存:)

此时在内存中创建对象，然后调用__init__方法。如果__init__没有在你的类中实现，那么object_init会被调用，它什么都不做:)

然后type_call只返回绑定到变量的对象。

@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__步骤，则需要标记对象。

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中的不可变类型。

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

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

我知道这个问题很老了，但我也遇到过类似的问题。 以下是我想要的:

class Agent(object):
    _agents = dict()

    def __new__(cls, *p):
        number = p[0]
        if not number in cls._agents:
            cls._agents[number] = object.__new__(cls)
        return cls._agents[number]

    def __init__(self, number):
        self.number = number

    def __eq__(self, rhs):
        return self.number == rhs.number

Agent("a") is Agent("a") == True

我使用这个页面作为资源http://infohost.nmt.edu/tcc/help/pubs/python/web/new-new-method.html

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

没有太多的原因，除了它就是这样做的。__new__没有初始化类的责任，其他一些方法有(__call__，可能——我不确定)。

我没想到会这样。有人能告诉我为什么会发生这种情况，以及我如何实现这个功能吗?(除了将实现放在__new__中，这感觉相当粗糙)。

如果__init__已经初始化，你可以让它什么都不做，或者你可以用一个新的__call__写一个新的元类，它只在新实例上调用__init__，否则只返回__new__(…)。