参考这个文档:

在继承不可变内置类型(如数字和字符串)时， 偶尔在其他情况下，会出现静态方法__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:
...

__init__被调用在__new__之后，所以当你在子类中重写它时，你添加的代码仍然会被调用。

如果你试图子类化一个已经有__new__的类，不知道这一点的人可能会通过调整__init__开始，并将调用转发到子类__init__。这种在__new__之后调用__init__的约定有助于按预期工作。

__init__仍然需要允许超类__new__所需的任何参数，但如果不这样做，通常会产生一个明确的运行时错误。__new__可能应该显式地允许使用*args和'**kw'，以清楚地表明扩展是OK的。

在同一个类中同时拥有__new__和__init__在同一继承级别通常是不好的形式，因为原来的海报所描述的行为。

参考这个文档:

在继承不可变内置类型(如数字和字符串)时， 偶尔在其他情况下，会出现静态方法__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:
...

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

你可以在__init__函数中为对象添加一个属性，以表明它已被初始化。检查该属性是否作为__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:
  ...

在大多数知名的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

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