这个问题不是为了讨论是否需要单例设计模式，是否是反模式，还是针对任何宗教战争，而是要讨论如何以最pythonic的方式在Python中最好地实现此模式。在这种情况下，我将“最pythonic”定义为表示它遵循“最少惊讶的原理”。

我有多个将成为单例的类（我的用例用于记录器，但这并不重要）。当我可以简单地继承或修饰时，我不希望增加gumph来使几个类杂乱无章。

最佳方法：

方法1：装饰器

def singleton(class_):
    instances = {}
    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]
    return getinstance

@singleton
class MyClass(BaseClass):
    pass

优点

• 装饰器的添加方式通常比多重继承更直观。

缺点

• 使用MyClass（）创建的对象将是真正的单例对象，而MyClass本身是一个函数，而不是类，因此您不能从中调用类方法。也就m = MyClass(); n = MyClass(); o = type(n)();这样m == n && m != o && n != o

方法2：一个基类

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

优点

• 这是一个真正的课堂

缺点

• 多重继承-好！__new__从第二个基类继承期间可能被覆盖？人们必须思考的超出了必要。

方法3：元类

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

#Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

#Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

优点

• 这是一个真正的课堂
• 自动神奇地涵盖继承
• 利用__metaclass__它的正确用途（使我意识到这一点）

缺点

• 有吗

方法4：装饰器返回具有相同名称的类

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                                    class_).__new__(class_,
                                                    *args,
                                                    **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(BaseClass):
    pass

优点

• 这是一个真正的课堂
• 自动神奇地涵盖继承

缺点

• 创建每个新类没有开销吗？在这里，我们为希望创建单例的每个类创建两个类。虽然这对我来说很好，但我担心这可能无法扩展。当然，要扩展这种模式是否太容易了还有争议。
• _sealed属性的重点是什么
• 无法使用调用基类上同名的方法，super()因为它们会递归。这意味着您无法自定义__new__，也无法将需要调用的类作为子类__init__。

方法5：一个模块

一个模块文件 singleton.py

优点

• 简单胜于复杂

缺点

使用元类

我建议使用方法2，但最好使用元类而不是基类。这是一个示例实现：

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(object):
    __metaclass__ = Singleton

或在Python3中

class Logger(metaclass=Singleton):
    pass

如果要在__init__每次调用类时运行，请添加

        else:
            cls._instances[cls].__init__(*args, **kwargs)

对中的if陈述Singleton.__call__。

关于元类的几句话。元类是类的类 ; 也就是说，类是其元类的实例。您可以使用来找到Python中对象的元类type(obj)。普通的新式类是类型type。Logger上面代码中的将会是type class 'your_module.Singleton'，就像的（唯一的）实例Logger将是type一样class 'your_module.Logger'。当你调用记录仪与Logger()，Python的首先要求的元类Logger，Singleton，做什么，允许实例创建要捷足先登。此过程与Python __getattr__通过执行以下操作引用类的一个属性时调用类来询问类的方法相同：myclass.attribute。

元类从本质上决定了类定义的含义以及如何实现该定义。参见例如http://code.activestate.com/recipes/498149/，它实质上是struct使用元类在Python中重新创建C风格的。线程元类的一些（具体）用例是什么？还提供了一些示例，它们通常似乎与声明性编程有关，尤其是在ORM中使用的声明性编程。

在这种情况下，如果您使用方法2，并且子类定义了一个__new__方法，则每次调用时都会执行SubClassOfSingleton()该方法-因为它负责调用返回存储实例的方法。对于元类，仅在创建唯一实例时才调用一次。您想自定义调用类的含义，该类由类的类型决定。

通常，使用元类实现单例是有意义的。单例很特别，因为它只能创建一次，而元类是自定义类创建的方式。如果需要以其他方式自定义单例类定义，则使用元类可以提供更多控制权。

您的单例不需要多重继承（因为元类不是基类），但是对于使用多重继承的已创建类的子类，您需要确保单例类是第一个/最左边的一个具有重新定义的元类的类。__call__这不太可能成为问题。实例dict 不在实例的名称空间中，因此不会意外覆盖它。

您还将听到单例模式违反了“单一责任原则”-每个类只能做一件事。这样，您就不必担心如果需要更改另一代码，便会弄乱代码要做的一件事，因为它们是分开封装的。元类实现通过了此测试。元类负责执行模式，创建的类和子类无需知道它们是单例。正如您在“ MyClass本身是一个函数而不是一个类，因此您无法从中调用类方法”中指出的那样，方法＃1未能通过该测试。

Python 2和3兼容版本

编写适用于Python2和3的东西需要使用稍微复杂一些的方案。由于元类通常是type的子类type，因此可以使用一个在运行时动态创建中介基类并将其作为元类，然后将其用作公共Singleton基类的基类。如下所示，这比做起来难解释。

# works in Python 2 & 3
class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})): pass

