当__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的任何真实实例。

class M(type):
    _dict = {}

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

class A(object):
    __metaclass__ = M

    def __init__(self, key):
        print 'INIT'
        self.key = key
        print

a1 = A('aaa')
a2 = A('bbb')
a3 = A('aaa')

输出:

NEW
INIT

NEW
INIT

EXISTS

注意:作为一个副作用，M._dict属性会自动从a中作为a ._dict访问，所以注意不要顺便覆盖它。

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

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

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

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

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

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

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

当实例化一个类时，首先调用__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