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

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

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

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

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

参考这个文档:

在继承不可变内置类型(如数字和字符串)时， 偶尔在其他情况下，会出现静态方法__new__ 派上了用场。__new__是实例构造的第一步，被调用 __init__之前。

__new__方法是用类来调用的 第一个参数;它的职责是返回该函数的一个新实例 类。

将其与__init__进行比较:__init__是通过实例调用的 作为它的第一个参数，它不返回任何东西;它的 职责是初始化实例。

有一些情况 在没有调用__init__(例如 当实例从pickle加载时)。没有办法去创造 一个不调用__new__的新实例(尽管在某些情况下可以 不需要调用基类的__new__)。

关于你想要达到的目标，还有关于单例模式的相同文档信息

class Singleton(object):
        def __new__(cls, *args, **kwds):
            it = cls.__dict__.get("__it__")
            if it is not None:
                return it
            cls.__it__ = it = object.__new__(cls)
            it.init(*args, **kwds)
            return it
        def init(self, *args, **kwds):
            pass

您也可以使用PEP 318中的这个实现，使用装饰器

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

@singleton
class MyClass:
...

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

引用文件:

Typical implementations create a new instance of the class by invoking the superclass's __new__() method using "super(currentclass, cls).__new__(cls[, ...])"with appropriate arguments and then modifying the newly-created instance as necessary before returning it. ... If __new__() does not return an instance of cls, then the new instance's __init__() method will not be invoked. __new__() is intended mainly to allow subclasses of immutable types (like int, str, or tuple) to customize instance creation.