class Logger(Singleton):
    pass

具有讽刺意味的是，这种方法使用子类来实现元类。一个可能的优点是，与纯元类不同，isinstance(inst, Singleton)它将返回True。

更正

在另一个主题上，您可能已经注意到了这一点，但是原始文章中的基类实现是错误的。_instances需要在类上引用，您需要使用super()或递归，并且__new__实际上是一个静态方法，您必须将类传递给，而不是类方法，因为尚未在其上创建实际的类叫做。所有这些对于元类实现也是正确的。

class Singleton(object):
  _instances = {}
  def __new__(class_, *args, **kwargs):
    if class_ not in class_._instances:
        class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
    return class_._instances[class_]

class MyClass(Singleton):
  pass

c = MyClass()

室内设计师返校

我本来是在写评论，但评论太长了，因此我将在此处添加。方法4比其他装饰器版本更好，但是它的代码比单例所需的代码更多，并且不清楚它的功能。

主要问题源于该类是它自己的基类。首先，让一个类成为几乎完全相同的类的子类不是很奇怪__class__吗？这也意味着你不能定义调用同名的方法对它们的基类的任何方法用super()，因为他们会重复。这意味着您的类无法自定义__new__，并且不能从需要对其__init__调用的任何类派生。

何时使用单例模式

您的用例是想要使用单例的更好示例之一。您在其中一项评论中说：“对我而言，伐木一直是Singletons的自然选择。” 你说的对。

人们说单身人士很糟糕，最常见的原因是他们是隐性的共享状态。虽然全局变量和顶级模块导入是显式共享状态，但通常会实例化传递的其他对象。这是一个好点，但有两个例外。

第一个，并且在各个地方都被提及的，是单例是恒定的。全局常数（尤其是枚举）的使用已被广泛接受，并被认为是明智的，因为无论如何，任何用户都无法为其他任何用户弄乱它们。对于恒定的单例也同样如此。

第二个例外（相反，它被忽略了）是相反的-当单例仅仅是数据接收器，而不是数据源（直接或间接）时。这就是为什么记录器感觉单例的“自然”使用。由于各种用户没有以其他用户关心的方式更改记录器，因此并没有真正的共享状态。这消除了反对单例模式的主要论点，并使其成为合理的选择，因为它们易于执行任务。

这是来自http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html的报价：

现在，有一种Singleton可以。那是所有可达对象都是不可变的单例。如果所有对象都是不可变的，则Singleton没有全局状态，因为一切都是恒定的。但是将这种单身人士变成易变的人是如此容易，这是很滑的坡度。因此，我也反对这些Singleton，不是因为它们不好，而是因为它们很容易变坏。（作为一个附带说明，Java枚举就是这些单例。只要您不将状态放入枚举中就可以，所以请不要这样做。）

另一种半可接受的单例是那些不影响代码执行的单例，它们没有“副作用”。日志记录就是一个很好的例子。它加载了Singletons和全局状态。这是可以接受的（因为它不会伤害您），因为无论是否启用给定的记录器，您的应用程序的行为都没有任何不同。此处的信息以一种方式流动：从您的应用程序进入记录器。甚至认为记录器是全局状态，因为没有信息从记录器流入您的应用程序，所以记录器是可以接受的。如果您想让测试断言某些东西正在被记录，那么您仍然应该注入记录器，但是一般来说，记录器即使处于满状态也不会有害。

class Foo(object):
     pass

some_global_variable = Foo()

模块仅导入一次，其他一切都考虑不周。不要使用单例并且不要使用全局。

使用模块。它仅导入一次。在其中定义一些全局变量-它们将是单例的“属性”。添加一些功能-单例的“方法”。

您可能永远不需要Python中的单例。只需在一个模块中定义所有数据和功能，便拥有事实上的单例。

如果您真的绝对必须要有一个单例课程，那么我可以考虑：

class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()

使用方法：

from mysingleton import my_singleton
my_singleton.foo()

其中mysingleton.py是定义My_Singleton的文件名。之所以起作用，是因为第一次导入文件后，Python不会重新执行代码。

这是您的一线客：

singleton = lambda c: c()

使用方法如下：

@singleton
class wat(object):
    def __init__(self): self.x = 1
    def get_x(self): return self.x

assert wat.get_x() == 1

您的对象会被实例化。这可能是您想要的，也可能不是。

看看Stack Overflow问题，是否有一种简单，优雅的方法在Python中定义单例？有几种解决方案。

我强烈建议观看Alex Martelli关于python设计模式的演讲：第1 部分和第2部分。特别是在第1部分中，他讨论了单例/共享状态对象。

这是我自己的单例实现。您所要做的就是装饰教室。要获得单例，则必须使用该Instance方法。这是一个例子：

   @Singleton
   class Foo:
       def __init__(self):
           print 'Foo created'

   f = Foo() # Error, this isn't how you get the instance of a singleton

   f = Foo.Instance() # Good. Being explicit is in line with the Python Zen
   g = Foo.Instance() # Returns already created instance

   print f is g # True

这是代码：

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Other than that, there are
    no restrictions that apply to the decorated class.

    To get the singleton instance, use the `Instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    Limitations: The decorated class cannot be inherited from.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def Instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `Instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

方法3看起来很整洁，但是如果您希望程序同时在Python 2和Python 3中运行，那么它将无法正常工作。即使使用Python版本的测试来保护单独的变体也失败了，因为Python 3版本在Python 2中给出了语法错误。

感谢Mike Watkins：http : //mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/。如果要使程序在Python 2和Python 3中都能工作，则需要执行以下操作：

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

MC = Singleton('MC', (object), {})

class MyClass(MC):
    pass    # Code for the class implementation

我认为作业中的“对象”需要替换为“ BaseClass”，但是我还没有尝试过（我尝试了如图所示的代码）。

好吧，除了同意关于模块级全局的Pythonic通用建议外，如何做到这一点：

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class2, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class2).__new__(class2, *args, **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(object):
    def __init__(self, text):
        print text
    @classmethod
    def name(class_):
        print class_.__name__

x = MyClass(111)
x.name()
y = MyClass(222)
print id(x) == id(y)

输出为：

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

这个怎么样：

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

将其用作应该为单例的类上的装饰器。像这样：

@singleton
class MySingleton:
    #....

这类似于singleton = lambda c: c()另一个答案中的装饰器。与其他解决方案一样，唯一的实例具有类（MySingleton）的名称。但是，使用此解决方案，您仍然可以通过执行从类“创建”实例（实际上是唯一的实例）MySingleton()。它还会阻止您这样做来创建其他实例type(MySingleton)()（这也会返回相同的实例）。

我将我扔进戒指。这是一个简单的装饰器。

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

我认为它具有一些其他解决方案的好处：

• 这是简洁明了的（在我看来； D）。
• 它的作用被完全封装。您无需更改的实现的任何事情YourClass。这包括不需要为您的类使用元类（请注意，上面的元类在工厂中，而不是“真实”类）。
• 它不依赖于猴子修补任何东西。
• 对呼叫者透明：
  • 调用者仍然简单地import YourClass，它看起来像一个类（因为是），并且可以正常使用它。无需使调用者适应工厂功能。
  • 什么YourClass()实例仍是的一个真正的实例YourClass您实现的，没有任何形式的代理，所以没有副作用的几率从产生。
  • isinstance(instance, YourClass) 并且类似的操作仍然可以按预期进行（尽管此位确实需要abc，因此排除了Python <2.6）。

我确实有一个缺点：实类的类方法和静态方法不能通过隐藏它的工厂类透明地调用。我已经很少使用了它，以至从未碰到过这种需求，但是通过在工厂上使用实现__getattr__()将所有属性访问权限委派给真实类的自定义元类，可以很容易地对其进行纠正。

我实际上发现的一个相关模式更有用（并不是说我经常需要这些东西）是“唯一”模式，其中使用相同的参数实例化该类会导致返回相同的实例。即“每个参数单”。上面的内容很好地适应了这一点，并且变得更加简洁：

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

综上所述，我确实同意以下一般性建议：如果您认为自己需要这些东西之一，则可能应该停一会儿，问问自己是否确实需要。YAGNI 99％的时间。

基于Tolli的答案的代码。

#decorator, modyfies new_cls
def _singleton(new_cls):
    instance = new_cls()                                              #2
    def new(cls):
        if isinstance(instance, cls):                                 #4
            return instance
        else:
            raise TypeError("I can only return instance of {}, caller wanted {}".format(new_cls, cls))
    new_cls.__new__  = new                                            #3
    new_cls.__init__ = lambda self: None                              #5
    return new_cls


#decorator, creates new class
def singleton(cls):
    new_cls = type('singleton({})'.format(cls.__name__), (cls,), {} ) #1
    return _singleton(new_cls)


#metaclass
def meta_singleton(name, bases, attrs):
    new_cls = type(name, bases, attrs)                                #1
    return _singleton(new_cls)

说明：

1. 创建新类，继承自给定的类cls
   （cls例如，在有人想要的情况下，它不会进行修改singleton(list)）

2. 创建实例。覆盖之前__new__是如此简单。

3. 现在，当我们轻松创建实例后，请__new__使用之前定义的方法进行覆盖。

4. 该函数instance仅在调用者期望的时候返回，否则抛出TypeError。
   当有人尝试从装饰类继承时，不满足该条件。

5. 如果__new__()返回的实例cls，那么新实例的__init__()方法将被调用一样__init__(self[, ...])，这里的自我是新实例，其余参数都一样传递给__new__()。

   instance已经被初始化，所以__init__功能被什么都不做的功能所取代。

看到它在线上工作

它与晶圆厂的答案有些相似，但并不完全相同。

该单合同并不要求我们能够多次调用构造函数。作为一个单例应该仅创建一次，是否不应该将其视为仅创建一次？“欺骗”构造函数无疑会损害可读性。

所以我的建议是这样的：

class Elvis():
    def __init__(self):
        if hasattr(self.__class__, 'instance'):
            raise Exception()
        self.__class__.instance = self
        # initialisation code...

    @staticmethod
    def the():
        if hasattr(Elvis, 'instance'):
            return Elvis.instance
        return Elvis()

这不排除instance用户代码对构造函数或字段的使用：

if Elvis() is King.instance:

...如果您确定Elvis还没有创建，那就已经创建了King。

但它鼓励用户the普遍使用该方法：

Elvis.the().leave(Building.the())

为了完成此操作，__delattr__()如果尝试删除instance，也可以重写以引发Exception ，并重写__del__()以引发Exception（除非我们知道程序正在结束...）

进一步的改进

感谢那些为评论和编辑提供帮助的人，我们欢迎其中的更多内容。当我使用Jython时，这应该更通用，并且是线程安全的。

try:
    # This is jython-specific
    from synchronize import make_synchronized
except ImportError:
    # This should work across different python implementations
    def make_synchronized(func):
        import threading
        func.__lock__ = threading.Lock()

        def synced_func(*args, **kws):
            with func.__lock__:
                return func(*args, **kws)

        return synced_func

class Elvis(object): # NB must be subclass of object to use __new__
    instance = None

    @classmethod
    @make_synchronized
    def __new__(cls, *args, **kwargs):
        if cls.instance is not None:
            raise Exception()
        cls.instance = object.__new__(cls, *args, **kwargs)
        return cls.instance

    def __init__(self):
        pass
        # initialisation code...

    @classmethod
    @make_synchronized
    def the(cls):
        if cls.instance is not None:
            return cls.instance
        return cls()

注意事项：

1. 如果您不从python2.x中的对象继承子类，则将获得一个老式的类，该类不使用 __new__
2. 装饰时，__new__您必须使用@classmethod装饰，否则__new__它将是未绑定的实例方法
3. 可以通过使用元类来改善这一点，因为这将使您能够创建the类级别的属性，并将其重命名为instance

一名班轮（我不为此感到自豪，但确实能胜任）：

class Myclass:
  def __init__(self):
      # do your stuff
      globals()[type(self).__name__] = lambda: self # singletonify

如果您不需要懒惰地初始化Singleton实例，则以下操作应该很容易且线程安全：

class A:
    instance = None
    # Methods and variables of the class/object A follow
A.instance = A()

这种方式A是在模块导入时初始化的单例。

• 如果一个人想拥有多个相同类的实例，但是只有当args或kwargs不同时，才可以使用它
• 例如
  1. 如果您有课程处理 serial通信，并且要创建一个实例，并且希望将串行端口作为参数发送，那么使用传统方法将无法正常工作
  2. 使用上述装饰器，如果args不同，则可以创建该类的多个实例。
  3. 对于相同的参数，装饰器将返回已经创建的相同实例。

>>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>

也许我误解了单例模式，但是我的解决方案是这个简单而实用的（pythonic？）。该代码实现了两个目标

1. 使实例可在Foo任何地方（全局）访问。
2. 只能Foo存在一个实例。

这是代码。

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

输出量

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

经过一段时间的努力，我最终想到了以下内容，以便从单独的模块中调用配置对象时，它只会被加载一次。元类允许将全局类实例存储在内置指令中，这在当前看来是存储适当程序全局的最简洁的方法。

import builtins

# -----------------------------------------------------------------------------
# So..... you would expect that a class would be "global" in scope, however
#   when different modules use this,
#   EACH ONE effectively has its own class namespace.  
#   In order to get around this, we use a metaclass to intercept
#   "new" and provide the "truly global metaclass instance" if it already exists

class MetaConfig(type):
    def __new__(cls, name, bases, dct):
        try:
            class_inst = builtins.CONFIG_singleton

        except AttributeError:
            class_inst = super().__new__(cls, name, bases, dct)
            builtins.CONFIG_singleton = class_inst
            class_inst.do_load()

        return class_inst

# -----------------------------------------------------------------------------

class Config(metaclass=MetaConfig):

    config_attr = None

    @classmethod
    def do_load(cls):
        ...<load-cfg-from-file>...

我不记得在哪里找到该解决方案，但是从我的非Python专家的角度来看，它是最“优雅”的：

class SomeSingleton(dict):
    __instance__ = None
    def __new__(cls, *args,**kwargs):
        if SomeSingleton.__instance__ is None:
            SomeSingleton.__instance__ = dict.__new__(cls)
        return SomeSingleton.__instance__

    def __init__(self):
        pass

    def some_func(self,arg):
        pass

我为什么喜欢这个？没有装饰器，没有元类，没有多重继承...，如果您决定不再希望它成为Singleton，只需删除该__new__方法。由于我是Python（和OOP的新手）的新手，所以我希望有人能使我明白为什么这是一种糟糕的方法？

这是我实现单例的首选方式：

class Test(object):
    obj = None

    def __init__(self):
        if Test.obj is not None:
            raise Exception('A Test Singleton instance already exists')
        # Initialization code here

    @classmethod
    def get_instance(cls):
        if cls.obj is None:
            cls.obj = Test()
        return cls.obj

    @classmethod
    def custom_method(cls):
        obj = cls.get_instance()
        # Custom Code here

这个答案可能不是您想要的。我想要一个单例，因为只有那个对象才具有其身份，以便进行比较。就我而言，它被用作前哨值。答案很简单，mything = object()根据python的性质制作任何对象，只有该对象才具有其标识。

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

该解决方案在模块级别上导致了一些名称空间污染（三个定义，而不仅仅是一个定义），但是我发现很容易遵循。

我希望能够编写这样的内容（延迟初始化），但不幸的是，类在其自身的定义中不可用。

# wouldn't it be nice if we could do this?
class Foo(object):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object()
            cls.instance.__class__ = Foo
        return cls.instance

由于这是不可能的，因此我们可以在其中分解初始化和静态实例

急切的初始化：

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        return foo_instance


foo_instance = FooMaker()
foo_instance.__class__ = Foo

延迟初始化：

急切的初始化：

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        global foo_instance
        if foo_instance is None:
            foo_instance = FooMaker()
        return foo_instance


foo_instance = None